Consultando PlatziBlog

Un pequeño ayuda memorias:

Este buen hombre ha resumido 1 año de asignatura universitaria en 39 vídeos, es admirable

Estuve leyendo la funcion GROUP_CONCAT, es interesante la clausula DISTINCT. Por ejemplo en donde queremos obtener en que categorias aporto un usuario con los posts para que no se repita hacer: GROUP_CONCAT(DISTINCT nombre_categoria)

SELECT u.nickname, COUNT(*) AS cant_posts, GROUP_CONCAT(DISTINCT nombre_categoria)
FROM usuarios AS u
	INNER JOIN posts AS p ON u.id = p.usuario_id
	INNER JOIN categorias AS c ON c.id = p.categoria_id
GROUP BY u.id
ORDER BY cant_posts DESC
;

07:19 para que la consulta no muestre categorías repetidas usamos DISTINCT.

SELECT u.nickname, COUNT(*) cant_posts, GROUP_CONCAT(DISTINCT nombre_cateogria)
FROM usuarios AS u
...
... 

Desde la clase anterior antes de que el sensei dé la respuesta yo pauso el video y lo resuelvo como yo me imagino, pude con todos los ejercicios y gracias a ello entendí bien las formulaciones de las queries, súper buenas las últimas lecciones, bueno, todas, en general. Gracias, sensei!

Mi solución al desafío de mostrar que usuarios no han escrito ningún post antes de ver la clase 💪🏼

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

Un aporte, al agregar el comando distinct dentro de group_concat se evita que se repitan los valores separados por coma.
Saludos

select u.nickname, count(*)cant_posts, GROUP_CONCAT(distinct(nombre))
from usuarios AS u
	inner join posts AS p ON u.id = p.usuario_id
    inner join categorias AS c ON c.id = p.categoria_id
group by u.id
order by cant_posts DESC

Resultado:
Moni 9 Deportes,Tecnología,Ciencia,Economía
Israel 6 Tecnología,Economía,Deportes
Ed 4 Espectáculos
Lau 2 Ciencia

En esto:
FROM categorias AS c
se puede omitir el AS y funciona
FROM categorias c

Me ha sido un poco complicado comprender los JOIN, pero nada que la práctica no resuelva!!!

RESUMEN DE LOS QUERIES 😃
Andaba buscando este comentario, como no lo encontré lo hice, espero les sirva para su proceso de aprendizaje

-- Mostrar el número de posts que tiene cada categoría.
SELECT c.nombre_categoria, COUNT(*) AS numero_posts
    FROM posts as p
    LEFT JOIN categorias AS c ON c.id = p.categoria_id
    GROUP BY p.categoria_id;
--****************************************************************************************
--Mostrar sólo la categoría con más posts
SELECT c.nombre_categoria, COUNT(*) AS num_posts 
FROM posts as p 
LEFT JOIN categorias AS c ON c.id = p.categoria_id 
GROUP BY p.categoria_id 
ORDER BY num_posts 
DESC LIMIT 1;
--****************************************************************************************
--qué usuario está creando más posts en el sistema
SELECT u.nickname, COUNT(*) AS num_posts
FROM usuarios AS u
LEFT JOIN posts AS p ON p.usuario_id = u.id
GROUP BY u.id
ORDER BY num_posts DESC;
--****************************************************************************************
--qué usuario está creando más posts en el sistema y de qué categorías ha escrito.
SELECT u.nickname, COUNT(*) AS num_posts, GROUP_CONCAT(nombre_categoria) AS nom_categoria
FROM usuarios AS u
LEFT JOIN posts AS p ON p.usuario_id = u.id
LEFT JOIN categorias AS c ON p.categoria_id = c.id
GROUP BY u.id
ORDER BY num_posts DESC;
--****************************************************************************************
-- Usuarios que no han escrito ningún post
SELECT *
FROM usuarios as u
LEFT JOIN posts AS p ON u.id = p.usuario_id
WHERE p.usuario_id IS NULL

No entendía por qué ponías “WHERE posts.usuario_id IS NULL” en el último ejercicio, si en realidad el usuario_id existía (el del amigo perezoso).

