No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de PostgreSQL

Curso de PostgreSQL

Oswaldo Rodr铆guez Gonz谩lez

Oswaldo Rodr铆guez Gonz谩lez

Cruzar tablas: SQL JOIN

18/32
Recursos

Aportes 98

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

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

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.鈥淚d_pasajero鈥=pasajero.鈥淚d鈥)

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.

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:

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 鈥渧iaje鈥 y me lo saltee?

El rigth join con trayecto y tren
SELECT
*
FROM
trayecto
RIGHT JOIN
tren
ON
(trayecto.鈥淚d_tren鈥=tren.鈥淚d鈥);

鈥 FULL OUTER JOIN
SELECT
*
FROM
trayecto
FULL OUTER JOIN
tren
ON
(trayecto.鈥淚d_tren鈥=tren.鈥淚d鈥);

ESTACION Y TRAYECTO
鈥揊ull outer join
SELECT
*
FROM
trayecto
FULL OUTER JOIN
estacion
ON
(trayecto.鈥淚d_estacion鈥=estacion.鈥淚d鈥);
鈥揜IGHT JOIN
SELECT
*
FROM
trayecto
RIGHT JOIN
estacion
ON
(trayecto.鈥淚d_estacion鈥=estacion.鈥淚d鈥);

Comparto un join de las tablas de estacion, tren y trayecto
SELECT
trayecto.鈥淚d鈥 as IdTrayecto,
trayecto.鈥淣ombre鈥 as Nombre,
tren.鈥淢odelo鈥 as tren,
tren.鈥淐apacidad鈥 as Capacidad,
estacion.鈥淣ombre鈥 as estacion,
estacion.鈥淒ireccion鈥 as ubicacion
FROM
trayecto
JOIN
tren
ON
(trayecto.鈥淚d_tren鈥=tren.鈥淚d鈥)
JOIN
estacion
ON
(trayecto.鈥淚d_estacion鈥 = estacion.鈥淚d鈥)

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;

Hecho 馃槉

  • 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

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

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.

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

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

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)

鈥揟rae 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

Los Joins son b谩sicamente toda la teor铆a de conjunto aplicada a SQL

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:

Tipos de Join

Ejemplo con INNER JOIN

Ejemplo con LEFT JOIN

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

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;

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;

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

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

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

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

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 );
SELECT p.nombre AS PASAJERO, v.inicio AS INICIO_VIAJE, v.fin FIN_VIAJE, 
       e.nombre AS ESTACION, e.direccion AS DIRECCION_EST, tr.modelo AS MODELO_TREN
FROM pasajero AS p
INNER JOIN viaje AS v
ON p.id = v.id_pasajero
INNER JOIN trayecto AS t
ON v.id_trayecto = t.id
INNER JOIN estacion AS e
ON t.id_estacion = e.id
INNER JOIN tren AS tr
ON  t.id_tren = tr.id;