No tienes acceso a esta clase

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

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

16D
5H
48M
4S
Curso Pr谩ctico de SQL

Curso Pr谩ctico de SQL

Israel V谩zquez Morales

Israel V谩zquez Morales

Productos cartesianos (JOIN)

6/29
Recursos

Aportes 45

Preguntas 8

Ordenar por:

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

o inicia sesi贸n.

Esta imagen es muy 煤til. Se debe tener en cuenta que el full join no aplica para todos los manejadores de bases de datos.

Para ser el curso pr谩ctico me parece que tiene mucha teor铆a鈥 馃槓

Las siguientes sentencias son equivalentes:

Tabla1 LEFT JOIN Tabla2
Tabla2 RIGHT JOIN Tabla1

este im谩genes son mi formulario me han ayudado mucho mientras aprendo bases de datos:

estas son las mas: usadas:

aqui se mencionan algunas formas de join que son implicitas (semi join):

en estas ultimas se muestran algunas relaciones entre 3 o mas tablas, sin embargo en el poco camino que llevo aprendiendo sql鈥 aun no las he usado:

Les comparto una prueba que hice para entender bien el tema de los join, esta en la web de Kaggle, sin c贸digo es complicado tenerlo claro:

/*Creando tabla propietarios 'owners'*/
CREATE TABLE public.owners 
(
	id serial,
	name varchar(50) NOT NULL,
	age smallint NOT NULL	
);

/*Se me olvido el campo pet_id y lo he tenido que ingresar con ALTER TABLE*/
ALTER TABLE public.owners
ADD pet_id integer NULL;


/*Agregando la clave primaria*/
ALTER TABLE public.owners
ADD PRIMARY KEY(id);

/*Creando tabla de mascotas 'pets'*/
CREATE TABLE public.pets 
(
	id serial,
	name varchar(50) NOT NULL,
	age smallint NOT NULL,
	animal varchar(50) NOT NULL
);

/*Agregando la clave primaria de mascotas 'pets'*/
ALTER TABLE public.pets
ADD PRIMARY KEY (id);

/*Agregando la clave foranea a la tabla 'owners' haciendo referencia a la tabla 'pets'*/
ALTER TABLE public.owners
ADD
CONSTRAINT fkpet 
FOREIGN KEY (pet_id) 
REFERENCES public.pets(id);


/*Insertando valores de prueba*/
INSERT INTO public.owners (name, age, pet_id)
VALUES ('Aubrie Little',20,1), 
	   ('Chett Crawfish',45,3), 
	   ('Jules Spinner',10,4), 
	   ('Magnus Burnsides',9,2), 
	   ('Veronica Dunn',8,NULL);
	   
INSERT INTO public.pets (name, age, animal)
VALUES ('Dr. Harris Bonkers',1,'Rabbit'), 
	   ('Moon',9,'Dog'), 
	   ('Ripley',7,'Cat'), 
	   ('Tom',2,'Cat'), 
	   ('Maisie',10,'Dog');

/*
----------------------------------------------------------
Obtenemos todos los valores de la tabla propietarios o due帽os, independientemente de si tiene valores que coinciden en la tabla pets.

LEFT JOIN hace referencia a la tabla que esta asignada antes del JOIN es decir owner
*/
SELECT
ow.name AS owner_name, pt.name AS pet_name
FROM public.owners AS ow
LEFT JOIN public.pets AS pt
ON (ow.pet_id = pt.id);

/*
Obtenemos todos los valores de la tabla mascotas, independientemente de si tiene valores que coinciden en la tabla propietarios.

RIGHT JOIN hace referencia a la tabla que esta asignada despues del JOIN es decir pets
*/
SELECT
ow.name AS owner_name, pt.name AS pet_name
FROM public.owners AS ow
RIGHT JOIN public.pets AS pt
ON (ow.pet_id = pt.id);


/*
Trae todos los valores de ambas tablas, independientemente si estan conectados, en las filas que no tienen coincidencias se rellenan con valores NULL
*/
SELECT
ow.name AS owner_name, pt.name AS pet_name
FROM public.owners AS ow
FULL JOIN public.pets AS pt
ON (ow.pet_id = pt.id);

Espero les sea de ayuda.