Me quebré el coco un rato, pero luego entendí que cuando un LEFT JOIN no tiene correspondencia en otra tabla todos los valores de esa tabla correspondiente son NULL, incluso la llave que en teoría los relaciona.

Buen ejercicio para mis neuronas jaja.

es un buen curso sin embargo considero que aveces suele enredar el hecho que la consulta no se realiza exactamente en el orden en que se van agregando los temas, seria mejor que con forme se vaya explicando las propiedades en la clase, se modifique cada parte de la consulta.

Para mí ha sido un poco extraño encontrar que el lenguaje no es tan universal como pensaba. Varias veces he tenido que buscar cómo hacer algo específicamente en SQL Server porque tal y como lo escribe el profe no funciona.

Por ejemplo no existe GROUP_CONCAT, hay que utilizar otra función que es STRING_AGG. Pero siento que el enfrentarme a este tipo de retos hace que aprenda mejor la lógica del lenguaje, cosa que no pasaría si solo trascribiera.

He conocido algunos detractores de la Normalización que se basan en los costosos JOIN que hay que realizar para recombinar los datos en la forma apropiada para contestar la mayoría de las preguntas.
Dependiendo de la volatilidad de un sistema en particular y de la naturaleza y frecuencia de las preguntas, una solución podría ser construir una tabla temporal donde se hubieran ejecutado los JOIN necesarios y donde se tendrían de forma directa los datos apropiados para responder tales preguntas con querys sencillos (sin JOIN y desde una sola tabla).

Si alguno les da este error:
Error Code: 1055 incompatible with sql_mode=only_full_group_by.
Pueden solucionarlo de la siguente forma:
SET sql_mode=(SELECT REPLACE(@@sql_mode,‘ONLY_FULL_GROUP_BY’,’’));
Ojo, estoy usando Mysql versión 14.14 en Ubuntu.
Aquí la fuente:
https://stackoverflow.com/questions/36207042/error-code-1055-incompatible-with-sql-mode-only-full-group-by

Para que la consulta no muestre categorías repetidas usamos DISTINCT

Me parece genial porque hasta este punto ya tenemos los superpoderes de poder manipular los datos de una base de datos de forma super sencilla, y el único limite es la imaginación, en serio que ya podemos hacer cosas super interesantes xD

Y reafirmo lo que dice el profesor, ¡practica! porque con base en la experiencia es que irás aprendiendo ^^

Sin duda que este curso me está ayudando mucho. Hace meses lo venía arrastrando porque se me hacía un poco pesado absorber la información.

Las bases de datos, los diagramas y la forma de pensarlo eran algo nuevo para mí.

El profesor explica muy bien, una sugerencia seria haber explicado como se introdujeron los datos.

el profe es un crack

me atoré con los JOIN, pero sigo practicando

Encontré este repositorio de Github con ejercicios de SQL, les recomiendo bastante que lo usen. Está en inglés, eso claramente es un Plus. Inicia con lo más sencillo, pero a medida que vamos solucionando los problemas se pone más complicado.

.

También está Hackerrank, las preguntas son muy buenas porque nos vamos preparando para preguntas de una entrevista de trabajo

👾

Para los que quieran jugar un poco directamente con SQL en un programa con algún lenguaje en especial (como Python) pueden probar SQLite 3. Es una librería escrita en C que ofrece todo el poder de SQL sin un servidor y corriendo dentro de la aplicación misma. Es una buena forma de practicar e implementar lo aprendido en un app de verdad.
No crean que porque tiene la palabra ‘Lite’ en el nombre no ofrece todo el poder de SQL, muchas aplicaciones grandes lo usan y es común encontrarlo en mobile y desktop.
https://www.sqlite.org/index.html
https://docs.python.org/3/library/sqlite3.html

Coloco la base de datos propia que trabajé hasta este punto.

Query:

Diagrama físico:

