MySQL: desglose rápido de los tipos de combinaciones

Me gustaría un desglose rápido de los tipos de uniones MySQL. Sé de estos, el resto no estoy seguro de lo que significan.

• separados por comas (¿para qué es exactamente esta abreviatura?):SELECT * FROM a, b WHERE b.id = a.beeId AND ...
• muestra información de a, incluso si no hay coincidencias en b: SELECT * FROM a LEFT OUTER JOIN b ON b.id = a.beeId WHERE ...

He visto otras uniones, pero quiero saber qué las hace diferentes, qué es INNER/ OUTER, agregar LEFTcosas cambiantes.

Ya sé cómo funcionan las uniones, solo quiero saber si hay otros tipos de uniones, o si son solo formas diferentes de obtener el mismo resultado.

(c) Encontrado en G + "Visualización de datos"

o vea los siguientes enlaces para una buena visión general:

http://www.khankennels.com/blog/index.php/archives/2007/04/20/getting-joins/

http://www.codinghorror.com/blog/2007/10/a-visual-explanation-of-sql-joins.html

Según su comentario, las definiciones simples de cada uno se encuentran mejor en W3Schools. La primera línea de cada tipo ofrece una breve explicación del tipo de unión

• JOIN: devuelve filas cuando hay al menos una coincidencia en ambas tablas
• UNIÓN IZQUIERDA: Devuelve todas las filas de la tabla izquierda, incluso si no hay coincidencias en la tabla derecha
• UNIÓN DERECHA: Devuelve todas las filas de la tabla derecha, incluso si no hay coincidencias en la tabla izquierda
• FULL JOIN: devuelve filas cuando hay una coincidencia en una de las tablas

EDICIÓN FINAL

En pocas palabras, el ejemplo separado por comas que diste de

SELECT * FROM a, b WHERE b.id = a.beeId AND ...

está seleccionando cada registro de las tablas ayb con las comas que separan las tablas, esto también se puede usar en columnas como

SELECT a.beeName,b.* FROM a, b WHERE b.id = a.beeId AND ...

Luego obtiene la información instruida en la fila donde la columna b.id y la columna a.beeId coinciden en su ejemplo. Entonces, en su ejemplo, obtendrá toda la información de las tablas a y b donde b.id es igual a a.beeId. En mi ejemplo, obtendrá toda la información de la tabla b y solo la información de la columna a.beeName cuando b.id es igual a a.beeId. Tenga en cuenta que también hay una cláusula AND, esto ayudará a refinar sus resultados.

Para ver algunos tutoriales y explicaciones simples sobre las uniones mySQL y las combinaciones izquierdas, eche un vistazo a los tutoriales mySQL de Tizag. También puede consultar el sitio web de Keith J. Brown para obtener más información sobre las combinaciones que también es bastante buena.

Espero que esto te ayude

Tengo 2 tablas como esta:

> SELECT * FROM table_a;
+------+------+
| id   | name |
+------+------+
|    1 | row1 |
|    2 | row2 |
+------+------+

> SELECT * FROM table_b;
+------+------+------+
| id   | name | aid  |
+------+------+------+
|    3 | row3 |    1 |
|    4 | row4 |    1 |
|    5 | row5 | NULL |
+------+------+------+

INNER JOIN se preocupa por ambas tablas

INNER JOIN se preocupa por ambas tablas, por lo que solo obtendrá una fila si ambas tablas tienen una. Si hay más de un par coincidente, obtendrá varias filas.

> SELECT * FROM table_a a INNER JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | id   | name | aid  |
+------+------+------+------+------+
|    1 | row1 |    3 | row3 | 1    |
|    1 | row1 |    4 | row4 | 1    |
+------+------+------+------+------+

INNER JOIN no hace ninguna diferencia si invierte el orden, porque se preocupa por ambas tablas:

> SELECT * FROM table_b b INNER JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | aid  | id   | name |
+------+------+------+------+------+
|    3 | row3 | 1    |    1 | row1 |
|    4 | row4 | 1    |    1 | row1 |
+------+------+------+------+------+

Obtiene las mismas filas, pero las columnas están en un orden diferente porque mencionamos las tablas en un orden diferente.

IZQUIERDA UNIRSE solo se preocupa por la primera mesa

LEFT JOIN se preocupa por la primera tabla que le da, y no le importa mucho la segunda, por lo que siempre obtiene las filas de la primera tabla, incluso si no hay una fila correspondiente en la segunda:

> SELECT * FROM table_a a LEFT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | id   | name | aid  |
+------+------+------+------+------+
|    1 | row1 |    3 | row3 | 1    |
|    1 | row1 |    4 | row4 | 1    |
|    2 | row2 | NULL | NULL | NULL |
+------+------+------+------+------+

Arriba puede ver todas las filas de la tabla_a a pesar de que algunas de ellas no coinciden con nada en la tabla b, pero no todas las filas de la tabla_b, solo las que coinciden con algo en la tabla_a.

Si invertimos el orden de las tablas, LEFT JOIN se comporta de manera diferente:

> SELECT * FROM table_b b LEFT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | aid  | id   | name |
+------+------+------+------+------+
|    3 | row3 | 1    |    1 | row1 |
|    4 | row4 | 1    |    1 | row1 |
|    5 | row5 | NULL | NULL | NULL |
+------+------+------+------+------+

Ahora obtenemos todas las filas de table_b, pero solo las filas coincidentes de table_a.

A DERECHA ÚNICA solo le importa la segunda mesa

a RIGHT JOIN bte da exactamente las mismas filas que b LEFT JOIN a. La única diferencia es el orden predeterminado de las columnas.

> SELECT * FROM table_a a RIGHT JOIN table_b b ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | id   | name | aid  |
+------+------+------+------+------+
|    1 | row1 |    3 | row3 | 1    |
|    1 | row1 |    4 | row4 | 1    |
| NULL | NULL |    5 | row5 | NULL |
+------+------+------+------+------+

Estas son las mismas filas table_b LEFT JOIN table_aque las que vimos en la sección LEFT JOIN.

Similar:

> SELECT * FROM table_b b RIGHT JOIN table_a a ON a.id=b.aid;
+------+------+------+------+------+
| id   | name | aid  | id   | name |
+------+------+------+------+------+
|    3 | row3 | 1    |    1 | row1 |
|    4 | row4 | 1    |    1 | row1 |
| NULL | NULL | NULL |    2 | row2 |
+------+------+------+------+------+

Es las mismas filas que table_a LEFT JOIN table_b.

No unirse en absoluto te da copias de todo

Cláusula No Join: si escribe sus tablas sin ninguna cláusula JOIN, solo separadas por comas, obtendrá cada fila de la primera tabla escrita junto a cada fila de la segunda tabla, en todas las combinaciones posibles:

> SELECT * FROM table_b, table_a;        
+------+------+------+------+------+
| id   | name | aid  | id   | name |
+------+------+------+------+------+
|    3 | row3 | 1    |    1 | row1 |
|    3 | row3 | 1    |    2 | row2 |
|    4 | row4 | 1    |    1 | row1 |
|    4 | row4 | 1    |    2 | row2 |
|    5 | row5 | NULL |    1 | row1 |
|    5 | row5 | NULL |    2 | row2 |
+------+------+------+------+------+

(Esto es de mi publicación de blog Ejemplos de tipos de unión SQL )

La unión externa completa no existe en mysql, es posible que deba usar una combinación de unión izquierda y derecha.