Left JOIN

Resumen de la clase:

-- Uso del JOIN implícito
SELECT b.title, a.name
FROM authors AS a, books AS b
WHERE a.author_id = b.author_id
LIMIT 10;

-- Uso del JOIN explícito
SELECT b.title, a.name
FROM books AS b
INNER JOIN authors AS a
  ON a.author_id = b.author_id
LIMIT 10;

--  JOIN y order by (por defecto es ASC)
SELECT a.author_id, a.name, a.nationality, b.title
FROM authors AS a
JOIN books AS b
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
ORDER BY a.author_id DESC;

-- LEFT JOIN para traer datos incluso que no existen, como el caso del author_id = 4 que no tene ningún libro registrado.
SELECT a.author_id, a.name, a.nationality, b.title
FROM authors AS a
LEFT JOIN books AS b
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
ORDER BY a.author_id;

-- Contar número de libros tiene un autor.
-- Con COUNT (contar), es necesario tener un GROUP BY (agrupado por un criterio)
SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)
FROM authors AS a
LEFT JOIN books AS b
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

• Si usamos inner join (o solo join) nos muestra la info que existe en las dos tablas.
• Con left join nos muestra la información que esta en la tabla principal del from, y nos trae vacio si no existe en la otra tabla

Ame su comentario de "El orden me pone de medio de malas " jajajajajajaja No hay mejor forma de aprender que de esta forma, alguien que es totalmente transparente con lo que siente.

El INNER JOIN solo traerá los datos de las tablas que coincidan entre las 2, en cambio el LEFT JOIN trae todos los datos de la primera tabla, y los que no correspondan en la segunda les asignara un valor NULL, así si usáramos el INNER JOIN en el ultimo ejemplo, no traerá al autor con el id 4 por que este no posee un libro, por tanto no tiene relación entre su columna con alguna de la otra tabla, pero si usaramos el LEFT JOIN, si que traerá al autor pero en el campo/campos asignara un valor NULL, ya que este autor no tiene libros registrados a su nombre.

Me ha gustado demasiado como va el curso hasta ahora y lo mucho que se ha aprendido.

Pues creo que esto es como teoría de conjuntos, INNER solo nos trae la intersección, el LEFT nos trae todo lo perteneciente a la tabla de la izquierda más la intersección.

Creo que para tener buenos query nos va tocar dibujar diagramas de venn a mano jajajja

INNER JOIN: Devuelve todas las filas cuando hay al menos una coincidencia en ambas tablas.
LEFT JOIN: Devuelve todas las filas de la tabla de la izquierda, y las filas coincidentes de la tabla de la derecha.
RIGHT JOIN: Devuelve todas las filas de la tabla de la derecha, y las filas coincidentes de la tabla de la izquierda.
OUTER JOIN: Devuelve todas las filas de las 2 tablas, la izquierda y la derecha. También se llama FULL OUTER JOIN

Me salio el autor Freddy vega esperamos su libro!!

Esto es lo que pasa cuando usas el INNER JOIN, solo muestra los datos de A relacionados con B. A diferencia del LEFT JOIN que muestra todos los datos de A relacionados con B e incluso los que tienen dato vacío en la relación con B.

LEFT o RIGHT JOIN sirven mucho para encontrar la falta de información y saber utilizarla. 😄

"Hay que saber utilizar la falta de información cuando la faltad de información sea útil."
Beco

Cuando usamos inner join este excluye todas las “filas” que tienen valores null

Chuck Palahniuk desaparece! 😃

Increible esta clase, aprendi mucho a hacer querys interesantes, poco a poco se va quitando el miedo de hacer consultas complejas

Resumen de la Clase:
Operadores:

• Order by: Organiza los resultados, asc para ascendente y dsc para descendente.
• Group by: define cual es el dato único que no se repite y sobre el cual pivotea.

Tips:

• Left join e Inner Join son el 95% de los joins que haremos.
• Left join trae todo el contenido de la tabla pivote, nos permite ver si un elemento de la misma NO tiene elementos en común en el join.

Código:

--Clase 15 Comando Left Join

SELECT b.title, a.name
FROM authors AS a, books AS b
WHERE a.author_id = b.author_id
LIMIT 10;

-- Esta primera version es tolerada por MySql pero no es buena practica.

SELECT b.title, a.name
FROM books AS b
INNER JOIN authors as a 
    on a.author_id = b.author_id
