Cruzar tablas: SQL JOIN

Tipos de Join

Alejandro Cruz Martínez

--------------------------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;								*/

rusbel bermúdez rivera

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

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

joreir

El mejor resumen

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

DAVID EDUARDO BAEZ SANCHEZ

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;

Martin DAVILA

Wilson Marino Pablo Mendez

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;

Gabriel Obregón

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

Cristian Palacios Beltran

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

Christian Andres Moreno Ceballos

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.

Jhon Stiven Posso Cardona

hace 8 meses

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 >

Adrian Castillo Ramírez

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

juanreinaguti

Estas son las consultas que hice:

Miguel Ángel Mateo Tavarez

hace 4 meses

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

Joel Sierra Mendoza

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;

Liliana Londono Agudelo

Ejemplo de una de las consultas que realice:

RubenSH

Platzi Team

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

Cristian Palacios Beltran

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

Cristian Palacios Beltran

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

Mateo Posada

hace 21 días

Gracias

Ana Cecilia Bernal García

hace 23 días

Captura de pantalla 2023-03-09 204218.png

Yoni Eduardo Ortiz Rojas

hace un mes

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;

Ian Cristian Ariel Yané

hace un mes

Bryan Carvajal

hace un mes

Hecho 😊

Carlos Eduardo Bracho Rosales

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

Alejandra Concepcion Gonzalez Sosa

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

jarek tovar martinez

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

Miguel Angel Lopez Monroy

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

Sandra Fiallos Ruiz(Sandre)

Using full joing

Pablo Huete Hernández

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

Guido Rivas

Código para tren:

Gilbert Ardila

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

Wilson Cortes Alvarez

hace 4 meses

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

Xavier Caviedes

hace 5 meses

Comparto mi consulta para los trenes y sus trayectos correspondientes:

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

Wilner Alexander Ochoa Vivas

hace 5 meses

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

Maximiliano Vazquez Massaro

hace 6 meses

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

Andersson Padilla

hace 7 meses

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

Ricardo Gomez

hace 8 meses

Johan Diaz

hace 8 meses

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

Daniel Enrique Merchan

hace 9 meses

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

Sergio Alexander Cadena

hace 9 meses

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;

CARLOS FRANZ GUTIERREZ GUTIERREZ

hace 10 meses

Resuelto el ejercicio:

Iván Santiago Tellez Hernandez

hace 10 meses

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.

Elliot Ramirez

Para poder realizarlo le incluí las comillas

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

Mauricio Perilla Rodriguez

SQL JOINS - Imagen del vídeo

Jhon Eiber Hurtado

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

Christian David Tovar Tirado

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

Jeisson Espinosa

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

Jhonatan David Ibarra Lavado

estupendo. me encanto la forma de hacer data ejemplo cool

Mariano Gobea Alcoba

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;

Reinaldo Omar Mendoza Leal

Los join son una maravilla y super simples de entender

Andrea Viviana Diaz Fonseca

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;

Santiago Rodriguez Chaves

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.

Oscar Eduardo Chaparro Blancas

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!

Luis David Martinez Espinosa

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

RubenSH

Platzi Team

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

Osvaldo Olguín

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

Eduardo Casaño

Juan Fernando López Hernández

Captura de pantalla 2021-11-09 a la(s) 15.12.01.png

Cristian Camilo Hernández Ramírez

Comando join
LEFT join
Todos los otros tipos de join

Jorge Enrique Fernández Arango

comparto mis query, espero que sirvan de ayuda:

Miguel Ángel Reyes Moreno

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

Giancarlo Zevallos Lecca

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"

Gerardo Mayel Fernández Alamilla

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;

Andres Felipe Cogollo Hincapie

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

Lery Andy Piérola Lazarte

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;

Luis Nilson Palma Campos

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

Boris Vargas Paucara

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

Flavio César Sandoval Muñoz

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

cconde

