Cruzar tablas: SQL JOIN

--------------------------RESUMEN----------------------------------------
/* Inner join: solo nos trae los datos que coinciden en ambas tablas. */
select * from route r
inner join train tr
on tr.train_id = r.train_id;

/* Este es un full outer join: trae todos los datos de ambas tablas. Coincidan o no. */
select * 
from route r
full outer join train tr
on tr.train_id = r.train_id;


/*Este full outer join ahora solo nos trae los datos que no coinciden de la tabla A 
 con la la tabla B, tambien nos trae los datos de la tabla B que no coiniden con la
 tabla A. (es como el opuesto del inner join, porque en lugar de traernos los que 
 coinciden en ambas tablas, nos trae solo los que no coinciden en ambas tablas.)*/
select * 
from route r
full outer join train tr
on tr.train_id = r.train_id
where r.train_id is null
or tr.train_id is null;


/* left join: nos trae todos los datos de la tabla A(izquierda) y solo los datos de la
 tabla B que coincidan en la tabla A. */
select * from route r
left join train tr
on tr.train_id = r.train_id;

/* left outer join: nos devuelve todos los datos de la tabla A que no coincide con la
tabla B. */
select * from route r
left join train tr
on tr.train_id = r.train_id
where tr.train_id is null;

/*right join: nos devuelve todos los datos de la tabla B, y solo los datos de la tabla
A que coincidan con la tabla B*/
select * from route r
right join train tr
on tr.train_id = r.train_id;

/* right outer join: nos trae todos los datos de la tabla B que no coinciden con
la tabla A*/

select * from route r
right join train tr
on tr.train_id = r.train_id
where r.train_id is null;

/*NOTA: Cuando usamos left join (Tabla A a la tabla B) estamos usando la tabla A, es
decir traemos todos los datos de la tabla A y solo los datos de la tabla B que coinciden
con la tabla A. si queremos usar un left outer join la llave primaria null que debemos
especificar es la de la tabla B.
WHERE b.pkey us null;
lo mismo pasa cuando usamos un right outer join
como usamos la tabla B y solo los que coinciden con la tabla A entonces la llave null
que usamos es de la tabla A.
WHERE a.pkey us null;								*/

Comparto a la comunidad mis notas de este curso en un repositorio, espero les sean de mucha utilidad, recuerden hacer buen uso

https://github.com/rb-one/Curso_PostgreSQL/blob/master/Notes/notes.md

El mejor resumen

https://www.postgresqltutorial.com/wp-content/uploads/2018/12/PostgreSQL-Joins.png

JOIN en PostgreSQL

Un join en PostgreSQL es una operación que combina filas de dos o más tablas en una sola tabla resultante. Se utiliza para recuperar información relacionada de diferentes tablas y para crear consultas más complejas.

Hay varios tipos de join en PostgreSQL, incluyendo:

• Inner join: solo incluye las filas que tienen una coincidencia en ambas tablas.
• Left join: incluye todas las filas de la tabla de la izquierda y las filas coincidentes de la tabla de la derecha. Si no hay una coincidencia, los valores en las columnas de la tabla de la derecha serán NULL.
• Right join: incluye todas las filas de la tabla de la derecha y las filas coincidentes de la tabla de la izquierda. Si no hay una coincidencia, los valores en las columnas de la tabla de la izquierda serán NULL.
• Full outer join: incluye todas las filas de ambas tablas, ya sea que haya una coincidencia o no. Si no hay una coincidencia, los valores en las columnas de una de las tablas serán NULL.

Para crear un join en PostgreSQL, primero debe definir ambas tablas y sus relaciones, luego puede usar la siguiente sintaxis en una consulta SQL:

SELECT *
FROM nombre_tabla_1
JOIN nombre_tabla_2
ON condición_de_unión;

Donde nombre_tabla_1 y nombre_tabla_2 son los nombres de las tablas que se van a unir, y condición_de_unión es la condición que se usa para determinar qué filas de cada tabla se deben incluir en el resultado. La condición de unión generalmente se basa en el valor de una columna en ambas tablas que deben ser iguales para que una fila se incluya en el resultado.

SELECT 
pasajero.nombre AS pasajero,
tren.modelo AS tren,  
trayecto.nombre AS trayecto, 
estacion.nombre AS estacion,
viaje.inicio, 
viaje.fin
FROM pasajero
INNER JOIN viaje
ON viaje.id_pasajero = pasajero.id
INNER JOIN trayecto
ON viaje.id_trayecto = trayecto.id
INNER JOIN tren
ON trayecto.id_tren = tren.id
INNER JOIN estacion
ON trayecto.id_estacion = estacion.id;

Consultas

SELECT * FROM pasajero
INNER JOIN viaje ON (viaje.id_pasajero = pasajero.id);

SELECT * FROM pasajero
LEFT JOIN viaje ON (viaje.id_pasajero = pasajero.id)
WHERE viaje.id IS NULL;

En esta página hay ejemplos interactivos para todos los casos de los SQL Join.
https://www.w3schools.com/sql/sql_join.asp

En la versión 12 de postgreSQL se usan comillas dobles ( " " ) para los campos, así funciona correctamente el join
SELECT
*
FROM
pasajero
join
viaje
ON
(viaje.“Id_pasajero”=pasajero.“Id”)

Les dejo mi aporte. Uní 3 tablas para obtener el nombre de los pasajeros que viajaron durante 2013 y qué rutas tomaron.

mi documentacion tal vez a alguien le ayude , recibo feedback tambien