LIMIT 10;

-- Estos dos queries son iguales.

SELECT a.author_id, a.name, a.nationality, b.title
FROM authors AS a 
JOIN books AS b 
    on b.author_id = a.author_id
WHERE author_id between 1 and 5;

-- Resultado  Column 'author_id' in where clause is ambiguous, corregimos el WHERE

SELECT a.author_id, a.name, a.nationality, b.title
FROM authors AS a 
JOIN books AS b 
    on b.author_id = a.author_id
WHERE a.author_id between 1 and 5
ORDER BY a.author_id;

-- Aqui usamos por primera vez el operador ORDER BY

SELECT a.author_id, a.name, a.nationality, b.title
FROM authors AS a 
LEFT JOIN books AS b 
    on b.author_id = a.author_id
WHERE a.author_id between 1 and 5
ORDER BY a.author_id;

-- Usamos left join para ver todos los datos de la tabla pivote, authors aunque no tengan libro 

SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)
FROM authors AS a 
LEFT JOIN books AS b 
    on b.author_id = a.author_id
WHERE a.author_id between 1 and 5
ORDER BY a.author_id;

-- Queremos juntar las tablas y contar cuantos libros tiene

SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)
FROM authors AS a 
LEFT JOIN books AS b 
    on b.author_id = a.author_id
WHERE a.author_id between 1 and 5
GROUP BY a.author_id
ORDER BY a.author_id;

-- Queremos juntar las tablas y contar cuantos libros tiene, agrupando por author_id```

Muy cierto lo de la falta de información, esta en este caso es útil, este left join nos indica que no hay un libro en existencia para ese autor, se agotó. Como analistas podemos relacionar esto y buscar en nuestra tabla de transacciones, hacer un join con books y authors, buscar solamente las de el autor que queremos, si vemos muchas ventas, deberíamos adquirir stock nuevo de ese autor, incrementará las ventas por la demanda y además nuestros clientes estarán más satisfechos al encontrar el ejemplar que buscaban.

JOIN.- Muestra solo los datos que están relacionados con amas tablas.
LEFT JOIN.- Muestra todos los datos, los que están y los que no se encuentran.

Cuando se utiliza JOIN en vez de LEFT JOIN, el resulta es que no muestra la informacion de quienes no tienen libros

SELECT a.author_id, a.name, a.nationality, b.title, COUNT(b.book_id)
FROM authors AS a 
JOIN books AS b ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5 
GROUP BY a.author_id
ORDER BY a.author_id DESC```

el left Join me recuerda mucho al BuscarV de Excel, te trae lo que está y lo que no. Al final es muy útil para contestar preguntas sobre algún indicador de negocio

Ya habiendo hecho mas de la mitad del curso, tengo suficientes motivos como para agradecerle al profesor alberto, aunque cuando comenzó, me costo el tema de las configuraciones de mysql, de ahí en adelante, fue todo conocimiento perfectamente transferido.

Entendido y aplicado

SELECT a.name, b.title FROM  authors AS a, books AS b WHERE b.author_id = a.author_id;

SELECT a.name, b.title FROM  authors AS a, books AS b WHERE b.author_id = a.author_id LIMIT 10;

SELECT a.name, b.title FROM  authors AS a LEFT JOIN books AS b ON b.author_id = a.author_id LIMIT 10;

SELECT a.author_id, a.name, a.nationality, b.title FROM  authors AS a INNER JOIN books AS b ON b.author_id = a.author_id WHERE a.author_id BETWEEN 1 AND 5 ;

SELECT a.author_id, a.name, a.nationality, b.title 
FROM  authors AS a INNER JOIN books AS b ON b.author_id = a.author_id 
WHERE a.author_id BETWEEN 1 AND 5 
ORDER BY a.author_id;

SELECT a.author_id, a.name, a.nationality, b.title 
FROM  authors AS a LEFT JOIN books AS b ON b.author_id = a.author_id 
WHERE a.author_id BETWEEN 1 AND 5 
ORDER BY a.author_id;

SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id) 'TOTAL BOOKS'
FROM  authors AS a LEFT JOIN books AS b ON b.author_id = a.author_id 
WHERE a.author_id BETWEEN 1 AND 5 
GROUP BY a.author_id, a.name, a.nationality
ORDER BY a.author_id;

