Este buen hombre ha resumido 1 año de asignatura universitaria en 39 vídeos, es admirable
Bienvenida conceptos básicos y contexto histórico de las Bases de Datos
Bienvenida conceptos básicos y contexto histórico de las Bases de Datos
Playground: tu primera consulta en bases de datos
Introducción a las bases de datos relacionales
Qué son entidades y atributos
Historia de las bases de datos relacionales
Entidades de Platzi Blog
Relaciones
Múltiples muchos
Diagrama ER
Diagrama Físico: tipos de datos y constraints
Diagrama Físico: normalización
Formas normales en Bases de Datos relacionales
Diagrama Físico: normalizando Platziblog
RDBMS (MySQL) o cómo hacer lo anterior de manera práctica
¿Qué es RDB y RDBMS?
Instalación local de un RDBMS (Windows)
Instalación local de un RDBMS (Mac)
Instalación local de un RDBMS (Ubuntu)
Clientes gráficos
Servicios administrados
SQL hasta en la sopa
Historia de SQL
DDL create
Playground: CREATE TABLE
CREATE VIEW y DDL ALTER
DDL drop
Playground: VIEW, ALTER y DROP en SQL
DML
Playground: CRUD con SQL
¿Qué tan standard es SQL?
Creando Platziblog: tablas independientes
Creando Platziblog: tablas dependientes
Creando Platziblog: tablas transitivas
Consultas a una base de datos
¿Por qué las consultas son tan importantes?
Estructura básica de un Query
SELECT
Playground: SELECT en SQL
FROM y SQL JOINs
Utilizando la sentencia FROM
Playground: FROM y LEFT JOIN en SQL
WHERE
Utilizando la sentencia WHERE nulo y no nulo
Playground: Filtrando Datos con WHERE
GROUP BY
ORDER BY y HAVING
Playground: Agrupamiento y Ordenamiento de Datos
El interminable agujero de conejo (Nested queries)
¿Cómo convertir una pregunta en un query SQL?
Preguntándole a la base de datos
Consultando PlatziBlog
Playground: Prueba Final con PlatziBlog
Introducción a la bases de datos NO relacionales
¿Qué son y cuáles son los tipos de bases de datos no relacionales?
Servicios administrados y jerarquía de datos
Manejo de modelos de datos en bases de datos no relacionales
Top level collection con Firebase
Creando y borrando documentos en Firestore
Colecciones vs subcolecciones
Recreando Platziblog
Construyendo Platziblog en Firestore
Proyecto final: transformando tu proyecto en una db no relacional
Bases de datos en la vida real
Bases de datos en la vida real
Big Data
Data warehouse
Data mining
ETL
Business intelligence
Machine Learning
Data Science
¿Por qué aprender bases de datos hoy?
Bonus
Bases de datos relacionales vs no relacionales
Elegir una base de datos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Puedes usar una abreviación para evitar escribir lo mismo cada vez.
Ejemplo:
FROM categorias AS c
Aportes 308
Preguntas 92
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!
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
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
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!!!
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.
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
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.
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 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).
me atoré con los JOIN, pero sigo practicando
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í.
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 ^^
Coloco la base de datos propia que trabajé hasta este punto.
El profesor explica muy bien, una sugerencia seria haber explicado como se introdujeron los datos.
el profe es un crack
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.
Les adjunto esta Cheatsheet para SQL que me encontre, espero les sirva.
<h1>MySQL cheatsheet</h1> <h3>General Commands</h3>To run sql files
source <filename>.sql;
create database cheatsheet;
<h4>Use Database</h4>
use cheatsheet;
<h4>Show Databases</h4>
show databases;
<h4>Create Table</h4>
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)
);
<h4>Show Tables</h4>
show tables;
<h4>Describe Table</h4>
describe employee;
desc employee;
show columns in employee;
<h4>Rename Table</h4>
rename table employee to employee_table;
alter table employee_table rename to employee;
<h4>Renaming Column</h4>
alter table employee change column employee_id emp_id int;
<h4>Add Constraint to Column</h4>
alter table employee change column first_name first_name varchar(50) not null;
<h4>Add Column</h4>
alter table employee add column salary real;
<h4>Drop Column</h4>
alter table employee drop column salary;
<h4>Modify the Datatype of column</h4>
alter table employee modify column salary int;
<h4>Truncate Table</h4>
truncate employee;
<h4>Drop Table</h4>
drop table department;
<h4>Drop Database</h4>
drop database cheatsheet;
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);
<h4>Insertion (Partial)</h4>
insert into employee (employee_id, first_name) values (3, "Vageesh");
<h4>Updating all rows</h4>
update employee set salary = 1.1 * salary;
<h4>Updating a specified row</h4>
update employee set salary = 1.2 * salary where employee_id = 1;
<h4>Delete a specified row</h4>
delete from employee where employee_id = 2;
<h4>Delete all rows</h4>
delete from employee;
<h4>Enabling foreign key checks</h4>
set foreign_key_checks = 1;
<h4>Disabling foreign key checks</h4>
set foreign_key_checks = 0;
select * from employee;
<h4>Select only specified columns</h4>
select employee_id, first_name from employee;
<h4>Select only few rows</h4>
select employee_id, first_name from employee where age > 25;
<h3>Where Clause</h3>
<h4>Greater than(>)</h4>
select * from employee where salary > 3100;
<h4>Greater than equal to(>=)</h4>
select * from employee where salary >= 3100;
<h4>Less than(<)</h4>
select * from employee where salary < 4500;
<h4>Less than equal to(<=)</h4>
select * from employee where salary <= 4350;
<h4>Range</h4>
select * from employee where salary > 3000 and salary < 4000;
<h4>BETWEEN and AND</h4>
select * from employee where salary between 3000 and 4000;
<h4>Like Operator</h4>
select * from employee where name like '%Jo%'; -- Similar to *Jo* in regrex
select * from employee where name like 'Jo_'; -- Similar to Jo. in regrex
create view personal_info as select first_name, last_name, age from employees;
<h4>Displaying view</h4>
select * from personal_info;
<h4>Updating in view</h4>
update personal_info set salary = 1.1 * salary;
<h4>Deleting record from view</h4>
delete from personal_info where age < 40;
<h4>Droping a view</h4>
drop view personal_info;
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;
<h4>Full outer join</h4>
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;
<h4>Left outer join</h4>
select e.fname, p.pname from employees as e left outer join project as p on e.eid = p.eid;
<h4>Right outer join</h4>
select e.fname, p.pname from employees as e right outer join project as p on e.eid = p.eid;
<h4>Left outer join - inner join</h4>
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;
<h4>Right outer join - inner join</h4>
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;
select sum(population) from city group by population;
<h4>Average function</h4>
select avg(population) from city group by population;
<h4>Count function</h4>
select district, count(district) from city group by district;
<h4>Maximum function</h4>
select max(population) from city group by population;
<h4>Minimum function</h4>
select min(population) from city group by population;
<h4>Standard deviation function</h4>
select stddev(population) from city group by population;
<h4>Group concat function</h4>
select group_concat(population) from city group by population;
create procedure display_dbs()
show databases;
<h4>Calling procedure</h4>
call display_dbs();
<h4>Drop procedure</h4>
drop procedure display_dbs;
start transaction;
<h4>Create savepoint</h4>
savepoint sv_pt;
delete from city; -- changing data in table
<h4>Rollback</h4>
rollback to sv_pt;
<h4>Releasing savepoint</h4>
release savepoint sv_pt;
<h4>Commiting changes</h4>
commit;
create table emp_dup like employee;
<h4>Duplicate a Table</h4>
create table emp_dup select * from employee;
use mysql;
update user set authentication_string=PASSWORD("<new2-password>") where User='<user>';
flush privileges;
set @num = 10;
set @name = 'Anurag';
<h4>Print them</h4>
select @name;
<h4>For loop</h4>
set @n = 21;
select repeat("* ", @n := @n - 1) from information_schema.tables where @n > 0;
select round(3.141596, 3);
<h4>Repeated concatenation</h4>
select repeat("* ", 20);
<h4>Random float</h4>
select rand();
<h4>Typecast to Int</h4>
select cast(23.01245 as signed);
<h4>Concatenation</h4>
select concat("Mahesh", " ", "Chandra", " ", "Duddu", "!");
<h4>Extract Month</h4>
select month("1998-12-30");
<h4>Extract Year</h4>
select year("1998-12-30");
Por si las quieren resolver antes de ver como las resuelve el profesor, les traigo las preguntas de este video:
¿Cuáles son las categorías que tiene mas posts relacionadas? Ordenadas de mayor a menor.
¿Cuántos posts tiene escritos cada usuario? Y también ordenarlo de mayor a menor
Modificar la pregunta 2 para saber que categoría escribe cada usuario.
¿Qué usuarios no escribieron ningún post?
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;```
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;
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;
Existe alguna forma de mostrar cual es la categoria con mas post y la que tiene menos post al mismo tiempo?
alos que el primer ejercicos no les funciono como ami por poner
"select c.nombre_categoria, count()" solo tienen que quitarle la parte de “_categoria” y les queda asi "select c.nombre, count()"
Me declaro fan de Oso Pérez, alias Perezoso!!!
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
Para quienes se les dificultan los QUERYS y toda la parte practica pueden pracricar con estas paginas:
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.
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.
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
-- 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!!! 😃
Segunda vez que me vuelve a pasar esto:
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:
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
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?