Estoy súper feliz con este curso 😃 no sabía nada de este tema y ahora ya puedo estructurar queries. Me gusta mucho jugar pokemon, así que realicé una BD con los pokes que utilizo en una de las ligas. Mi pregunta fue ¿Cuál es el tipo predominante en mi equipo? (son 50 pokes) Casi brinco de alegría cuando si corrió lo que escribí ❤️

select tipos.nombre, count(*) frecuencia_tipos
from tipos
inner join pokemon_tipos on tipos.id=pokemon_tipos.tipo_id
inner join pokemon on pokemon.id=pokemon_tipos.pokemon_id
group by tipos.nombre
order by frecuencia_tipos desc
limit 1;

Interesante el progreso que se logra realizar hasta este punto, yo ya tenía algo de experiencia con bases de datos, pero he aprendido varias cosas nuevas, como el funcionamiento adecuado de las tablas pivote, los efectos que se pueden añadir a las llaves foráneas, unir consultas mediante Unión, la diferencia practica entre los distintos tipos de Join y muchas otras cosas. Muchas gracias por compartir estos conocimientos y todavía falta más del curso.
 
Respecto a los alias, son una buena forma de ahorrar tiempo al no tener que volver a escribir los nombres, pero en consultas grandes puede volverse confuso si solo se usa letras, por tal razón yo uso unas términos clave para identificar los alias, por ejemplo:
 
tbCate – tabla Categorías. Usando las dos primeras identifico que es, en este caso una tabla, si es una columna uso cl y si es un proceso almacenado sp. Las siguiente 4 letras corresponden a parte del nombre para ayudar en la identificación.

Muy buen curso, el profesor es muy claro y los ejemplos han sido bastante efectivos

Excelente todo lo aprendido hasta el momento en cuanto a bases de datos relacionales, muy buen profesor.

Lo que más me sorprendió fue encontrar a un profesor de bases de datos TAN bueno. Muchas gracias Platzi e Israel.

Este tema es completamente nuevo para mi y es increíble ver como ya logró hacer queries mas complejos y todo lo que he aprendido, el profe es excelente muy buen curso.
esta es una consulta a mi base de datos usando lo aprendido hasta ahora:

Se pone interesante pero complejo porque ahora hay que unir las tablas que separamos !

🤣

Añadí un pequeño detalle a la query que hizo Israel para presentar la cantidad de posts por usuario y las categorías. Como noté que se repetían, le añadí el comando DISTINC dentro del GROUP_CONCAT(DISTINCT nombre_categoria). Aquí dejo el código (los nombres de las tablas o columnas pueden variar un poco)

-- Presenta cuántos posts ha publicado cada usuario, 
-- así como las categorías de sus posts 
-- eliminando las categorías repetidas que produce 
-- GROUP_CONCAT utilizando DISTINCT en nombre_categoria

SELECT usuario.login , COUNT(posts.id) AS cant_posts, GROUP_CONCAT(DISTINCT nombre_categoria) AS categorias_usuario
FROM usuario
	INNER JOIN posts ON usuario.idUsuario = usuario_id
    INNER JOIN categorias ON posts.categoria_id = categorias.id
