tipos teoria resueltos permutaciones historia ejercicios combinatorio combinatoria combinaciones analisis mysql join

mysql - resueltos - teoria de permutaciones



MySQL: desglose rápido de los tipos de combinaciones (4)

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

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

FIN EDITAR

En pocas palabras, el ejemplo separado por comas que di

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 se puede usar también en columnas como

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

A continuación, 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 ayb, 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 sea igual a a.beeId. Tenga en cuenta que hay una cláusula AND también, esto ayudará a refinar sus resultados.

Para obtener algunos tutoriales simples y explicaciones sobre uniones mySQL y uniones 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 uniones que también es bastante buena.

Espero que esto te ayude

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

  • separados por comas (¿para qué sirve 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 combinaciones, pero quiero saber qué las hace diferentes, qué es INNER / OUTER , si agrega la LEFT cambiar cosas.

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

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

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ás una fila si ambas tablas tienen una. Si hay más de un par coincidente, obtendrá múltiples 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 | +------+------+------+------+------+

No hace ninguna diferencia a INNER JOIN 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.

LEFT JOIN solo se preocupa por la primera mesa

LEFT JOIN se preocupa por la primera tabla que le das, y no le importa mucho la segunda, por lo que siempre obtienes 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 table_a aunque algunas de ellas no coincidan con nada en la tabla b, pero no en todas las filas de table_b, solo aquellas que coinciden con algo en table_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 correspondientes de table_a.

RIGHT JOIN solo se preocupa por la segunda mesa

a RIGHT JOIN b te 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 que table_b LEFT JOIN table_a , 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 | +------+------+------+------+------+

Son las mismas filas que table_a LEFT JOIN table_b .

No unirse a nada te da copias de todo

Si escribe sus tablas sin ninguna cláusula JOIN, simplemente separadas por comas, obtendrá cada fila de la primera tabla escrita al lado de cada fila de la segunda tabla, en cada combinación posible:

> SELECT * FROM table_b 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 blog post Ejemplos de tipos de combinación de SQL )