Bienvenida conceptos básicos y contexto histórico de las Bases de Datos

1

Bienvenida conceptos básicos y contexto histórico de las Bases de Datos

Introducción a las bases de datos relacionales

2

Historia de las bases de datos relacionales

3

Entidades y atributos

4

Entidades de Platzi Blog

5

Relaciones

6

Múltiples muchos

7

Diagrama ER

8

Diagrama Físico: tipos de datos y constraints

9

Diagrama Físico: normalización

10

Formas normales en Bases de Datos relacionales

11

Diagrama Físico: normalizando Platziblog

RDBMS (MySQL) o cómo hacer lo anterior de manera práctica

12

¿Qué es RDB y RDBMS?

13

Instalación local de un RDBMS (Windows)

14

Instalación local de un RDBMS (Mac)

15

Instalación local de un RDBMS (Ubuntu)

16

Clientes gráficos

17

Servicios administrados

SQL hasta en la sopa

18

Historia de SQL

19

DDL create

20

CREATE VIEW y DDL ALTER

21

DDL drop

22

DML

23

¿Qué tan standard es SQL?

24

Creando Platziblog: tablas independientes

25

Creando Platziblog: tablas dependientes

26

Creando Platziblog: tablas transitivas

Consultas a una base de datos

27

¿Por qué las consultas son tan importantes?

28

Estructura básica de un Query

29

SELECT

30

FROM

31

Utilizando la sentencia FROM

32

WHERE

33

Utilizando la sentencia WHERE nulo y no nulo

34

GROUP BY

35

ORDER BY y HAVING

36

El interminable agujero de conejo (Nested queries)

37

¿Cómo convertir una pregunta en un query SQL?

38

Preguntándole a la base de datos

39

Consultando PlatziBlog

Introducción a la bases de datos NO relacionales

40

¿Qué son y cuáles son los tipos de bases de datos no relacionales?

41

Servicios administrados y jerarquía de datos

Manejo de modelos de datos en bases de datos no relacionales

42

Top level collection con Firebase

43

Creando y borrando documentos en Firestore

44

Colecciones vs subcolecciones

45

Recreando Platziblog

46

Construyendo Platziblog en Firestore

47

Proyecto final: transformando tu proyecto en una db no relacional

Bases de datos en la vida real

48

Bases de datos en la vida real

49

Big Data

50

Data warehouse

51

Data mining

52

ETL

53

Business intelligence

54

Machine Learning

55

Data Science

56

¿Por qué aprender bases de datos hoy?

Bonus

57

Bases de datos relacionales vs no relacionales

58

Elegir una base de datos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Consultando PlatziBlog

39/58
Recursos

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

FROM categorias AS c

Aportes 238

Preguntas 69

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Un pequeño ayuda memorias:

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
;

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

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
...
... 

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

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

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.

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.

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

el profe es un crack

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

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í.

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

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).

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.

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 ^^

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

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.

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;

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;```

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

Query:

Diagrama físico:

  • 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.

<h1>MySQL cheatsheet</h1> <h3>General Commands</h3>

To run sql files

source <filename>.sql;

Data Definition Language (DDL)

<h4>Create Database</h4>
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;

Data Manipulation Language (DML)

<h4>Insertion (Complete)</h4>
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;

Data Query Language (DQL)

<h4>Display Table</h4>
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

Views

<h4>Create a view</h4>
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;

Joins

<h4>Inner join</h4>
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;

Aggregation

<h4>Sum function</h4>
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;

Procedure

<h4>Creating procedure</h4>
create procedure display_dbs()
show databases;
<h4>Calling procedure</h4>
call display_dbs();
<h4>Drop procedure</h4>
drop procedure display_dbs;

Transaction

<h4>Begin transaction</h4>
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;

Cloning

<h4>Duplicate a Table Schema</h4>
create table emp_dup like employee;
<h4>Duplicate a Table</h4>
create table emp_dup select * from employee;

Access Controls

<h4>Set new password to a user</h4>
use mysql;
update user set authentication_string=PASSWORD("<new2-password>") where User='<user>';
flush privileges;

Programming

<h4>Declare variables</h4>
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;

Miscellaneous

<h4>Round</h4>
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");

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

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

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, ', ')

me atoré con los JOIN, pero sigo practicando

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

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

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

🤣

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

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;

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:

interesante!
★★★★★

Excelente explicación

muy bueno los JOINS, entendi mas con esta clase.

lo mas interesante me parece el group concat

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

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!!!

Es muy interesante, y la estructura tal vez mas complicada de entender son los INNER JOIN, pero una vez comprendiendo el tema, son muy útiles en los proyectos reales.

Algo no se vio en detalle, es como como ingresar los datos que componen la base de datos. Es importante realizar este ejercicio para ir practicando y entender mucho mejor como crear una base de datos exitosa.

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?

En este curso he aprendido algo importante y muy cliché que muchas veces nos dicen y es:“De los errores se aprende”

Desde que comencé a usar MySQL para hacer el proyecto platziblog, como práctica en cada clase, me aprecian muchos errores que a simple vista no encontraba y me frustraba mucho, ya que decía “pero que estoy haciendo mal”, lo peor eran errores muy bobos como una coma, no haber seleccionado la base de datos, entonces cuando intentaba hacer algo me salía “No has seleccionado la base de datos”, errores así siempre me sucedían, pero es muy normal porque esta es mi primera vez utilizando estos programas, nunca me desanime, con ayuda y aprender de esos errores conseguí avanzar en este curso.

Para las personas que por primera vez está utilizando MySQL, no se desanimen por tener errores tan bobos y que no pueden notar a simple vista, siempre pasa, lo importante es que sepan cuál es error y corregirlo, obviamente aprender de ellos.

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

Consultas vistas en clase:

Excelente curso

  • World

¿ Cuales son los 10 continentes con mayor catidad de paises y meciona los paises?

Se me complican los JOIN pero a seguir practicando!

Un buen planteamiento de la pregunta es sumamente importante a la hora de aplicar un query

Buen día, si no les funciona la sentencia group_concat(nombre_categoria) porque les arroja el error 1054. Unknown column “nombre_categoria”, lo solucioné de la siguiente manera:

select nickname, count(*) cantidad_posts, group_concat(categorias.nombre)
from usuarios

No sé si para todos, pero en particular para mi la función de group_concat hoy día funciona cuando entre los paréntesis mencionas la tabla y la columna que se necesita.

Recordar: Le podemos dar un alias a las diferentes tablas que estoy utilizando, con el fin de no llenar el query o hacerlo tan largo, y más fácil de comprender.

No le veo utilidad pero me sirvio para entender bien

el nick_name con el título de los posts que ha publicado, sus categorías y sus labels

SELECT  u.nick_name as user, group_concat(labels.label_name) as labels, group_concat(c.category_name) as category, group_concat(p.title) as post_title
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
    INNER JOIN posts_labels ON p.id = posts_labels.post_id
    INNER JOIN labels ON labels.id = posts_labels.label_id
group by u.nick_name;

Salludos: ¡Es excelente este curso gracias a la estructura, metodologia y las aplicaciones derivadas del caso de uso.

Pregunta para el nickname = ‘Moni’

SELECT u.nickname, 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
WHERE u.nickname = 'Moni';

Resultado Moni.png
Salludos: ¡Es excelente este curso gracias a  la metodologia y las aplicaciones en el casos de uso!

Amigos es muy importante que aprendamos a fondo la sentencia Join y revisemos nuestra sinaxis!!

Cantidad de posts por categoria en usuario

select u.nickname, count(*) as cant_posts, group_concat(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
limit 1;