El producto cartesiano es una operaci贸n de la teor铆a de conjuntos en la que dos o m谩s conjuntos se combinan entre s铆. En el modelo de base de datos relacional se utiliza el producto cartesiano para interconectar conjuntos de tuplas en la forma de una tabla. El resultado de esta operaci贸n es otro conjunto de tuplas ordenadas, donde cada tupla est谩 compuesta por un elemento de cada conjunto inicial.
Fuente: https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/sql-join/#:~:text=El producto cartesiano es una,la forma de una tabla.

El profe hablando del join mostrando un enredo y yo pensando en mis notas de obsidian

4. PRODUCTOS CARTESIANOS (Join)

- SELECT *

FROM tabla_diaria AS td 鈥> Selecciona la tabla indicada y le da el alias de "td"
JOIN tabla_mensual AS tm 鈥> Relaciona la tabla diaria con la tabla mensual y la renombre con el alias "tm"
ON tdpk = tmfk; 鈥> Relaciona la llave principal 鈥.pk鈥 (primary key) con la llave for谩nea 鈥.fk鈥 (foranean key).
- Se debe tener cuidado al realizar productos cartesianos pues se puede llegar a una soluci贸n muy compleja.
- Left Join: Toma la tabla de la izquierda y conserva todos sus elementos junto con los elementos de la segunda tabla que pertenezcan a al primera tabla.

- Right Join:Toma la tabla de la derecha y conserva todos sus elementos junto con los elementos de la segunda tabla que pertenezcan a al primera tabla.



- Exclusive Left Join: Toma los elementos de la tabla de la izquierda pero que NO est谩n en la tabla de la derecha.
  • Exclusive Right Join: Toma los elementos de la tabla de la izquierda pero que NO est谩n en la tabla de la derecha.

  • Full Outer Join: Trae todos los elementos de la primera tabla y todos los elementos de la segunda tabla.

  • Excusive Full Outer Join: Trae los elementos que existen en la primera tabla y los elementos de la segunda tabla pero que NO son en com煤n

  • Inner Join: Cuando no se espec铆fica el tipo de Join, por default se ejecuta este. Que trae solamente los elementos en com煤n de las tablas

Prod. Cartesiano (JOIN)

  • Es la combinaci贸n de m谩s de una tabla a trav茅s de una o m谩s sentencias de relaci贸n
  • Normalmente se usa una Primary Key y una Foreign Key

Israel tiene magia para explicar, se nota tu amor por los datos, sin lugar a dudas tus cursos solos valen la sucripci贸n de Platzi

Recuerda que al hacer JOINS y unir tablas, en algunos casos puedes tener informaci贸n duplicada en las dimensiones, as铆 que siempre debes estar validando no estar duplicando la informaci贸n, o analizarla de forma correcta, para el tema de an谩lisis de datos debemos siempre validar que la info que estamos mostrando es real.

algunos ejemplos de joins