GROUP BY usuario.login
ORDER BY cant_posts DESC;```

Por si las quieren resolver antes de ver como las resuelve el profesor, les traigo las preguntas de este video:

1. ¿Cuáles son las categorías que tiene mas posts relacionadas? Ordenadas de mayor a menor.

2. ¿Cuántos posts tiene escritos cada usuario? Y también ordenarlo de mayor a menor

3. Modificar la pregunta 2 para saber que categoría escribe cada usuario.

4. ¿Qué usuarios no escribieron ningún post?

• Comparto una fuente que me pareció bastante buena para profundizar y tener más ejemplos sobre GROUP_CONCAT.
• Este sitio me pareció bueno para tener más formas de practicar lo aprendido: w3resource.

Les adjunto esta Cheatsheet para SQL que me encontre, espero les sirva.

To run sql files

source <filename>.sql;

Data Definition Language (DDL)

create database cheatsheet;

use cheatsheet;

show databases;

create table employee
(
    employee_id int primary key,              -- Setting primary key(1st method)
    first_name varchar(50),
    last_name varchar(50),
    dept_number int,
    age int,
    salary real
);

create table department
(
    dept_number int,
    dept_name varchar(50),
    dept_location varchar(50),
    emp_id int,
    primary key(dept_number)                -- Setting primary key(2nd method)
);

show tables;

describe employee;
desc employee;
show columns in employee;

rename table employee to employee_table;
alter table employee_table rename to employee;

alter table employee change column employee_id emp_id int;

alter table employee change column first_name first_name varchar(50) not null;

alter table employee add column salary real;

alter table employee drop column salary;

alter table employee modify column salary int;

truncate employee;

drop table department;

drop database cheatsheet;

Data Manipulation Language (DML)

insert into employee (employee_id, first_name, last_name, dept_number, age, salary) values (1, "Anurag", "Peddi", 1, 20, 93425.63);

insert into employee values (2, "Anuhya", "Peddi", 2, 20, 83425.63);

insert into employee (employee_id, first_name) values (3, "Vageesh");

update employee set salary = 1.1 * salary;

update employee set salary = 1.2 * salary where employee_id = 1;

delete from employee where employee_id = 2;

delete from employee;

set foreign_key_checks = 1;

set foreign_key_checks = 0;

Data Query Language (DQL)

select * from employee;

select employee_id, first_name from employee;

select employee_id, first_name from employee where age > 25;

select * from employee where salary > 3100;

select * from employee where salary >= 3100;

select * from employee where salary < 4500;

select * from employee where salary <= 4350;

select * from employee where salary > 3000 and salary < 4000;

select * from employee where salary between 3000 and 4000;

select * from employee where name like '%Jo%';          -- Similar to *Jo* in regrex

select * from employee where name like 'Jo_';           -- Similar to Jo. in regrex

Views

create view personal_info as select first_name, last_name, age from employees;

select * from personal_info;

update personal_info set salary = 1.1 * salary;

delete from personal_info where age < 40;

drop view personal_info;

Joins

select e.fname, p.pname from employees as e inner join project as p on e.eid = p.eid;

-- or

select e.fname, p.pname from employees as e join project as p on e.eid = p.eid;

select e.fname, p.pname from employees as e left outer join project as p on e.eid = p.eid
union
select e.fname, p.pname from employees as e right outer join project as p on e.eid = p.eid;

select e.fname, p.pname from employees as e left outer join project as p on e.eid = p.eid;

select e.fname, p.pname from employees as e right outer join project as p on e.eid = p.eid;

select e.fname, p.pname from employees as e left outer join project as p on e.eid = p.eid where p.pname is null;

select e.fname, p.pname from employees as e right outer join project as p on e.eid = p.eid where e.fname is null;

Aggregation

select sum(population) from city group by population;

select avg(population) from city group by population;

select district, count(district) from city group by district;

select max(population) from city group by population;

select min(population) from city group by population;

select stddev(population) from city group by population;

select group_concat(population) from city group by population;

Procedure

create procedure display_dbs()
show databases;

call display_dbs();

drop procedure display_dbs;

Transaction

start transaction;

savepoint sv_pt;

delete from city;       -- changing data in table

rollback to sv_pt;

release savepoint sv_pt;

commit;

Cloning

create table emp_dup like employee;

create table emp_dup select * from employee;

Access Controls

use mysql;
update user set authentication_string=PASSWORD("<new2-password>") where User='<user>';
flush privileges;

Programming

set @num = 10;
set @name = 'Anurag';

select @name;

set @n = 21;
select repeat("* ", @n := @n - 1) from information_schema.tables where @n > 0;

Miscellaneous

select round(3.141596, 3);

select repeat("* ", 20);

select rand();

select cast(23.01245 as signed);

select concat("Mahesh", " ", "Chandra", " ", "Duddu", "!");

select month("1998-12-30");

select year("1998-12-30");

Existe alguna forma de mostrar cual es la categoria con mas post y la que tiene menos post al mismo tiempo?

Para quienes se les dificultan los QUERYS y toda la parte practica pueden pracricar con estas paginas:

1. https://sqlbolt.com/
2. https://sqlzoo.net/

seria bueno que hubiera explicado la sentencia DISTINCT, para que no repitiera datos como en el caso de las consultas que se hicieron con group concat

Si están usandO postgreSQL como yo en vez de MySQL acá les va un dato.

No existe la funciÓn GROUP_CONCAT(), en cambio existe una función que opera de la misma manera y es la siguiente

string_agg(nombre_columna, ', ')

Intentar realizar la consulta antes de que el profesor lo haga es muy buena práctica.

Con GROUP_CONCAT podemos también usar los criterios; DISTINCT para evita duplicidad en los valores, ORDER BY para decidir el orden de concatenación del campo y SEPARATOR que es el separador a utilizar para separar los valores (por defecto, el separador es una coma “,”).

-- Mostrar las categorías de la tabla posts de forma descendente. A las tablas se les debe asignar un alias.
Select C.Nombre_Categoria, Count(*) As Cant
From categorias As C
	Inner Join posts As P On C.Id = P.Categorias_Id
Group By C.Id
Order By Cant Desc;

-- Mostrar cuales son las categorías que están escribiendo los usuarios.
Select usuarios.Nickname, Count(*) As Cant, 
	Group_Concat(Distinct categorias.Nombre_Categoria
				Order By categorias.Nombre_Categoria
				Separator " - ") As Nom_Categoria
From usuarios
	Inner Join posts On usuarios.Id = posts.Usuario_Id
	Inner Join categorias On categorias.Id = posts.Categorias_Id
Group By usuarios.Id
Order By Cant Desc;

-- Mostrar de cada categoría cuantos posts han escrito los usuarios y ordenarlos de formas descendente por nombre de usuario y cantidad.
Select usuarios.Nickname, categorias.Nombre_Categoria, Count(*) As Cant
From usuarios
	Inner Join posts On usuarios.Id = posts.Usuario_Id
	Inner Join categorias On categorias.Id = posts.Categorias_Id
Group By usuarios.Id, categorias.Id
Order By usuarios.Nickname, Cant Desc;

-- Mostrar los usuarios que han creado más posts en el sistema.
Select usuarios.Nickname, Count(*) As Cant
From usuarios
	Inner Join posts On usuarios.Id = posts.Usuario_Id
Group By usuarios.Id
Order By Cant Desc;

-- Mostrar los usuarios que no han escrito posts.
Select * From usuarios
	Left Join posts On usuarios.Id = posts.Usuario_Id
Where posts.Usuario_Id Is Null;

Uno de los elementos que siempre me ha sido difícil de comprender era el Having. Al fin comprendo que es muy similar al where, porque me permite establecer condiciones, aunque en este caso es en las agrupaciones.

Genial, no tenia ni idea del manejo de datos pero hasta ahora me a gustado, he entendido y veo que me servirá mucho en mis proyectos.

SELECT nacionalidad.nacionalidad AS nac, SUM(goles) AS num_goles
FROM  nacionalidad
	INNER JOIN futbolistas ON nacionalidad.id_nacionalidad = futbolistas.id_nacionalidad
WHERE goles > 0
GROUP BY nacionalidad
ORDER BY num_goles ASC;

Sorprende la cantidad de preguntas que sale de una base de datos (sobre todo ésta que tengo que no es muy grande). Acá quería ver las nacionalidades con más goles.

Mis queries, traba de hacerlos antes de que el profesor los hiciera para practicar:

– LAS CATEGORIAS QUE TIENEN MAS POSTS, ORDENADAS DE LAS QUE TIENEN MAS A MENOS
SELECT c.nombre_categoria, count(p.id) as numero_posts
FROM categorias c
INNER JOIN posts p ON p.categoria_id = c.id
group by c.nombre_categoria
order by numero_posts desc;

– QUE USUARIO ESTA CREANDO MÁS POSTS EN EL SISTEMA
SELECT u.nickname, count(p.id) as numero_posts
FROM usuarios u
INNER JOIN posts p ON p.usuario_id = u.id
group by u.nickname
order by numero_posts desc;

– QUE USUARIO ESTA CREANDO MÁS POSTS EN EL SISTEMA Y DE QUE CATEGORIA
SELECT u.nickname, count(p.id) as numero_posts, group_concat(c.nombre_categoria)
FROM usuarios u
INNER JOIN posts p ON p.usuario_id = u.id
INNER JOIN categorias c ON p.categoria_id = c.id
group by u.nickname
order by numero_posts desc;

– USUARIOS QUE NO HAN ESCRITO NINGUN POST
SELECT * FROM usuarios u
LEFT JOIN posts p ON p.usuario_id = u.id
WHERE p.usuario_id is null;

Consulta:
Cantidad de posts por categoría

SELECT c.nombre_categoria, COUNT(*) AS cant_posts
FROM categorias c, posts p
WHERE c.id = p.categoria_id
GROUP BY c.nombre_categoria
ORDER BY 2 DESC;

También se puede ordenar por indice de columnas en el GROUP BY, ya que en el SELECT vamos a mostrar 2 columnas, nombre_categoria y cant_posts, podemos definir que ordene por la segunda columna.

select posts_etiquetas.post_id as post_id, count(*) as etiquetas_quantity
from posts_etiquetas
groupby posts_etiquetas.post_id;```