<--joins  , comparacion de tablas 
--trae  solo los valores que corespondadn con la otra tabla 

        select *   -- seleccionamos las filas
        from passengers  --selecionamos la columna (tabla A)
        join viaje  -- LLAMAMOS  la union ( tabla B)
        on   -- selecciona todas las columnas de todas las tablas 
        (viaje.id_passengers -- tabla que queremos unir (B) con la columa que deseamos referenciar de esa misma cotabla 
        = passengers.id) -- tabla local (A), con su id de referencia y coneccion con las demas tablas 


--left join 
--nos trae los datos de la tabla (A) esten correlacionados o no con a tabla (B)
        select *   -- seleccionamos las filas
        from passengers  --selecionamos la columna (tabla A)
        left join viaje  -- LLAMAMOS  la union ( tabla B)
        on   -- selecciona todas las columnas de todas las tablas 
        (viaje.id_passengers -- tabla que queremos unir (B) con la columa que deseamos referenciar de esa misma cotabla 
        = passengers.id) -- tabla local (A), con su id de referencia y coneccion con las demas tablas > 

Left Join funciona de manera optima en la generación de reportes cuando se buscan bugs o errores en la inserción de datos

Estas son las consultas que hice:

Los Joins son básicamente toda la teoría de conjunto aplicada a SQL

• Aqui la clase de Conjuntos de el curso de lenguaje matematico
• Aqui la clase del curso de fundamentos de BD en donde se ven los JOINS en accion

Hecho 😊

Nunca pude entender los joins. Espero esta vez tenga más suerte.

SELECT trenes.modelo as Trenes, trenes.capacidad as Capacidad, estaciones.nombre as Estaciones, trayectos.nombre as Trayectos FROM trayectos
LEFT JOIN trenes ON (trenes.id = trayectos.tren_id)
LEFT JOIN estaciones ON (estaciones.id = trayectos.estacion_id);

Aquí hice los 7 cruces de tablas posibles con las tablas pasajeros y viajes y las preguntas que podrían responder:

**¿A qué horas iniciaron y finalizaron su viaje los pasajeros? **

SELECT *
FROM pasajeros
LEFT JOIN viajes
ON pasajeros.id = viajes.id_pasajeros;

¿Qué personas están registradas pero no han hecho ningún viaje?

SELECT *
FROM pasajeros
LEFT JOIN viajes
ON pasajeros.id = viajes.id_pasajeros
WHERE viajes.id_pasajeros IS NULL;

¿Cuántos viajes efectivos han sido realizados por los pasajeros?

SELECT *
FROM pasajeros
RIGHT JOIN viajes
ON pasajeros.id = viajes.id_pasajeros;

¿Qué viajes o cuántos viajes han tomado los pasajeros que no estén registrados?

SELECT *
FROM pasajeros
RIGHT JOIN viajes
ON pasajeros.id = viajes.id_pasajeros
WHERE pasajeros.id IS NULL;

¿Cuántos pasajeros han tomados viajes de forma efectiva?

SELECT *
FROM pasajeros
INNER JOIN viajes
ON pasajeros.id = viajes.id_pasajeros;

Bueno, aquí se unifican las tablas pasajeros y viajes

SELECT *
FROM pasajeros
FULL OUTER JOIN viajes
ON pasajeros.id = viajes.id_pasajeros;

¿Cuántos pasajeros no han hecho viajes?

SELECT *
FROM pasajeros
LEFT JOIN viajes
ON pasajeros.id = viajes.id_pasajeros
WHERE pasajeros.id IS NULL
OR viajes.id_pasajeros IS NULL;

Ejemplo de una de las consultas que realice:

La primer consulta me sale totalmente vacía. En algún momento llenamos la tabla “viaje” y me lo saltee?

El rigth join con trayecto y tren
SELECT
*
FROM
trayecto
RIGHT JOIN
tren
ON
(trayecto.“Id_tren”=tren.“Id”);

– FULL OUTER JOIN
SELECT
*
FROM
trayecto
FULL OUTER JOIN
tren
ON
(trayecto.“Id_tren”=tren.“Id”);

ESTACION Y TRAYECTO
–Full outer join
SELECT
*
FROM
trayecto
FULL OUTER JOIN
estacion
ON
(trayecto.“Id_estacion”=estacion.“Id”);
–RIGHT JOIN
SELECT
*
FROM
trayecto
RIGHT JOIN
estacion
ON
(trayecto.“Id_estacion”=estacion.“Id”);

Comparto un join de las tablas de estacion, tren y trayecto
SELECT
trayecto.“Id” as IdTrayecto,
trayecto.“Nombre” as Nombre,
tren.“Modelo” as tren,
tren.“Capacidad” as Capacidad,
estacion.“Nombre” as estacion,
estacion.“Direccion” as ubicacion
FROM
trayecto
JOIN
tren
ON
(trayecto.“Id_tren”=tren.“Id”)
JOIN
estacion
ON
(trayecto.“Id_estacion” = estacion.“Id”)

SELECT * FROM  public.pasajero
JOIN viaje ON (viaje.id_pasajero = id_pasajero);

SELECT *
FROM pasajero
JOIN viaje ON (viaje.id_pasajero = pasajero.id_pasajero);


SELECT *
FROM pasajero
LEFT JOIN viaje ON (viaje.id_pasajero = pasajero.id_pasajero)
WHERE viaje.id_pasajero IS NULL; 