Like te percataste que Freddy Vega esta entre los autores de la DB

😄

Los LEFT JOIN nos ayudan mucho para saber que datos nos faltan en nuesta aplicación, es decir por medio de esta relación podremos saber, en el ejemplo de los autores, qué autores (valga la redundancia) no tienen libros, y con ello podemos tomar decisiones como: se deben conseguir libros de estos autores para poder vender o alquilar.

mysql> SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)    -> FROM authors AS a    -> INNER JOIN books AS b
    ->     ON b.author_id = a.author_id
    -> WHERE a.author_id BETWEEN 1 AND 5
    -> GROUP BY a.author_id
    -> ORDER BY a.author_id desc;
+-----------+--------------------+-------------+------------------+
| author_id | name               | nationality | COUNT(b.book_id) |
+-----------+--------------------+-------------+------------------+
|         5 | Juan Rulfo         | MEX         |                1 |
|         3 | Arthur Conan Doyle | GBR         |                3 |
|         1 | Sam Altman         | USA         |                2 |
+-----------+--------------------+-------------+------------------+
3 rows in set (0.00 sec)

This happens:

mysql> SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id) AS total_books
    -> FROM authors AS a
    -> JOIN books AS b
    ->     ON b.author_id = a.author_id
    -> WHERE a.author_id BETWEEN 1 AND 5
    -> GROUP BY a.author_id
    -> ORDER BY total_books DESC;
+-----------+--------------------+-------------+-------------+
| author_id | name               | nationality | total_books |
+-----------+--------------------+-------------+-------------+
|         3 | Arthur Conan Doyle | GBR         |           3 |
|         1 | Sam Altman         | USA         |           2 |
|         5 | Juan Rulfo         | MEX         |           1 |
+-----------+--------------------+-------------+-------------+
3 rows in set (0.00 sec)

La diferencia del JOIN y del LEFT JOIN, es que:
JOIN: proyecta la información del junte de la tabla donde se cumplan las condiciones dadas.
LEFT JOIN: proyecta toda la información cumpla o no cumpla las condiciones dadas.

Con condiciones dadas nos referimos por ejemplo:

ON b.author_id = a.author_id

Y lo podemos visualizar comparando el resultado de ambos querys:

muy buena explicación Alberto Alcocer es bastante bueno

Último código, para comprobar el funcionamiento de LEFT JOIN e INNER JOIN:

• LEFT JOIN
  SELECT a.author_id, a.name, b.nacionality, COUNT(b.book_id) FROM authors AS a LEFT JOIN books AS b ON b.author_id = a.author_id WHERE a.author_id BETWEEN 1 AND GROUP BY a.author_id ORDER BY a.author_id

• INNER JOIN
  SELECT a.author_id, a.name, b.nacionality, COUNT(b.book_id) FROM authors AS a LEFT JOIN books AS b ON b.author_id = a.author_id WHERE a.author_id BETWEEN 1 AND GROUP BY a.author_id ORDER BY a.author_id

LEFT JOIN permite la visualización de los elementos de la tabla seleccionada aunque no aparezcan en la otra tabla. Si utilizaramos INNER JOIN, solo aparecerian los existentes en ambas tablas.

Sigue sin quedarme claro la diferencia entre INNER JOIN y LEFT JOIN, por que realizando la consulta de las dos formas aparentemente me regreso la misma información,. Alguien me podría aclarar este punto! .

Es necesario hacer consultas multitabla, ya que se puede encontrar información más útil si se capturan datos de tablas que están relacionadas.

bases de datos + join, left join + right join = Teoria de conjuntos.

Hola
Mi aporte es muy sencillo, pero quizás de utilidad para algunos.
Agrego a la consulta vista el clase la función GROUP_CONCAT() con la que podremos listar los títulos de los libros escritos, además del número de libros escritos.

SELECT a.author_id as ID, a.name as 'Nombre del autor', a.nationality as Nacionalidad, count(b.book_id) as 'Libros Escritos',
GROUP_CONCAT(b.title)
FROM authors as a
LEFT JOIN books as b
ON a.author_id = b.author_id
GROUP BY ID;

escript 1

Muchas gracias por la explicación Alberto, me queda mucho más claro la diferencia entre un INNER JOIN y un LEFT JOIN

SELECT b.book_id
    ,a.name
    ,b.title