con el pgadmin es realmente sencillo hacer las consultas

andoni

andoni

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

Maitte Gutierrez

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

Marco Antonio González Arellano

jcbarrales

inner join intersección

left join

right join

outer join

Gerson Pac

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

YUELY RIOS MORALES

Ejecutando Join

Angel de Jesus Quintero Pereira

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

Angel de Jesus Quintero Pereira

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

Angel de Jesus Quintero Pereira

Joins son toda las teorias de conjuntos implementadas en los joins

Angel de Jesus Quintero Pereira

--¿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'
	
;

Ramón Ruiz

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

Miguel Torres

Profe Platzi

😄

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.

Daniel Marino Gutierrez Camelo

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

luifer088

Tipos de Join

luifer088

Ejemplo con INNER JOIN

luifer088

Ejemplo con LEFT JOIN

Juan David Suarez

Intenté hacer otra que es de que pasajeros viajan en cada tren, pero tengo que investigar más de ella debido a que tren y pasajeros no se relacionan directamente en una tabla.

-- En que estacion pasa cada tren
select estacion.nombre, tren.modelo
from trayecto
join estacion on (estacion.id_estacion = trayecto.id_estacion)
join tren on (tren.id = trayecto.id_tren);

Joan Garcia

Algunas consultas que se me ocurrieron:

-- Pasajeros que han tomado mas de 3 viajes
SELECT pa.nombre, COUNT(*) AS cantidad_viajes
FROM pasajero AS pa
	JOIN viaje AS vi ON (vi.id_pasajero = pa.id)
GROUP BY pa.id
HAVING COUNT(*) >= 3
ORDER BY cantidad_viajes DESC;

-- Trenes que tienen mas de un trayecto
SELECT 
	tr.id,
	tr.modelo,
	COUNT(*) AS cantidad_trayectos
FROM tren AS tr
	JOIN trayecto ON (trayecto.id_tren = tr.id)
GROUP BY tr.id
HAVING COUNT(*) >= 3
ORDER BY cantidad_trayectos DESC;

-- Los 5 trenes que tienen mas trayectos y sus trayectos separados por coma
SELECT 
	tr.id,
	tr.modelo,
	COUNT(*) AS cantidad_trayectos,
	string_agg(trayecto.nombre, ',') AS trayectos
FROM tren AS tr
	JOIN trayecto ON (trayecto.id_tren = tr.id)
GROUP BY tr.id
ORDER BY cantidad_trayectos DESC
LIMIT 5;

-- Los 5 pasajeros que han tomado mas viajes y nombre de las estaciones 
-- desde donde tomaron esos viajes separadas por '/'
SELECT
	pa.id,
	pa.nombre, 
	COUNT(*) AS cantidad_viajes,
	string_agg(es.nombre, '/') AS estaciones
FROM pasajero AS pa
	JOIN viaje AS vi ON (vi.id_pasajero = pa.id)
	JOIN trayecto AS tra ON (tra.id = vi.id_trayecto)
	JOIN estacion AS es ON (es.id = tra.id_estacion)
GROUP BY pa.id
ORDER BY cantidad_viajes DESC
--fetch first 5 rows only
LIMIT 5;

-- Idetificar trenes por capacidad
-- pequeno 0 pasajeros < capacidad <= 10 pasajeros
-- mediano 10 pasajeros < capacidad <= 50 pasajeros
-- grande 50 pasajeros < capacidad
SELECT 
	tre.id,
	tre.modelo,
	tre.capacidad,
	CASE
		WHEN tre.capacidad > 50 THEN 'Grande'
		WHEN tre.capacidad > 10 THEN 'Mediano'
		ELSE 'Pequeno'
	END AS "Clasificacion"
FROM tren AS tre;