<select Cantidad_Maquinas, count(*) as cant_cantidad
from Area_Pecho as C
inner join Area_Pierna as p on C.id = p.Cantidad_Maquinas
group by C.id 
order by Cant_cantidad desc;>

QUIEN COMENTA MAS

En el query para saber quien escribe de que tema yo le agregaría un distinct dentro del group_concat, de la siguiente manera:

select
	u.nickname
    ,count(*) as num_posts
    ,group_concat(distinct nombre) as etiq
from usuarios u
inner join posts p
	on u.id = p.usuario_id
inner join categorias c
	on c.id = p.categoria_id
group by 1
order by num_posts desc;

33. Mis apuntes sobre: “Consultando PlatziBlog”

-1. Ejemplo de Código SQL:

SELECT c.nombre_categoria,
COUNT(*) AS cant_posts
FROM categorias AS c
  INNER JOIN posts AS p ON c.id = p.categoria_id
GROUP BY c.id
ORDER BY cant_posts DESC
LIMIT 1;

-2. Ejemplo de Código SQL:

SELECT u.nickname,
COUNT(*) AS cant_posts,
GROUP_CONCAT(nombre_categoria)
FROM usuarios AS u
  INNER JOIN posts AS p ON u.id = p.categoria_id
  INNER JOIN categorias AS c ON c.id = p.categoria_id