SELECT *
FROM pasajero
INNER JOIN viaje ON (viaje.id_pasajero = pasajero.id_pasajero)
WHERE viaje.id_pasajero IS NULL;

Me creé un query para saber que trenes fueron los que mas uso han tenido y en cuantas rutas están asignados.

Todos los viajes junto con los detalles de los pasajeros correspondientes, y si hay viajes sin pasajeros, los campos de pasajero tendrán valores NULL.

SELECT * FROM viaje
RIGHT JOIN pasajero ON (viaje.id_pasajero = pasajero.id);

Aquí les comparto mis consultas:

SELECT * FROM trayectos
RIGHT JOIN trenes ON (trenes.id = trayectos.id_trenes)
WHERE trayectos.id IS null;

SELECT * FROM trayectos
FULL OUTER JOIN estaciones ON estaciones.id = trayectos.id_estaciones

SELECT * FROM pasajero
join viaje on (viaje.id_pasajero=pasajero.id)


SELECT * FROM pasajero pa
left join viaje v on (v.id_pasajero=pa.id) 
where v.id is null


SELECT * from trayecto tra
right join estacion e on e.id=tra.id_estacion
right join tren tr on tr.id=tra.id_tren
where e.id is null 
and  tra.id is null


SELECT * FROM Trayecto tra
full outer join estacion e on e.id=tra.id_estacion
where tra.id is not null

esas explicaciones tan malas, pésimas, con pocas ganas, poco ánimo, falta de pedagogía

Trayectos cuyos trenes tienen una capacidad menor a 10

select t.*, z.* from trayecto t left join tren z on t.id_tren = z.id
where z.capacidad <'10';

Gracias

select *
from pasajero
join viaje on (viaje.id_pasajero=pasajero.id);

select *
from pasajero
	left join viaje on (viaje.id_pasajero = pasajero.id)
where viaje.id_viaje is NULL;


select *
from "Trenes"
	join trayecto on("Trenes".id_tren = trayecto.id_tren);
	
	
select * 
from "Trenes"
	left join trayecto on("Trenes".id_tren = trayecto.id_tren)
where "Trenes".id_tren is null;

select *
from "Trenes"
	right join trayecto on ("Trenes".id_tren = trayecto.id_tren);
	
select *
from "Trenes"
	right join trayecto on ("Trenes".id_tren = trayecto.id_tren)
where "Trenes".id_tren is null;

SELECT * FROM trayecto
LEFT JOIN tren ON (tren.id = trayecto.id_tren)
LEFT JOIN estacion ON (estacion.id = trayecto.id_estacion);

Consultar que trenes no tienen ninguna ruta

SELECT * FROM trains t LEFT JOIN routes r ON r.train_id=t.id
WHERE r.id IS NULL;

id | model | capacity | id | station_id | train_id | name
----±------------------------±---------±—±-----------±---------±-----
25 | LaCrosse | 22 | | | |
27 | Lanos | 24 | | | |
93 | Maxima | 90 | | | |
17 | 1000 | 14 | | | |
66 | Continental Flying Spur | 63 | | | |
89 | Corolla | 86 | | | |
33 | Expedition | 30 | | | |
57 | Pajero | 54 | | | |
12 | W201 | 9 | | | |
10 | GS | 7 | | | |
98 | 911 | 95 | | | |
64 | MX-5 | 61 | | | |
71 | Talon | 68 | | | |
83 | Silverado 3500 | 80 | | | |
77 | Camry | 74 | | | |
91 | Golf | 88 | | | |
5 | M Roadster | 2 | | | |
96 | A4 | 93 | | | |
24 | Safari | 21 | | | |
55 | Touareg | 52 | | | |
8 | RAV4 | 5 | | | |
:

Using full joing

Ayuda a los pasajeros a saber cual estacion, cual ruta y cual tren.

SELECT E.nombre AS nombre_estacion,
	E.direccion AS direccion_estacion,
	T.nombre AS nombre_trayecto,
	TR.modelo AS modelo_tren,
	TR.capacidad AS capacidad_tren
	FROM estaciones E
	INNER JOIN public.trayectos T ON (E.id = T.id_estacion)
	INNER JOIN public.trenes TR ON (T.id_tren = TR.id);

Código para tren:

<SELECT inicio AS fecha_inicio,fin AS fecha_fin,trayectos.nombre 
AS ruta,pasajeros.nombre AS pasajero,modelo AS modelo_tren,capacidad, 
trenes.id AS id_tren
FROM viajes 
JOIN trayectos_viajes ON (trayectos_viajes.id_viajes = viajes.id)
JOIN trayectos ON (trayectos_viajes.id_trayectos = trayectos.id) 
JOIN pasajeros ON (pasajeros.id = viajes.id_pasajero)
JOIN trenes ON (trenes.id = trayectos.id_tren);> 