[SQL Joins ](

6. Productos cartesianos (JOIN)

  • Sacar todos los datos de todas las tablas que tengo involucradas.
  • No es deseable hacer todos contra todos.
  • Tener equivalente a cada join en los diagramas de Venn
SELECT * 
FROM tabla_diaria AS td
	JOIN tabla_mensual AS tm
	ON td.pk = tm.fk;

Left Join

  • Elementos que existen a A, sin importar que est茅n en B.

Right Join

  • Elementos que existen en B, sin importar que est茅n en A.

Exclusive Left Join

  • Lo que existe en A que no exista en B.

Exclusive Right Join

  • Lo que existe en B que no exista en A.

Full Outer Join 鈥 Rara vez se ocupa 鈥 No es muy performante

  • Todo lo de A con todo lo de B.

Exclusive Full Outer Join

  • Todo lo de A con todo lo de B, excepto lo que coincida.

Inner Join 鈥 M谩s com煤n 鈥 Default

  • Solamente lo que tengan en com煤n las tablas A y B.

Si hacemos:

ON td.fk = td.pk

Es m谩s 贸ptimo o el optimizador de consultas de los SGBD lo resuelve??
Dado que hacer un FK contra una PK, genera menos data que hacer un PK contra N FKs

Es importante no confundir la visualizacion de los conjuntos:

  1. En el caso del diagrama de ben no varia la posicion de los conjuntos con relacion al porcentaje de interseccion que tienen.
  2. Por lo tanto la interseccion parece siempre la misma, pero puede darse el caso que todo A se intersecte con todo B, y ver谩s que los circulos siguen en la misma posicion.
  3. Por eso es importante comprender el funcionamiento mas que la imagen misma.

siento que este curso deberia estar antes, me hubiera servido demasiado verlo antes hacer el de postgre

CROSS JOIN is the keyword for the basic join without a WHERE clause. Therefore

SELECT * 
FROM EMPLOYEE, COMPENSATION ; 

can also be written as

SELECT * 
FROM EMPLOYEE CROSS JOIN COMPENSATION ; 

The result is the Cartesian product (also called the cross product) of the two source tables.

PRUEBA ESTOS COMANDOS CON LOS JOINS

SELECT * FROM platzi.alumnos AS ta
INNER JOIN platzi.carreras AS tc
ON ta.carrera_id = tc.id;

ejemplo de consulta, con tablas relacionadas!

Un ejemplo de como yo uso las bases de datos. Manejo un sistema con bases de datos, y la plataforma genera reportes csv, hay una tabla que tiene como columna un titulo, resulta que al generar el reporte, no arroja el csv y esto por que en una fila de una columna o un registro, se guardo mal, y el error del sistema me aparecia que no pod铆a obtener un t铆tulo. Asi que, haciendo un an谩lisis de donde podria encontrarse ese dato en una columna, ya localizado, pude borrar ese registro. Al final, obtuve el reporte de 5 a帽os en un csv.

A trav茅s de los JOIN podemos recorrer por todos los datos de la BASE DE DATOS. 馃槷

*Para **unir** tablas se **utiliza** la propiedad* **JOIN***, **despu茅s** de la sentencia* **FROM***. La sentencia* **JOIN** *se **basa** en la teor铆a de conjuntos, **existentes** **varios** **tipos** de sentencia* **JOIN***.* `Por ``diferencia`` ``LEFT JOIN``.` `/*` `Syntax` `SELECT *` `FROM tableName` `LEFT JOIN tableName ON foreingKey = foreignKey;` `*/` `SELECT *` `FROM users` `LEFT JOIN posts ON usersID = postsID;` `Por ``diferencia`` ``RIGHT JOIN``.` `/*` `Syntax` `SELECT *` `FROM tableName` `RIGHT JOIN tableName ON foreingKey = foreignKey;` `*/` `SELECT *` `FROM users` `RIGHT JOIN posts ON usersID = postsID;` `Por intersecci贸n ``INNER JOIN``.` `/*` `Syntax` `SELECT *` `FROM tableName` `INNER JOIN tableName ON foreingKey = foreignKey;` `*/` `SELECT *` `FROM users` `INNER JOIN posts ON usersID = postsID;` `Por union ``UNION``.` `/*` `Syntax` `SELECT *` `FROM tableName` `LEFT JOIN tableName ON foreingKey = foreignKey` `UNION` `SELECT *` `FROM tableName` `RIGHT JOIN tableName ON foreingKey = foreignKey;` `*/` `SELECT *` `FROM users` `LEFT JOIN posts ON usersID = postsID` `UNION` `SELECT *` `FROM users` `RIGHT JOIN posts ON usersID = postsID;` `Por ``diferencia`` sim茅trica ``WHERE``.` `/*` `Syntax` `SELECT *` `FROM tableName` `LEFT JOIN tableName ON foreingKey = foreignKey` `WHERE foreingKey IS NULL` `UNION` `SELECT *` `FROM tableName` `RIGHT JOIN tableName ON foreingKey = foreignKey` `WHERE foreingKey IS NULL;` `*/` `SELECT *` `FROM users` `LEFT JOIN posts ON usersID = postsID` `WHERE foreingKey IS NULL` `UNION` `SELECT *` `FROM users` `RIGHT JOIN posts ON usersID = postsID` `WHERE foreingKey IS NULL;`

Comparto mi practica de lo que aprendi de la clase

SELECT * 
FROM platzi.alumnos AS a
INNER JOIN platzi.carreras AS c ON c.id = a.carrera_id; 
-- Left join
SELECT a.nombre, a.apellido, c.carrera, c.vigente AS estado
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c ON c.id = a.carrera_id;
-- Left join with exclusion
SELECT a.nombre, a.apellido, c.carrera, c.vigente AS estado
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c ON c.id = a.carrera_id
WHERE c.id IS NULL;
-- Right join
SELECT c.carrera, a.colegiatura AS Valor_carrera, a.nombre, a.apellido
FROM platzi.carreras AS c
RIGHT JOIN platzi.alumnos AS a ON a.carrera_id = c.id;
-- Right join with exclusion
SELECT c.carrera, a.colegiatura AS Valor_carrera, a.nombre, a.apellido
FROM platzi.carreras AS c
RIGHT JOIN platzi.alumnos AS a ON a.carrera_id = c.id
WHERE c.idIS NULL;
-- Inner join
SELECT a.nombre, a.apellido, c.carrera, c.vigente
FROM platzi.alumnos AS a
INNER JOIN platzi.carreras AS c ON c.id = a.carrera_id;
-- Full outer join
SELECT *
FROM platzi.alumnos AS a
FULL OUTER JOIN platzi.carreras AS c ON c.id = a.carrera_id;
-- Full outer join with exclusion
SELECT a.nombre, a.apellido, c.carrera, c.vigente AS estado
FROM platzi.alumnos AS a
LEFT JOIN platzi.carreras AS c ON c.id = a.carrera_id
WHERE c.id IS NULL
UNION ALL
SELECT a.nombre, a.apellido, c.carrera, c.vigente AS estado
FROM platzi.alumnos AS a
RIGHT JOIN platzi.carreras AS c ON c.id = a.carrera_id
WHERE a.carrera_id IS NULL;

Estaria bueno que mostrara un peque帽o ejemplo de joins con tablas. Cuando se refiere a los 鈥渆lementos鈥 de un grupo o tabla se refiere a registros, no a columnas.

Suele ocurrir que con inner join se pueden repetir los registros y por ello a veces es mas recomendable left join 鉁岋笍

![](
![](
![](

Los RIGHT & LEFT joins son lo mismo, solo que se cambia cual tabla es llamada primero

Muy buen dato, con esto mejorar茅 una consulta de mi sistema.

Ejemplo de Join:

SELECT nombre, apellido, carrera_id, carreras.carrera FROM platzi.alumnos JOIN platzi.carreras
ON alumnos.carrera_id = carreras.id;

Es necesario elegir bien un Join para no gastar recursos de m谩s, podemos usar los diagramas de Ben para guiarnos:

Exclusive Left Join: Solo existe en A pero que no est谩n en la B
Exclusive Right Join: Solo existe en B pero que no est谩n en la A
Full Outer Join: El producto cartesiano, traes todos los elementos de las 2 tablas.
Exclusive Full Outer Join: Trae A y B pero evita traer los elementos en com煤n
Inner Join: Lo que tienes en com煤n en ambas tablas

<SELECT* 
FROM tabla_diaria AS td 
JOIN tabla_mensual AS tm 
ON td.pk=tm.fk

---se utiliza teoria de conjuntos---
left join -- traer todo lo del lado de la izquierda (conjunto a) y 
--la relacion que tiene con un conjunto b.

Right join -- traer todo lo del lado derecho (conjunto b) y la relacion 
--que tiene con el conjunto a.

exclusive left join -- trae todos los elementos del lado izquierdo (conjunto a) 
--que no existe en el conjunto b

exclusive Right join --trae todos los elementos del lado izquierdo (conjunto b)
--que no existe en el conjunto a> 

Anterior mente el profesor menciono que hay casos en que tendremos que unir do tablas de base de datos diferentes, pero con la diferencia que estas se encontraban en el mismo host, justamente tuve una semana frustrado por no poder realizar mi query de manera exitosa, pasaba que se me duplicaban, que si de echo eran muchos, se convirti贸 en una cat谩strofe.
Para ello la soluci贸n solo fue una peque帽a instrucci贸n

<DISTINCT> 

Para mi la soluci贸n fue usar esta instrucci贸n de la siguiente manera

<SELECT DISTINCT bd.campo.......> 

Espero darme a entender

Hubiera deseado ver los ejemplos del uso de los JOIN en conjunto con la explicaci贸n te贸rica.

Sin duda que el Join ayuda mucho a saber por d贸nde vamos a atacar esa base de datos o que parte de los datos son las que nos interesan.

Existen comando para cuando tengo m谩s de dos tablas?