GROUP BY u.id
ORDER BY cant_posts DESC;

-3. Ejemplo de Código SQL:

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

Me di cuenta que se puede obtener una lista unica con el GROUP_CONCAT si se le agrega un DISTINCT, espero les sirva

-- ¿De que categorías UNICAS escribe cada usuario?

SELECT u.id, u.login, u.nickname, u.email, COUNT(*) AS number_of_posts, GROUP_CONCAT(DISTINCT c.category_name ORDER BY c.category_name) AS categories_written
FROM users AS u
INNER JOIN posts AS p ON u.id = p.user_id
INNER JOIN categories AS c ON p.category_id = c.id
GROUP BY u.id;

interesante!
★★★★★

Excelente explicación

muy bueno los JOINS, entendi mas con esta clase.

lo mas interesante me parece el group concat

47. Consultando PlatziBlog

-- ordena en orden descendente la categoria del post
SELECT c.nombre_categoria, COUNT(*) AS cant_posts
FROM categorias AS c
INNER JOIN posts AS p ON c.id = p.categoria_id
GROUP BY c.id
ORDER BY cant_posts DESC;

-- ordena por escritor en descendente
SELECT u.nickname, count(*)cant_posts
FROM usuarios AS u
INNER JOIN posts AS p ON u.id = p.usuario_id
GROUP BY u.id
ORDER BY cant_posts DESC

;