<
"fecha_inicio"	"fecha_fin"	"ruta"	"pasajero"	"modelo_tren"	"capacidad"	"id_tren"
"2022-12-01"	"2022-12-01"	"usme-portal norte"	"carlos roman"	"Hino 2206"	225	1
"2022-12-01"	"2022-12-01"	"usme-portal norte"	"jose pardo"	"Hino 2206"	225	1
"2022-12-01"	"2022-12-01"	"usme-portal norte"	"carolina arbelaez"	"Hino 2206"	225	1
"2022-12-01"	"2022-12-01"	"usme-portal norte"	"juana la loca"	"Hino 2206"	225	1
"2022-12-02"	"2022-12-02"	"usme-portal 80"	"carlos roman"	"Hino 2206"	225	2
"2022-12-02"	"2022-12-02"	"usme-portal 80"	"jose pardo"	"Hino 2206"	225	2
"2022-12-02"	"2022-12-02"	"usme-portal 80"	"carolina arbelaez"	"Hino 2206"	225	2
"2022-12-02"	"2022-12-02"	"usme-portal 80"	"juana la loca"	"Hino 2206"	225	2
"2022-12-03"	"2022-12-03"	"usme-aereopuerto el dorado"	"carlos roman"	"Hino 2206"	225	3
"2022-12-03"	"2022-12-03"	"usme-aereopuerto el dorado"	"jose pardo"	"Hino 2206"	225	3
"2022-12-03"	"2022-12-03"	"usme-aereopuerto el dorado"	"carolina arbelaez"	"Hino 2206"	225	3
"2022-12-03"	"2022-12-03"	"usme-aereopuerto el dorado"	"juana la loca"	"Hino 2206"	225	3
"2022-12-04"	"2022-12-04"	"usme-museo del oro"	"carlos roman"	"Hino 2206"	225	4
"2022-12-04"	"2022-12-04"	"usme-museo del oro"	"jose pardo"	"Hino 2206"	225	4
"2022-12-04"	"2022-12-04"	"usme-museo del oro"	"carolina arbelaez"	"Hino 2206"	225	4
"2022-12-04"	"2022-12-04"	"usme-museo del oro"	"juana la loca"	"Hino 2206"	225	4
"2022-11-26"	"2022-09-03"	"Hoepker"	"carolina arbelaez"	"Ecodrive 001"	100	28
"2022-11-09"	"2022-10-24"	"La Follette"	"Vaughn Pitkin"	"Ecodrive 001"	100	26
"2022-04-15"	"2022-06-15"	"Dayton"	"Janet Matthai"	"Hino 2206"	225	9
"2022-07-02"	"2022-07-23"	"Norway Maple"	"Maddi MacMorland"	"Hino 2206"	225	3
"2022-09-14"	"2022-05-13"	"Anderson"	"Daryl Weaver"	"BYD Hibrid"	182	12
"2022-10-19"	"2022-08-03"	"Aberg"	"Darlleen Costigan"	"Ecodrive 001"	100	28
"2022-10-19"	"2022-08-03"	"Rigney"	"Darlleen Costigan"	"BYD Hibrid"	182	13
"2022-03-30"	"2022-11-10"	"Sycamore"	"Charlie Dreng"	"Hino 2206"	225	9
"2022-04-06"	"2022-09-26"	"Larry"	"Jonathan Killner"	"BYD Hibrid"	182	15
"2022-02-13"	"2022-11-27"	"La Follette"	"Letta Hazeman"	"BYD Hibrid"	182	14
"2022-02-07"	"2022-06-23"	"Redwing"	"Molly Block"	"Ecodrive 001"	100	23
"2022-03-08"	"2022-02-18"	"Declaration"	"Daryl Weaver"	"BYD Hibrid"	182	12
"2022-09-05"	"2022-04-15"	"Carpenter"	"Emanuel Paroni"	"Hino 2206"	225	3
"2022-06-09"	"2022-10-02"	"Moulton"	"Darlleen Costigan"	"Ecodrive 001"	100	26
"2022-06-09"	"2022-10-02"	"Judy"	"Darlleen Costigan"	"Ecodrive 001"	100	26
"2022-09-25"	"2022-10-09"	"Aberg"	"Malina Durtnell"	"Ecodrive 001"	100	28
"2022-10-04"	"2022-07-29"	"Hayes"	"Roxana Jowle"	"Hino 2206"	225	7
"2022-03-04"	"2022-07-25"	"Eggendart"	"Theodor Harry"	"Hino 2206"	225	4
"2022-09-02"	"2022-04-03"	"Steensland"	"Sven Scotney"	"Hino 2206"	225	8
"2022-07-02"	"2022-04-18"	"North"	"Sherlock McKilroe"	"BYD Hibrid"	182	17
"2022-09-05"	"2022-04-15"	"Bluestem"	"Emanuel Paroni"	"Ecodrive 001"	100	29
"2022-05-28"	"2022-03-01"	"Manitowish"	"Lemar Abramovici"	"BYD Hibrid"	182	19
"2022-10-07"	"2022-04-30"	"Eggendart"	"Worth Yellowlee"	"Hino 2206"	225	4
"2022-11-16"	"2022-03-30"	"Hoepker"	"Emanuel Paroni"	"Ecodrive 001"	100	28
"2022-12-02"	"2022-12-02"	"Aberg"	"juana la loca"	"Ecodrive 001"	100	28
"2022-05-06"	"2022-05-28"	"Sauthoff"	"Nicko Duckerin"	"Ecodrive 001"	100	24
"2022-09-01"	"2022-04-10"	"North"	"Janet Matthai"	"BYD Hibrid"	182	17
"2022-12-01"	"2022-12-01"	"Washington"	"jose pardo"	"BYD Hibrid"	182	12
"2022-09-26"	"2022-09-11"	"Harbort"	"Darcey Fuge"	"BYD Hibrid"	182	13
"2022-07-23"	"2022-12-07"	"La Follette"	"Jdavie Matis"	"BYD Hibrid"	182	14
"2022-12-03"	"2022-12-03"	"Warner"	"carolina arbelaez"	"Hino 2206"	225	6
"2022-05-20"	"2022-02-01"	"Autumn Leaf"	"Ollie Larimer"	"BYD Hibrid"	182	18
"2022-12-02"	"2022-12-02"	"Bayside"	"carolina arbelaez"	"Ecodrive 001"	100	29
"2022-07-23"	"2022-12-07"	"Graceland"	"Jdavie Matis"	"Ecodrive 001"	100	29
"2022-02-03"	"2022-10-19"	"Redwing"	"Selinda Nellies"	"Ecodrive 001"	100	23
"2022-07-25"	"2022-11-29"	"North"	"Cicily Gilfoy"	"BYD Hibrid"	182	17
"2022-02-09"	"2022-06-26"	"Mitchell"	"Krishnah Clymer"	"Hino 2206"	225	10
"2022-02-09"	"2022-06-26"	"Bunting"	"Krishnah Clymer"	"Ecodrive 001"	100	30
"2022-11-06"	"2022-11-23"	"Rockefeller"	"Guglielmo Ivins"	"BYD Hibrid"	182	17
"2022-09-09"	"2022-06-23"	"Rusk"	"Darlleen Costigan"	"BYD Hibrid"	182	14
"2022-03-26"	"2022-05-08"	"Schurz"	"Hilde Bruneau"	"Hino 2206"	225	5
"2022-11-06"	"2022-05-05"	"Pleasure"	"Sherlock McKilroe"	"Hino 2206"	225	4
"2022-08-19"	"2022-09-21"	"Memorial"	"Nicko Duckerin"	"BYD Hibrid"	182	11
"2022-11-16"	"2022-03-30"	"Londonderry"	"Emanuel Paroni"	"Hino 2206"	225	1
"2022-03-14"	"2022-06-19"	"Pleasure"	"Wilton Lemme"	"Hino 2206"	225	4
"2022-03-14"	"2022-06-19"	"Moulton"	"Wilton Lemme"	"Ecodrive 001"	100	26
"2022-11-26"	"2022-09-03"	"North"	"carolina arbelaez"	"BYD Hibrid"	182	20
"2022-10-27"	"2022-06-30"	"Grover"	"Janos Warre"	"BYD Hibrid"	182	14
"2022-05-28"	"2022-03-01"	"North"	"Lemar Abramovici"	"BYD Hibrid"	182	17
"2022-11-18"	"2022-05-03"	"Hayes"	"Sven Scotney"	"Hino 2206"	225	7
"2022-12-06"	"2022-09-27"	"Judy"	"Emanuel Paroni"	"Ecodrive 001"	100	26
"2022-10-04"	"2022-07-29"	"Bartillon"	"Roxana Jowle"	"Hino 2206"	225	4
"2022-02-11"	"2022-04-10"	"Superior"	"Kary Shapira"	"Ecodrive 001"	100	24
"2022-11-10"	"2022-05-09"	"La Follette"	"Charles Soppitt"	"BYD Hibrid"	182	14
"2022-09-05"	"2022-04-15"	"Bartillon"	"Emanuel Paroni"	"Hino 2206"	225	4
"2022-02-04"	"2022-07-10"	"Superior"	"juana la loca"	"Ecodrive 001"	100	24
"2022-12-02"	"2022-12-02"	"Vera"	"jose pardo"	"Ecodrive 001"	100	23
"2022-11-18"	"2022-05-03"	"Manufacturers"	"Sven Scotney"	"Ecodrive 001"	100	23
"2022-07-14"	"2022-08-25"	"Derek"	"Edan Pires"	"BYD Hibrid"	182	12
"2022-12-02"	"2022-12-02"	"Nobel"	"juana la loca"	"Ecodrive 001"	100	29
"2022-11-10"	"2022-05-09"	"Vera"	"Charles Soppitt"	"Ecodrive 001"	100	23
"2022-03-16"	"2022-02-27"	"Harbort"	"Noam Poltone"	"BYD Hibrid"	182	13
"2022-11-06"	"2022-03-26"	"Linden"	"Allsun Ivimy"	"Ecodrive 001"	100	28
"2022-05-20"	"2022-02-01"	"Autumn Leaf"	"Ollie Larimer"	"BYD Hibrid"	182	18
"2022-03-14"	"2022-06-19"	"Kropf"	"Wilton Lemme"	"Ecodrive 001"	100	23
"2022-09-02"	"2022-04-03"	"Sauthoff"	"Sven Scotney"	"Ecodrive 001"	100	24
"2022-08-22"	"2022-09-20"	"Pankratz"	"Lynnelle Oleksinski"	"Hino 2206"	225	7
"2022-11-06"	"2022-03-26"	"Loomis"	"Allsun Ivimy"	"BYD Hibrid"	182	15
"2022-09-10"	"2022-12-07"	"Forster"	"Darcey Fuge"	"Ecodrive 001"	100	23
"2022-11-16"	"2022-03-30"	"Welch"	"Emanuel Paroni"	"Ecodrive 001"	100	25
"2022-10-05"	"2022-02-01"	"North"	"Worth Yellowlee"	"Ecodrive 001"	100	26
"2022-07-14"	"2022-04-01"	"Harbort"	"Tonnie Cattle"	"BYD Hibrid"	182	13
"2022-12-02"	"2022-12-02"	"Sage"	"carlos roman"	"Ecodrive 001"	100	29
"2022-01-14"	"2022-04-03"	"Lotheville"	"Molly Block"	"BYD Hibrid"	182	13
"2022-12-02"	"2022-12-02"	"Bluestem"	"carlos roman"	"Ecodrive 001"	100	29
"2022-05-27"	"2022-07-07"	"Comanche"	"Krishnah Clymer"	"Hino 2206"	225	2
"2022-08-22"	"2022-07-05"	"Tony"	"Ann Gair"	"Hino 2206"	225	3
"2022-09-10"	"2022-12-07"	"Norway Maple"	"Darcey Fuge"	"Hino 2206"	225	3
"2022-12-02"	"2022-12-02"	"Grayhawk"	"carolina arbelaez"	"Ecodrive 001"	100	27
"2022-07-23"	"2022-12-15"	"Welch"	"Laurette Moneti"	"Hino 2206"	225	3
"2022-03-08"	"2022-02-18"	"Columbus"	"Daryl Weaver"	"Ecodrive 001"	100	27
"2022-06-03"	"2022-06-08"	"Schurz"	"Theodor Harry"	"Hino 2206"	225	5
"2022-01-24"	"2022-08-23"	"Lotheville"	"Darcey Fuge"	"BYD Hibrid"	182	13
"2022-10-05"	"2022-02-01"	"Eggendart"	"Worth Yellowlee"	"Hino 2206"	225	4
"2022-05-20"	"2022-02-01"	"Scoville"	"Ollie Larimer"	"BYD Hibrid"	182	12
"2022-05-23"	"2022-08-04"	"Dayton"	"Jonathan Killner"	"Hino 2206"	225	9
"2022-12-05"	"2022-01-16"	"Londonderry"	"Emilia Mant"	"Hino 2206"	225	1
"2022-04-15"	"2022-06-15"	"Linden"	"Janet Matthai"	"Ecodrive 001"	100	26
"2022-01-14"	"2022-05-31"	"Loomis"	"Winny Gotcliffe"	"BYD Hibrid"	182	15
"2022-04-15"	"2022-03-08"	"East"	"Cicily Gilfoy"	"Ecodrive 001"	100	25
"2022-07-25"	"2022-11-29"	"Forster"	"Cicily Gilfoy"	"Ecodrive 001"	100	23
"2022-07-02"	"2022-04-18"	"Farwell"	"Sherlock McKilroe"	"Hino 2206"	225	2
"2022-11-02"	"2022-04-03"	"Graceland"	"Edan Pires"	"Ecodrive 001"	100	29
"2022-10-07"	"2022-04-30"	"East"	"Worth Yellowlee"	"Ecodrive 001"	100	25
"2022-12-01"	"2022-12-01"	"Memorial"	"carlos roman"	"BYD Hibrid"	182	11
"2022-04-09"	"2022-03-15"	"Memorial"	"Riannon Pletts"	"Ecodrive 001"	100	28
"2022-03-10"	"2022-10-22"	"East"	"Prissie Lake"	"Ecodrive 001"	100	25
"2022-07-02"	"2022-07-23"	"Arizona"	"Maddi MacMorland"	"Hino 2206"	225	1
"2022-06-09"	"2022-10-02"	"Riverside"	"Darlleen Costigan"	"BYD Hibrid"	182	20
"2022-04-09"	"2022-03-15"	"North"	"Riannon Pletts"	"BYD Hibrid"	182	17
> 

