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

2

Playground: tu primera consulta en bases de datos

Introducción a las bases de datos relacionales

3

Qué son entidades y atributos

4

Historia de las bases de datos relacionales

5

Entidades de Platzi Blog

6

Relaciones

7

Múltiples muchos

8

Diagrama ER

9

Diagrama Físico: tipos de datos y constraints

10

Diagrama Físico: normalización

11

Formas normales en Bases de Datos relacionales

12

Diagrama Físico: normalizando Platziblog

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

13

¿Qué es RDB y RDBMS?

14

Instalación local de un RDBMS (Windows)

15

Instalación local de un RDBMS (Mac)

16

Instalación local de un RDBMS (Ubuntu)

17

Clientes gráficos

18

Servicios administrados

SQL hasta en la sopa

19

Historia de SQL

20

DDL create

21

Playground: CREATE TABLE

22

CREATE VIEW y DDL ALTER

23

DDL drop

24

Playground: VIEW, ALTER y DROP en SQL

25

DML

26

Playground: CRUD con SQL

27

¿Qué tan standard es SQL?

28

Creando Platziblog: tablas independientes

29

Creando Platziblog: tablas dependientes

30

Creando Platziblog: tablas transitivas

Consultas a una base de datos

31

¿Por qué las consultas son tan importantes?

32

Estructura básica de un Query

33

SELECT

34

Playground: SELECT en SQL

35

FROM y SQL JOINs

36

Utilizando la sentencia FROM

37

Playground: FROM y LEFT JOIN en SQL

38

WHERE

39

Utilizando la sentencia WHERE nulo y no nulo

40

Playground: Filtrando Datos con WHERE

41

GROUP BY

42

ORDER BY y HAVING

43

Playground: Agrupamiento y Ordenamiento de Datos

44

El interminable agujero de conejo (Nested queries)

45

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

46

Preguntándole a la base de datos

47

Consultando PlatziBlog

48

Playground: Prueba Final con PlatziBlog

Introducción a la bases de datos NO relacionales

49

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

50

Servicios administrados y jerarquía de datos

Manejo de modelos de datos en bases de datos no relacionales

51

Top level collection con Firebase

52

Creando y borrando documentos en Firestore

53

Colecciones vs subcolecciones

54

Recreando Platziblog

55

Construyendo Platziblog en Firestore

56

Proyecto final: transformando tu proyecto en una db no relacional

Bases de datos en la vida real

57

Bases de datos en la vida real

58

Big Data

59

Data warehouse

60

Data mining

61

ETL

62

Business intelligence

63

Machine Learning

64

Data Science

65

¿Por qué aprender bases de datos hoy?

Bonus

66

Bases de datos relacionales vs no relacionales

67

Elegir una base de datos

No tienes acceso a esta clase

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

Consultando PlatziBlog

47/67
Recursos

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

FROM categorias AS c

Aportes 308

Preguntas 92

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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.

Query:

Diagrama físico:

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;

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");

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?

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:

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

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

el query más complejo para mi, ha sido usar el JOIN con todas sus variantes. pero al final lo he entendido y estoy super contento.
Cuando asignamos un alias a una tabla es importante usar ese alias en todas las sentencias de lo contrario nos va a marcar un error
El que mas me cuesta usar es INNER JOIN, LEFT JOIN, EN FIN LOS "JOINS" en general...

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

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

`SELECT u.nickname, COUNT(*) cant_post, 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_idGROUP BY u.id   ORDER BY cant_posts DESC;` \-- *Partes de la consulta* \--*SELECT u.nickname, COUNT(\*) cant\_post* SELECT: La cláusula SELECT se utiliza para especificar las columnas que deseas recuperar de las tablas.u.nickname: Selecciona el campo nickname de la tabla usuarios (alias u). Este es el nombre del usuario que se mostrará en el resultado.COUNT(\*) cant\_post: La función agregada COUNT(\*) cuenta la cantidad total de registros (en este caso, publicaciones) que se encuentran en la tabla posts (vinculada a la tabla usuarios). El COUNT(\*) se utiliza sin condiciones específicas, lo que cuenta todos los posts de cada usuario. Este conteo se le da el alias cant\_post, que representa el número total de publicaciones realizadas por cada usuario.sql \--*FROM usuarios AS u* FROM usuarios AS u: Indica la tabla principal de la que se extraen los datos. En este caso, es la tabla usuarios.usuarios es la tabla donde se almacena la información sobre los usuarios.El alias u es un nombre corto asignado a la tabla usuarios, que facilita su uso en el resto de la consulta.sql \--*INNER JOIN posts AS p ON u.id = p.usuario\_id* INNER JOIN posts AS p: Esta cláusula realiza una unión interna (INNER JOIN) con la tabla posts (alias p). El INNER JOIN asegura que solo se incluyan aquellos usuarios que tienen al menos una publicación.posts es la tabla que almacena las publicaciones realizadas por los usuarios.El alias p es asignado a la tabla posts para facilitar su uso en la consulta.Condición de unión: ON u.id = p.usuario\_id. Esto especifica que la unión debe realizarse donde el campo id de la tabla usuarios coincida con el campo usuario\_id de la tabla posts. Es decir, relaciona cada usuario con las publicaciones que ha realizado.sql \--*GROUP BY u.id* GROUP BY u.id: La cláusula GROUP BY agrupa los resultados según el valor del campo id de la tabla usuarios.Esto significa que, en lugar de contar todas las publicaciones de manera general, se agrupan los resultados por cada usuario individualmente, de modo que la consulta cuenta las publicaciones de cada usuario por separado.u.id se utiliza como criterio de agrupación, ya que es el identificador único de cada usuario en la tabla usuarios.sql \--*ORDER BY cant\_post DESC* ORDER BY cant\_post DESC: Ordena los resultados en orden descendente (de mayor a menor) según la columna cant\_post, que es el conteo de publicaciones por usuario.DESC indica orden descendente (si no se especifica, el valor predeterminado es orden ascendente, ASC).Esto asegura que el usuario con más publicaciones aparecerá primero en los resultados.
Observo que aquí no usó la tabla intermedia
Realmente, lo más complejo fue entender que tipo de JOIN utilizar en cierto momento
Estas ultimas clases me animan a postear mas en los blogs.