-- Pasajeros que han tomado viajes en 2019 y 2020
-- nombre de la estacion desde donde tomaron el viaje
-- y la capacidad del tren que abordaron
SELECT
	pa.id,
	pa.nombre,
	vi.inicio AS inicio_viaje,
	es.nombre AS nombre_estacion,
	tre.capacidad AS capacidad_tren
FROM pasajero AS pa
	JOIN viaje AS vi ON (vi.id_pasajero = pa.id)
	JOIN trayecto AS tra ON (tra.id = vi.id_trayecto)
	JOIN estacion AS es ON (es.id = tra.id_estacion)
	JOIN tren AS tre ON (tre.id = tra.id_tren)
WHERE EXTRACT(YEAR FROM vi.inicio) >= '2019'
ORDER BY pa.id ASC;

Cristian Jose Curup Muyus

join para ver cuantos pasajeros viajan en un tren

select count(v.id_pasajero) as Pasajeros, tr.id__tren as Tren
from trayecto as tr
join viaje as v
on (v.id_trayecto=tr.id)
group by tr.id__tren
order by tr.id__tren desc;

comprobando cuantos pasajeros viajan en el tren 98 para ver si coincide con el join realizado anterioremente

select v.id_pasajero,tr.id__tren
from viaje as v 
join trayecto as tr on (v.id_trayecto=tr.id)
where tr.id__tren = 98;

DOUGLAS OSMAR CALDERON MENDOZA

Select * from pasajero
right join viaje on pasajero.id= viaje.id_pasajero

Select * from trayecto
full outer join viaje on trayecto.id = viaje.id_trayecto

aperdomo1988

Mis querys

SELECT * FROM trayectos
JOIN estaciones ON (trayectos.id_estacion = trayectos.id)
JOIN trenes ON (trayectos.id_tren = trenes.id)
WHERE trayectos.nombre = 'Domainer';

SELECT * FROM trayectos
RIGHT JOIN trenes ON (trayectos.id_tren = trenes.id)
WHERE trayectos.nombre = 'Domainer';

jyfercolina

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

SELECT * FROM public.pasajero 
RIGHT Join public.viaje 
ON (viaje.id_pasajero = pasajero.id) 
WHERE viaje.id IS NULL;

SELECT * FROM public.pasajero 
FULL OUTER Join public.viaje 
ON (viaje.id_pasajero = pasajero.id);

SELECT * FROM public.pasajero 
FULL OUTER Join public.viaje 
ON (viaje.id_pasajero = pasajero.id) 
WHERE viaje.id_pasajero IS NULL OR pasajero.id IS NULL;

Jahdiel Herrera

SELECT *
FROM trenes
JOIN trayectos ON trayectos.id_tren = trenes.id
WHERE trenes.capacidad >= ‘100’;

Luis Fernando Zarazua Aguilar

Les compartó mis soluciones:

Estación

SELECT * FROM public.trayecto
RIGHT JOIN estacion ON (trayecto.id_estacion = estacion.id)
WHERE trayecto.id IS NULL
ORDER BY trayecto.id;

Tren

SELECT * FROM public.trayecto
RIGHT JOIN tren ON (trayecto.id_tren = tren.id)
WHERE trayecto.id IS NULL
ORDER BY tren.id;

Jhou Esmit Cajamarca Huaripaucar

--Pasajero/viaje
SELECT * FROM pasajero
JOIN viaje on (viaje.id_pasajero = pasajero.id);

--pasajero/viaje cuando is null
SELECT * FROM pasajero
LEFT JOIN viaje on (viaje.id_pasajero = pasajero.id)
WHERE viaje.id is NULL;

--estacion/tren
SELECT * FROM estacion
JOIN tren ON (tren.id =estacion.id);```

Carlo Maximiliano Tovar Rodriguez

Para unir trenes y estaciones:

SELECT * FROM trayectos AS t
JOIN trenes AS tr ON (t.id_tren = tr.id )
JOIN estaciones AS s ON (t.id_estacion = s.id );

CARLOS MARTINEZ