-- de que escribe cada usuario
SELECT u.nickname, count(*)cant_posts, group_concat(nombre_categoria)
FROM usuarios AS u
INNER JOIN posts AS p ON u.id = p.usuario_id
inner join categorias as c on c.id = p.categoria_id
GROUP BY u.id
ORDER BY cant_posts DESC

;

-- usuarios sin posts
select*
from usuarios
 left join posts on usuarios.id = posts.usuario_id
where posts.usuario_id is null

;

En mi proyecto tomando como base el ejercicio de la clase anterior decidi preguntar de esa misma tabla cuales medicamentos no mostraban riesgo teratogenico y pedi que me lo ordenara los medicamentos de acuerdo a este riesgo (NULL, A, B, C, D).

Por otro lado me siento muy feliz lo que puedo hacer hasta ahora, todo gracias a las clases del profesor, cabe destacar que tiene una EXCELENTE METODOLOGIA DE ENSEÑANZA!!! gracias a las clases y a la practica ya puedo hacer muchas cosas…Gracias Profe!!! 😃

https://github.com/jesusdanielquiroga/Introduccion-Base-de-Datos.git

Segunda vez que me vuelve a pasar esto:

• Tomé dos días de descanso de este curso y he vuelto nuevamente.
• Israel sugiere una query y me propongo pausar el video para intentar realizar la query por mí mismo.
• Siento un poco de angustia por no recordar lo suficiente el código necesario para poder realizar la query.
• Logro hacer la query a la primera.

Me quedo atónito ante la idea de que, pese a no tener presente el código, aprendí a realizar queries.
Así que a esto llaman aprender? Se siente bien

Me demore mi tiempo en hacerla pero me muestra
el cliente que más ordenes realizó en la ciudad con más ventas.

select customer_id, first_name, store_id , ordenes
from (select c.customer_id, first_name, ord.store_id, count() ordenes
from customers c inner join orders ord
on c.customer_id = ord.customer_id
where ord.store_id = (select s.store_id from orders o
inner join stores s
on o.store_id = s.store_id
group by s.store_id
having count() = (select max(mayor_orden) from (select s.store_id, city, count(*) as mayor_orden from orders o
inner join stores s
on o.store_id = s.store_id
group by s.store_id, city ) ) )
group by c.customer_id, first_name, ord.store_id

                       having count(*) = (select max(ordenes) from (select  c.customer_id, first_name, ord.store_id, count(*) ordenes 
                                                                    from customers c   inner join orders ord
                                                                                       on c.customer_id = ord.customer_id
                                                                                       where ord.store_id = (select s.store_id from orders o
                                                                                                                    inner join stores s
                                                                                                                    on o.store_id = s.store_id
                                                                                                                    group by s.store_id 
                                                                                                                    having count(*) = (select max(mayor_orden) from (select s.store_id, city, count(*) as mayor_orden  from orders o
                                                                                                                                                                 inner join stores s
                                                                                                                                                                 on o.store_id = s.store_id
                                                                                                                                                                 group by s.store_id, city ) ) ) 
group by c.customer_id, first_name, ord.store_id ) ) );

Cuando colocamos un ALIAS a las tablas, no es necesario colocar siempre el AS, solo con escribirlo despues de la tabla que usaremos es suficiente:

• Cuando hice yo el ejercicio de platzi Blog no le puse el atributo Nickname sino Alias.
• Para no confundirnos con los alias, siento que es una practica usar minimo las dos iniciales de la (Entidad, Tabla), para no confundirnos con con otras tablas que inician igual. Aunque solo al leer el Script uno se da cuenta, creo que es reducir la carga cognitiva y hacernos la vida mas facil para saber mas rapido de donde sacamos los Datos, de donde hacemos la uniones y las Columnas qe estamos viendo de donde vienen.

SELECT us.alias, COUNT(*) AS posts_escritos, GROUP_CONCAT(ca.categoria)
FROM usuarios us 
	INNER JOIN posts p ON us.id = p.id_usuario
	INNER JOIN categorias ca ON ca.id = p.id_categoria
GROUP BY us.id
ORDER BY posts_escritos DESC;