En los join lo mejor es asignarle un alias a la tabla maestra y de esa forma es mas corta la instrucción cuando se haga la union con la referencia

Comparto mi consulta para los trenes y sus trayectos correspondientes:

SELECT * FROM tren
INNER JOIN trayecto ON (trayecto.id_tren = tren.id);

Para poder unir las tablas estacion y tren utilice la tabla transitiva trayecto:

<SELECT *
FROM estacion
	INNER JOIN trayecto on (trayecto.id_estacion = estacion.id)
	INNER JOIN tren on (tren.id = trayecto.id_tren);
> 

el resultado

--TRENES QUE LLEGAN A LAS ESTACIONES EXISTENTES

select t1.*
from trenes t1
join trayectos t2
on t1.id=t2.id_tren
join estaciones t3
on t3.id=t2.id_estacion

--TRENES QUE NO LLEGAN A ESTACIONES EXISTENTES
select t1.*
from trenes t1
left join trayectos t2
on t1.id=t2.id_tren
left join estaciones t3
on t3.id=t2.id_estacion
where t2.id_estacion is null

--trenes que no estan en ningun trayecto
select t1.*
from trenes t1
left join trayectos t2
on t1.id=t2.id_tren
where t2.id_tren is null

Realice la query con la idea de determinar los viajes y trayectos de cada pasajero