FROM books AS b
    JOIN authors AS a
        ON a.author_id = b.author_id
WHERE b.author_id BETWEEN 1 and 5;

SELECT b.title
    ,c.name
    ,a.name
    ,t.type
FROM transactions AS t
    JOIN books AS b
        ON t.book_id = b.book_id
    JOIN clients AS c
        ON t.client_id = c.client_id
    JOIN authors AS a
        ON b.author_id = a.author_id
WHERE c.gender = 'F'
    and t.type = 'sell';

SELECT a.author_id
    ,a.name
    ,a.nationality
    ,b.title
FROM authors AS a
    INNER JOIN books AS b
        ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5
ORDER BY a.author_id;

SELECT a.author_id
    ,a.name
    ,a.nationality
    ,b.title
FROM authors AS a
    LEFT OUTER JOIN books AS b
        ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5
ORDER BY a.author_id;

SELECT a.author_id
    ,a.name
    ,a.nationality
    ,COUNT(b.book_id) AS Libros
FROM authors AS a
    LEFT OUTER JOIN books AS b
        ON a.author_id = b.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
    ,a.name
    ,a.nationality
ORDER BY a.author_id;

Ejemplo de COUNT()

Muy buen curso, he aprendido muchas cosas que pude haber utilizado en mi proyecto pasado.

LEFT JOIN muestra datos existentes en la tabla “a”, junto con sus respectivos datos de la tabla relacionada “b”.

(SI EN LA TABLA “b” NO EXISTEN DATOS EN RELACIÓN A TABLA “a” EL MOTOR TE INFORMARA CON UN “NULL” PARA EL DATO DE LA TABLA “b”)

INNER JOIN: Trae todos los registros relacionados.
LEFT JOIN: Trae los registros relacionados y no relacionados de la tabla pivote

INNER JOIN: Devuelve los valores coincidentes en las 2 tablas.
LEFT JOIN: Devuelve los valores coincidentes entre las 2 tablas y los valores de la tabla de la izquierda.

Excelente explicación. Que viva el profe Alberto.

Tambien podemos:
Renombrar la columna creada con AS y Ordenar con esa nueva columna

SELECT a.author_id, a.name, count(b.book_id) as Numero_libros FROM authors as a 
JOIN books as b 
ON a.author_id=b.author_id 
GROUP BY a.author_id 
ORDER BY Numero_libros DESC LIMIT 10;

De la misma forma en este caso podriamos encontrar los que no tienen libros … Queda de ejercicio XD 😉

El left join va a traer los datos de la tabla de la izquierda 

El inner join va a traer los datos que estén en ambas tablas.
select  a.author_id, a.name,a.nationality, count(b.book_id)
from authors as a left join books as b on
b.author=a.author_id where a.author_id between 1 and 5 
group by a.author_id order  by  a.author_id;  

select  a.author_id, a.name,a.nationality, count(b.book_id)
from authors as a inner join books as b on
b.author=a.author_id where a.author_id between 1 and 5 
group by a.author_id order  by  a.author_id;

Megusto la clase mas practica que otras bien!

En caso de usar el inner join, solo se pueden contar los libros existentes en la otra otra, y autores que no tengan coincidencias ni siquiera se visualizan.

Muy buena explicaciòn de los Join, como lo indicas, es de gran ayuda saber que registros cuentan con un desarrollo, y cuales aun no han sido afectados.

Qué buena clase, cada vez estoy más emocionado.

SELECT a.author_id 'ID AUTHOR', a.name 'NOMBRE AUTHOR', a.nationality 'NATIONALITY', COUNT(b.book_id) 'TOTAL BOOKS'
FROM authors as a
LEFT JOIN books as b
ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

Cuando usamos el INNER JOIN envés de LEFT JOIN, lo que se esta generando es una intersección de conjuntos o tablas , por lo cual lo que nos mostrará en la pantalla va a ser cuantos libros hay por autores con tal de que al menos el autor tenga un libro.

El inner Join de entiende por solo colocar el Join

COUNT(b.book_id); Esta función de grupo lo que haces contar las incidencias según un valor pivote.

GROUP BY author_id; Esta sentencia permite agrupar datos bajo una misma características. Se recomienda usar datos numéricos como los id.

Cabe añadir que la bases de datos puede ordenar y garantizar dicho orden, pero puede darse la situación que otra cosa es como lo ordena el lenguaje de programación que se conecta nuestra bases de datos y saca información.