Si es muy bueno practicar, creando preguntas primero y luego pasarlas código,
Es mu importante conocer los datos para saber que se quiere responder

El video tiene un error para que funcione se debe hacer asi si se hace igual en la parte de nombre_categoria no existe esta columna solo existe nombre asi:

Estoy amando las BBDD, siento que he aprendido mucho en estas 39 clases.

Algo curioso que creo es que al principio pensé que JOIN casi no se iba a usar y miren ahora básicamente todas las consultas tienen a JOIN

Wow es impresionante lo que se puede hacer con las consultas!

😮🤯

Entendí todo bien, solo me quedó la duda de si aparte de que se muestran las categorías, por ejemplo las que están repetidas dentro del CONCAT más bien podría poner la categoría en frente un entre paréntesis con la cantidad de veces que posteo en esa categoría. Supongo que no, pero es solo una duda irrelenvante. Muchas gráficas por el curso hasta ahora. Me siento poderosa sabiendo esto, aunque llegar hasta aquí particularmente para mí que tomo nota y trato de entender todo, fue en verdad un esfuerzo.

Dejaré mi mayor obstáculo aquí a ver si a alguien más le pasa:
Me cuesta mucho recordar los nombres de las tablas y columnas a pesar de que les puse nombres bien específicos y explicativos. También me cuesta realizar operaciones con tablas combinadas, ya que no distingo tan bien cuándo usar un left join o un right join. 😕

Otra solución al primer ejercicio

SELECT p.post_id, c.categoria, COUNT(*) AS cant_posts
FROM post as p
	LEFT JOIN categorias AS c ON p.categoria_id = c.categoria_id
GROUP BY c.categoria
ORDER BY cant_posts DESC;

Este es uno de los mejores cursos que he visto hasta ahora.

Más cursos con este nivel de pedagogía!, esta excelente el curso 😄

Excelente curso, definitivamente requiere de bastante practica. Pero muy bueno por encima de todo.

sencillo y claro

Muy buena clase

Excelente clase!!

excelente maestro!

Muy buena clase.

de lujo

un poquito entendible!! pero poco a poco se hara mas facil!!

Puedes usar una abreviación para evitar escribir lo mismo cada vez.
Ejemplo:

FROM categorias AS c

Que increible esto de las consultas

Dentro de las queries la primera de este video me pareció bastante compleja y trate de buscar la forma de hacerla mas simple y con menos codigo, pero falle en el intenti 😃.

Pero cuales son los cursos a los que te refieres?

Excelente video

Muchas gracias, ahora comprendo mejor los diagramas de Venn 😃

Ya sabemos como miden nuestro rendimiento con estos aportes!

un gran profesor, lo hace fácil sobre todo muy entendible… a por más.

El uso de alias no lo conocia. Me parece una buen practica.

El mejor curso de bases de datos

que lindo el uso de los alias realmente ayuda mucho

GROUP_CONCAT es lo mas interesante y el uso de los diferentes JOINS es la clave

Los JOIN son los que más me llamaron la atención.

buena clase

Me declaro fan de Oso Pérez, alias Perezoso!!!

SELECT p.nombre_producto AS producto_mas_vendido, SUM(dv.cantidad) AS total_vendido
FROM detalle_ventas dv
JOIN productos p ON dv.id_producto = p.id_producto
GROUP BY p.nombre_producto
ORDER BY total_vendido DESC
LIMIT 10;

Esta consulta selecciona el nombre del producto y la suma de las cantidades vendidas de ese producto. Luego, agrupa los resultados por nombre de producto y los ordena en orden descendente según la cantidad vendida. Finalmente, limita el resultado a 10 filas, que representará el producto más vendido.

Para que solo se muestra una vez la categoría en el GROUP_CONCAT:

SELECT u.nickname, count(*) as posts_qty, GROUP_CONCAT(DISTINCT c.category)
FROM users AS u
INNER JOIN posts as p ON u.id = p.user_id
INNER JOIN categories as c ON c.id = p.category_id
GROUP BY u.id
ORDER BY posts_qty DESC