SELECT p.nombre AS pasajero,t.nombre AS trayecto,e.nombre AS estacion,v.inicio AS fecha_inicio,v.fin AS fecha_fin,tr.id AS id_tren
	FROM public.pasajero AS p
	JOIN public.viaje AS v
		ON v.id_pasajero= p.id
	JOIN public.trayecto AS t
		ON v.id_trayecto=t.id
	JOIN public.estacion AS e
		ON t.id_estacion=e.id
	JOIN public.tren as tr
		ON tr.ID = t.id_tren

--Estaciones de salida asignadas por modelo de tren y su capacidad-- 
SELECT modelo, MAX(capacidad)capacidad, COUNT(estacion_a_id)estaciones_salida
FROM rutas
LEFT JOIN trenes ON trenes.tren_id = rutas.tren_id
group by MODELO
Order by estaciones_salida desc
;

--Quienes realizan más viajes ?
select A.nombre, count(*) as viajes from pasajero as A
join viaje as B
on A.id = B.id_pasajero
group by A.nombre
order by viajes DESC

Decidí hacer la unión de las tres tablas (Estaciones, Trenes y Trayectos) y filtrar los datos por los trenes con mayor capacidad que actualmente estén circulando y tengan una estación definida.

select *
from public."estaciones"
	Right JOIN public."Trayectos" on public."estaciones".id_estacion = 		 
  public."Trayectos".id_estacion
	Right JOIN public."trenes" on public."trenes".id_tren = public."Trayectos".id_tren