El INNER JOIN es un join implícito

Las sentencias sql en ocasiones puedes Tener ambigüedad en el nombre de tablas para el manejador de bases de datos, es por ello que es buena práctica colocar el nombre de la tabla o el nombre del alias de esta tabla antes de la columna Ejemplo: authors.author_id

ORDER BY va después del WHERE y esta sentencia permite ordenar los datos mientras se van sacando de la bases de datos. a diferencia del HAVING que ordena los datos es una vez que están en la vista(tabla temporal que se crea cuando ejecutamos un SELECT)

Al realizar el respectivo ejercicio es claro que con INNER JOIN no podemos observar los autores que no tienen relacionado libros en cambio que con el LEFT JOIN asi el autor no tenga libros nos lo muestra con un NULL

¿Podria existir una “diferencia simetrica”? Digamos quiero ver los datos que no tienen relacion alguna de las dos tablas que quiero relacionar. ¿O solo haciento un “full join” y restando un “inner join”?

-- Traer los autores que tienen mas de 1 libro.

SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id) AS cantida_libros
FROM authors AS a
LEFT JOIN books AS b ON a.author_id = b.author_id
GROUP BY a.author_id
HAVING cantida_libros > 1
ORDER BY a.name
LIMIT 5;```

mysql> Select a.author_id,a.name,a.nationality, count(b.book_id)
-> from authors as a
-> inner join books as b
-> on b.author_id = a.author_id
-> where a.author_id between 1 and 5
-> group by a.author_id
-> order by a.author_id;
±----------±-------------------±------------±-----------------+
| author_id | name | nationality | count(b.book_id) |
±----------±-------------------±------------±-----------------+
| 1 | Sam Altman | USA | 2 |
| 3 | Arthur Conan Doyle | GBR | 3 |
| 5 | Juan Rulfo | MEX | 1 |
±----------±-------------------±------------±-----------------+

Escribir las consultas con estructura ANSI y NO con estructuras T-SQL

Ejemplo estructura ANSI

    SELECT <Campo1>, <Campo2> 
      FROM <Nombre Tabla1> 
           INNER JOIN <Nombre Tabla2> ON <PK_TBL1> = <FK_Tbl2>
     WHERE <Condición>

Ejemplo estructura T-SQL

    SELECT <Campo1>, <Campo2> 
      FROM <Nombre Tabla1>, <Nombre Tabla2> 
     WHERE <PK_Tbl1> = <FK_Tbl2> 
       AND  <Condición>

Dado lo anterior, para realizar las relaciones entre las tablas, se deben utilizar las instrucciones:

    INNER JOIN
    LEFT JOIN
    RIGHT JOIN
    CROSS JOIN

Si se utiliza varias tablas en la consulta, hay que especificar siempre a que tabla pertenece cada  
campo. Esto ahorra al gestor el tiempo de localizar a que tabla pertenece el campo.

Join implícito y Explícito

Estos dos tipos de JOIN realizan la misma acción pero tienen diferencias, aunque se recomienda usar el JOIN explícito, por ser más practico y legible.

• Un JOIN implícito es aquel que damos por sobreentendido y en el que omitimos ciertas partes, en código se ve así.

  SELECT a.name, b.title
  FROM authors AS a, books AS b
  WHERE a.author_id = b.book_id
  LIMIT 10;
  

• Un JOIN explícito es aquel que muestra de forma visible como se realiza algo, en este caso el código se ve así:

  SELECT a.name, b.title
  FROM books AS b
  INNER JOIN authors AS a
  	ON a.author_id = b.book_id
  LIMIT 10;
  

Clarísimo con el ejemplo 👍

Excelente clase!

Excelente clases

La diferencia es que las tablas con un count 0 no se muestran

Por fin ya tengo claro el uso de LEFT JOIN gracias.

que buena clase, a seguir aprendiendo.

Gracias!! Mas claro que nunca.

Implícito

SELECT b.title, a.name
FROM authors as a, books as b 
WHERE a.author_id = b.author_id
LIMIT 10;

SELECT b.title, a.name
FROM books as b 
INNER JOIN authors as a 
  ON a.author_id = b.author_id
LIMIT 10;

SELECT a.author_id, a.name, a.nationality, b.title, COUNT(b.book_id) 
FROM authors as a 
JOIN books as b 
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

Utilizando el LEFT JOIN

SELECT a.author_id, a.name, a.nationality, b.title, COUNT(b.book_id) 
FROM authors as a 
LEFT JOIN books as b 
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

Muy buena clase 😃

script 2 Join Left

script 3 Count

Gracias!!

Desde mi punto de vista creo que todas esas consultas multitablas son inncesarias, ya que podríamos crear una tabla BOOKS en donde se especifique el nombre del libro y su autor como campos de la misma tabla.

join significa los que coinciden por eso

SELECT c.name, o.type, o.finished
FROM clients as c -- left
LEFT JOIN operations as o -- right
    on c.id_client = o.id_client;

Excelente clase

Excelente profesor, todo muy claro!

Este man explica muy bien!

Todos son muy buenos profesores aqí en platzi, pero me están gustando mucho las clases del señor Alberto Alcocer.

Gran profesor, se entiende todo perfectamente, creo que de lo mejor que he visto en Platzi.

EXCELENTE CURSO

La diferencia de INNER JOIN Y LEFT JOIN es:

INNER JOIN muestra toda la información solicitada existente cumpliendo con las sentencias establecidas en el comando, y el LEFT JOIN las muestra saltándose las condiciones y mostrando toda la información.

Excelente clase.

-- Este query nos devulve todos los registros de la tabla B, en este caso es authors 
-- y solo los registros que coinciden de la tabla A con la tabla B.

-- La funcion GROUP_CONCAT(), lo que hace e agrupas y separar por comas (,) los registros
-- de esa columna en particulas, la que le pasemos como parametro.

SELECT a.author_id, a.name AS Author, a.nationality AS Nationality, COUNT(b.book_id) AS Books ,
GROUP_CONCAT(b.title) AS Titles
FROM authors as a
LEFT JOIN books as b
	on b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;```

