No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

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 47

Preguntas 8

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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:

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

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.

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

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.

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.

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.

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

*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;`
SELECT nombre, apellido, carrera
FROM platzi.alumnos
JOIN platzi.carreras ON alumnos.carrera_id = carreras.id;

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

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

SELECT carreras.carrera, COUNT(alumnos.id) AS cantidad_alumnos
FROM platzi.carreras
LEFT JOIN platzi.alumnos ON carreras.id = alumnos.carrera_id
GROUP BY carreras.carrera;

Estos son solo ejemplos simples, y las consultas pueden variar según tus necesidades específicas.

Qué buena explicación! Gracias.
```txt Los diagramas de join, también conocidos como "diagrama de relaciones" o "diagrama de unión", son herramientas visuales utilizadas para representar y entender cómo se conectan las tablas en una base de datos relacional mediante operaciones de JOIN. Estos diagramas son útiles para diseñar consultas SQL complejas y para visualizar cómo se relacionan los datos entre diferentes tablas. Tipos Comunes de Joins Inner Join: Descripción: Devuelve solo las filas que tienen coincidencias en ambas tablas. Diagrama: Se representa con un cruce entre las tablas involucradas, mostrando las filas que cumplen la condición de la unión. Left Join (o Left Outer Join): Descripción: Devuelve todas las filas de la tabla de la izquierda y las filas coincidentes de la tabla de la derecha. Si no hay coincidencia, las columnas de la tabla de la derecha tendrán valores nulos. Diagrama: La tabla de la izquierda se representa completa, mientras que la tabla de la derecha muestra solo las filas coincidentes, con áreas que podrían estar vacías si no hay coincidencias. Right Join (o Right Outer Join): Descripción: Devuelve todas las filas de la tabla de la derecha y las filas coincidentes de la tabla de la izquierda. Si no hay coincidencia, las columnas de la tabla de la izquierda tendrán valores nulos. Diagrama: Similar al Left Join, pero la tabla de la derecha se representa completa. Full Join (o Full Outer Join): Descripción: Devuelve todas las filas cuando hay una coincidencia en una de las tablas. Si no hay coincidencia, el resultado incluirá valores nulos para las columnas de la tabla sin coincidencia. Diagrama: Muestra todas las filas de ambas tablas, con áreas superpuestas para las coincidencias y áreas separadas para las filas sin coincidencias. Cross Join: Descripción: Devuelve el producto cartesiano de las dos tablas, es decir, todas las combinaciones posibles de filas entre las dos tablas. Diagrama: Muestra una cuadrícula donde cada fila de la primera tabla se combina con cada fila de la segunda tabla. Representación Visual En los diagramas de join, puedes usar diferentes formas y líneas para representar las relaciones entre tablas. Los diagramas pueden incluir: Tablas: Representadas como bloques o rectángulos. Relaciones: Líneas que conectan los bloques, indicando cómo se unen las tablas. Condiciones de Join: Anotaciones o etiquetas que especifican las condiciones de la unión (por ejemplo, table1.id = table2.id). Ejemplo Imagina que tienes dos tablas: Clientes y Pedidos. Clientes: id_cliente, nombre_cliente Pedidos: id_pedido, id_cliente, fecha_pedido Un diagrama de join para un INNER JOIN entre estas dos tablas, basado en id_cliente, mostraría: sql Clientes +------------+ | id_cliente | | nombre | +------------+ Pedidos +-----------+ | id_pedido | | id_cliente| | fecha | +-----------+ Join Clientes.id_cliente = Pedidos.id_cliente Este diagrama visualiza cómo las filas de Clientes se emparejan con las filas de Pedidos basadas en la columna id_cliente. En resumen, los diagramas de join son herramientas visuales que ayudan a entender cómo se relacionan las tablas en una base de datos y cómo se combinan los datos mediante diferentes tipos de uniones. ```
* Hay una confusión en la explicación sobre FULL OUTER JOIN, a partir del minuto 7:11. * La gráfica SÍ corresponde al concepto, pero la explicación da a entender que el resultado de FULL OUTER JOIN es el mismo de CROSS JOIN (que no se ha explicado hasta ahora en este curso), lo cual es incorrecto. * Creo que la diferencia entre FULL OUTER JOIN y CROSS JOIN, la podría aclarar ChatGPT con un ejemplo sencillo: * *\[Advertencia previa: No estoy seguro que la copia de esta respuesta, funcione bien en esta nueva plataforma]* * Aquí la respuesta de ChatGPT: * La diferencia clave entre \*\*FULL OUTER JOIN\*\* y \*\*CROSS JOIN\*\* es cómo combinan los registros de dos tablas: * 1\. \*\*FULL OUTER JOIN\*\*: Combina todas las filas de ambas tablas, devolviendo los registros coincidentes y aquellos que no tienen correspondencia en una de las tablas, rellenando con `NULL` donde falten valores. * 2\. \*\*CROSS JOIN\*\*: Devuelve el producto cartesiano de ambas tablas, es decir, cada fila de la primera tabla se combina con todas las filas de la segunda tabla. No necesita condición de unión. * \### Ejemplo: * \#### Tablas: * \- `A`: * | id | name | * |----|-------| * | 1 | Anna | * | 2 | Ben | * * \- `B`: * | id | city | * |----|-----------| * | 1 | New York | * | 3 | London | * * \#### \*\*FULL OUTER JOIN\*\*: * ```js SELECT * FROM A FULL OUTER JOIN B ON A.id = B.id; ```SELECT \* FROM A FULL OUTER JOIN B ON A.id = B.id; * \*\*Resultado\*\*: * | id | name | id | city | * |-----|-------|-----|----------| * | 1 | Anna | 1 | New York | * | 2 | Ben | NULL| NULL | * | NULL| NULL | 3 | London | * * \#### \*\*CROSS JOIN\*\*: * * ```js SELECT * FROM A CROSS JOIN B; ```SELECT \* FROM A CROSS JOIN B; * \*\*Resultado\*\*: * | id | name | id | city | * |-----|-------|-----|----------| * | 1 | Anna | 1 | New York | * | 1 | Anna | 3 | London | * | 2 | Ben | 1 | New York | * | 2 | Ben | 3 | London |
# Tipos de JOIN en SQL 1. **INNER JOIN**: Retorna las filas cuando hay coincidencias en ambas tablas. 2. **LEFT JOIN (o LEFT OUTER JOIN)**: Retorna todas las filas de la tabla de la izquierda y las coincidencias de la tabla de la derecha. Si no hay coincidencias, rellena con valores `NULL`. 3. **RIGHT JOIN (o RIGHT OUTER JOIN)**: Retorna todas las filas de la tabla de la derecha y las coincidencias de la tabla de la izquierda. Si no hay coincidencias, rellena con valores `NULL`. 4. **FULL JOIN (o FULL OUTER JOIN)**: Retorna todas las filas cuando hay coincidencias en cualquiera de las tablas. Si no hay coincidencias, rellena con valores `NULL` en la tabla que no tiene datos. 5. **CROSS JOIN**: Retorna el **producto cartesiano** de ambas tablas, es decir, todas las combinaciones posibles entre las filas de ambas tablas.

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

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 “elementos” 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?