where public."trenes".capacidad > 500 and public."estaciones".id_estacion IS NOT NULL
order by public."trenes".capacidad desc;

Resuelto el ejercicio:

Los datos se pueden cruzar utilizando JOIN y sus diferentes tipos, los cuales se basan en el uso de teoría de conjuntos para analizar y/o dar manejo a los datos, de mi banco de datos, dependiendo de lo que se quiera analizar.

Para poder realizarlo le incluí las comillas

<SELECT * FROM "Historica"
JOIN "Docentes" ON "Docentes"."DOCUMENTO" = "Historica"."DOCUMENTO";> 

SQL JOINS - Imagen del vídeo

Aquí un Inner Join entre trayecto, estacion y tren.
Muestra las estaciones, el trayecto y el tren que hace el trayecto.

select * from trayectos as t
inner join viajes as v on v.id_trayecto= t.id;

Información resumida de esta clase
#EstudiantesDePlatzi

• Los JOIN es la teoría de conjuntos implementada en SQL

• Los JOIN nos permite crear intersección, consultar el conjunto de la izquierda, derecha o completo

• Es de gran ayuda pegar el papelito de JOIN cerca al lugar de trabajo

estupendo. me encanto la forma de hacer data ejemplo cool

Algunas de mis consultas combinadas…

SELECT * FROM "TREN"
LEFT JOIN "TRAYECTO" ON ("TREN".id = "TRAYECTO".id_tren)
ORDER BY "TREN".id;

SELECT * FROM "ESTACION"
INNER JOIN "TRAYECTO" ON ("ESTACION".id = "TRAYECTO".id_estacion)
ORDER BY "ESTACION".id;

Los join son una maravilla y super simples de entender

Hice una demostración uniendo 3 tablas, estacion,tren y trayecto ya que trayecto esta relacionada a ambas tablas, y le pedi que me mostraran los que tuvieran un nombre similar a mazda

Lo hice con este query

SELECT trayecto.id,trayecto.nombre AS nombre_trayecto,trenes.modelo,estaciones.nombre AS estaciones
FROM public.trayectos AS trayecto
INNER JOIN public.trenes ON trenes.id=trayecto.id_tren
INNER JOIN public.estaciones ON estaciones.id=trayecto.id_estacion
WHERE trenes.modelo LIKE '%Mazda%'
ORDER BY trayecto.nombre;

por alguna razon la sintaxis de mi pdadmin es bastante deferente a la que usa el profesor como muestro en la imagen. Si alguno sabe como cambiar esa sintaxis agradeceria me dejara saber como hacerlo. tardo mucho tiempo de descifrar que necesita el programa.

Les comparto algunas consultas interesantes del proyecto que estoy trabajando.
Aún me hace falta cargar mucho mas información y planear trayectos de pasajeros que hagan trasbordos, pero de momento así se van viendo las consultas que ya me sirven para reportar situaciones dentro de mi esquema.
Traté de compartir los recursos aqui, pero me pusieron el comentario en revision. Dejo la url de github en donde tengo ese script definido.

Saludos!

No es basicamente toda la teoría de conjuntos. Es algebra de conjuntos. Una parte de la gran teoría de conjuntos.

Jajaja obviamente el pasajero con Id 101 no había hecho viajes.

Comando join
LEFT join
Todos los otros tipos de join

comparto mis query, espero que sirvan de ayuda:

-- Pasajeros que viajaron
SELECT * FROM "Pasajeros"
JOIN "Viajes" ON ("Viajes".id_pasajero = "Pasajeros".id);

--Pasajeros que no han viajado
SELECT * FROM "Pasajeros"
LEFT JOIN "Viajes" ON ("Viajes".id_pasajero = "Pasajeros".id)
WHERE "Viajes".id IS NULL;

SELECT 	tra."Nombre", 
		tre."Modelo", 
		tre."Capacidad", 
		est."Nombre"
FROM "Trayecto" tra
INNER JOIN "Tren" tre ON tra."IdTren" = tre."Id"
INNER JOIN "Estacion" est ON tra."IdEstacion" = est."Id"

Consulta para conocer los trayectos más visitados, el nombre de mis tablas está en plural por lo que tal vez necesiten cambiarlo.

select trayectos.nombre_trayecto, count(*) from trayectos
left join viajes on (viajes.id_trayecto = trayectos.id_trayecto)
where id_viaje is not null
group by trayectos.nombre_trayecto
order by count DESC;