Freddy Vega NULL XDDDD
Like si viste el RAP de freddy vs kardashan

Si usamos inner join nos muestra la info que existe en las dos tablas. Con left join nos muestra la información que esta en la tabla principal del from.

La clase de hoy

select a.author_id, a.name, a.nationality, b.title
from authors as a
left join books as b
on b.author_id = a.author_id
where a.author_id between 1 and 5
order by a.author_id;

Trabajando con falta de informacion

“Aprender a trabajar con información que falta, cuando es bien llevado es súper útil para el negocio”

LEFT JOIN

-- Contar número de libros tiene un autor.
-- Con COUNT (contar), es necesario tener un GROUP BY (agrupado por un criterio)
SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)
FROM authors AS a
LEFT JOIN books AS b
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

Vs, INNER JOIN

SELECT a.author_id, a.name, a.nationality, COUNT(b.book_id)
FROM authors AS a
JOIN books AS b
  ON b.author_id = a.author_id
WHERE a.author_id BETWEEN 1 AND 5
GROUP BY a.author_id
ORDER BY a.author_id;

Podemos observar que la consulta realizada con LEFT JOIN nos trae dos autores más, de los cuales no contamos con libros en existencia, un análisis posterior nos indicara si es que existe una alta demanda de los autores de los cuales no contamos con existencias, produciendo así una información valiosa para el negocio

Falta el libro All systems red - The Murderbot Diaries de freddy vega.

Respuesta al ejercicio. Lo que pasa es que en el resultado no aparecerán los autores que no tienen libros.

aquí el código de la clase:

-- mostrar que no hay libros del autor con id 4,
select authors.author_id, authors.name, authors.nationality, books.title
from authors
inner join books
    on books.author_id = authors.author_id
where authors.author_id between 1 and 5
order by authors.name desc -- default is asc
;

-- left join

select authors.author_id, authors.name, authors.nationality, books.title
from authors
left join books
    on books.author_id = authors.author_id
where authors.author_id between 1 and 5
order by authors.author_id asc
;

-- se muestra el group by
select authors.author_id, authors.name, authors.nationality, count(books.book_id)
from authors
inner join books
    on books.author_id = authors.author_id
where authors.author_id between 1 and 5
group by authors.author_id
order by authors.author_id asc
; 

Si en la universidad explicaran como este MAESTRO!

Muy buena y explicada su clase profe

Al hacer el GROUP by author_id, si dejamos la columna title, solo nos trae un titulo de forma aletoria.