SELECT *FROM tren
RIGHT JOIN trayecto ON (trayecto.id_tren = tren.id);```

SELECT pasajero.id, pasajero.nombre, COUNT(viaje.id) AS num_viajes FROM pasajero
LEFT JOIN viaje ON (viaje.id_pasajero = pasajero.id)
GROUP BY (pasajero.id)
HAVING COUNT(viaje.id) > 2
ORDER BY num_viajes DESC;

MUY BIEN EXPLICADO GRACIAS AQUÍ DEJO MI APORTE CON EL INNER JOIN

-- Para ver los pasajeros que hicieron un viaje
SELECT * FROM pasajero
JOIN viaje ON (viaje.id_pasajero = pasajero.id);

-- Para ver los pasajeros que no hicieron un viaje
SELECT * FROM pasajero
LEFT JOIN viaje ON (viaje.id_pasajero = pasajero.id)
WHERE viaje.id IS NULL;

<SELECT nombre, AGE(CURRENT_DATE, fecha_nacimiento) as edad, fecha_nacimiento
FROM pasajeros as p
LEFT JOIN viajes as v on v.pasajero_id = p.pasajero_id
WHERE viaje_id is NULL;>

con el pgadmin es realmente sencillo hacer las consultas

La unión de dos consultas para traer todos los datos, tengan o no relación

Hola!

No se si mi descripción del query esta correcta:

– cuantos viajes hizo un pasajero
SELECT pasajero.id, nombre, COUNT(pasajero.id)
FROM pasajero
JOIN viaje ON (viaje.id_pasajero = pasajero.id)
GROUP BY pasajero.ID;

– trae todos los trayectos que tienen tren
SELECT * FROM tren
RIGHT JOIN trayecto ON (trayecto.id_tren = tren.id)
WHERE tren.id is not null

– Trae todos los trayectos y trenes
SELECT * FROM tren
FULL JOIN trayecto ON (trayecto.id_tren = tren.id)

–Trae todas las estaciones que no tienen trayecto
SELECT * FROM trayecto
RIGHT JOIN estacion ON (trayecto.id_estacion = estacion.id)
WHERE trayecto.id IS NULL

inner join intersección

left join

right join

outer join

Aqui un JOIN simple para ver a los pasajeros cuando iniciaron el viaje y cuando termino

SELECT p.nombre, v.inicio, v.fin FROM pasajero as p
JOIN viaje as v
ON (v.id_pasajero = p.id);

Ejecutando Join

Tipos de JOINS: 1.INNER JOINS, 2.LEFT JOINS, 3.RIGHT JOINS, FULL OUTHER

Joins son toda las teorias de conjuntos implementadas en los joins

--¿Cantidad de viajes por estación?
SELECT 
	e.id, e.nombre, e.direccion, count (v.id_trayecto) AS cantidad_llegadas FROM estacion AS e
INNER JOIN  trayecto AS t
	ON (e.id = t.id_estacion)
INNER JOIN viaje AS v 
	ON(v.id_trayecto = t.id)
GROUP BY e.id
ORDER BY cantidad_llegadas DESC
;

--¿Cuáles usuarios hicieron  viajes?
SELECT * FROM pasajero
INNER JOIN viaje  
	ON (viaje.id_pasajero =pasajero.id);


--¿Cuáles fueron los  usuarios  no  realizaron viaje?
SELECT * FROM pasajero
LEFT JOIN viaje
	ON (viaje.id_pasajero = pasajero.id)
WHERE viaje.id_pasajero IS NULL

;

--¿Cuáles  son los trenes (Id ,modelo, capacidad )que no tienen trayecto asignado?
SELECT * FROM tren
LEFT JOIN  trayecto 
	ON (trayecto.id_tren = tren.id)
WHERE trayecto.id_tren IS NULL
;

SELECT * FROM viaje
WHERE EXTRACT (YEAR FROM viaje.inicio) ='2019';

SELECT * FROM viaje
WHERE  viaje.inicio >'2019-01-1' AND  viaje.inicio <'2019-01-31';


--¿Cuáles son usauarios viajaron  en el año 2019 y a que estación llegaron?
SELECT 
	p.id AS identificador, p.nombre AS nombre_pasajero, 
	v.inicio AS fecha_viaje, e.nombre  AS nombre_estacion  
FROM viaje AS  v
INNER JOIN	pasajero AS p 
	ON ( p.id = v.id_pasajero  )
INNER JOIN trayecto AS t 
	ON  (t.id = v.id_trayecto)
INNER JOIN estacion AS e
	ON (e.id = t.id_estacion)
WHERE EXTRACT (YEAR FROM v.inicio) ='2019';

;
	
--¿Cuáles son usauarios tienen reserva   entre la fecha 2019-01-01 y 2019-01-31 y a que estación llegaron?	
SELECT 
	p.id AS identificador, p.nombre AS nombre_pasajero, 
	v.inicio AS fecha_viaje, e.nombre  AS nombre_estacion
FROM viaje AS  v
INNER JOIN	pasajero AS p 
	ON ( p.id = v.id_pasajero  )
INNER JOIN trayecto AS t 
	ON  (t.id = v.id_trayecto)
INNER JOIN estacion AS e
	ON (e.id = t.id_estacion)
WHERE  v.inicio >'2019-01-01' AND  v.inicio <'2019-01-31'
	
;

//Estaciones en trayectos
SELECT * FROM estacion
JOIN trayecto On (trayecto.id_estacion = estacion.id)

//Trenes en trayectos
SELECT * FROM tren
JOIN  trayecto On (trayecto.id_tren = tren.id)

😄

SELECT * FROM trenes
RIGHT JOIN trayectos ON (trayectos.id_tren = trenes.id)

Con un Right Join sencillo me trae todos los trayectos y sus coincidencias de trenes. Acá no aparece ningún trayecto sin tren porque por la dependencia no pueden existir trayectos sin tren.

Aquí va mi aporte con un RIGHT JOIN y un OUTER EXCLUDING JOIN: