valores - where con varias condiciones mysql

Unión SQL: cláusula where vs. cláusula on

Question

Después de leerlo, este no es un duplicado de uniones explícitas vs implícitas de SQL . La respuesta puede estar relacionada (o incluso la misma) pero la pregunta es diferente.

¿Cuál es la diferencia y qué debe ir en cada uno?

Si entiendo la teoría correctamente, el optimizador de consultas debería poder usar ambos de manera intercambiable.

Answer 1

Creo que es el efecto de secuencia de unión. En el caso de la combinación superior izquierda, SQL se une primero a la izquierda y luego realiza el filtro donde. En el caso de downer, encuentre Orders.ID = 12345 primero, y luego únase.

Answer 2

En INNER JOIN s son intercambiables, y el optimizador los reorganizará a voluntad.

En OUTER JOIN s, no son necesariamente intercambiables, dependiendo de qué lado de la unión dependen.

Los puse en cualquier lugar dependiendo de la legibilidad.

Answer 3

En SQL, las cláusulas "WHERE" y "ON", son una especie de declaraciones condicionales, pero la principal diferencia entre ellas es que se usa la cláusula "Where" en las declaraciones de selección / actualización para especificar las condiciones, mientras que la cláusula "ON" se usa en uniones, donde verifica o verifica si los registros coinciden en las tablas de destino y origen, antes de que se unan las tablas

Por ejemplo: - ''DONDE''

SELECCIONAR * DEL empleado WHERE employee_id = 101

Por ejemplo: - ''ON''

* Hay dos tablas employee y employee_details, las columnas coincidentes son employee_id. *

SELECCIONAR * DEL empleado UNIRSE INTERNA employee_details ON employee.employee_id = employee_details.employee_id

Espero haber respondido a tu pregunta. Revertir de nuevo para aclaraciones.

Answer 4

En términos del optimizador, no debería hacer una diferencia si define sus cláusulas de unión con ON o DONDE.

Sin embargo, en mi humilde opinión, creo que es mucho más claro usar la cláusula ON cuando se realizan combinaciones. De esa manera, tiene una sección específica de su consulta que dicta cómo se maneja la unión en lugar de entremezclarse con el resto de las cláusulas WHERE.

Answer 5

En una unión interna, significan lo mismo. Sin embargo, obtendrá resultados diferentes en una combinación externa dependiendo de si coloca la condición de unión en la cláusula WHERE vs ON. Echa un vistazo a esta pregunta relacionada y esta respuesta (por mí).

Creo que tiene más sentido tener la costumbre de poner siempre la condición de unión en la cláusula ON (a menos que sea una combinación externa y realmente lo desee en la cláusula where), ya que hace que sea más claro para cualquiera que lea su consulta. en qué condiciones se unen las tablas, y también ayuda a evitar que la cláusula WHERE tenga docenas de líneas de longitud.

Answer 6

Hay una gran diferencia entre la cláusula where y la cláusula on , cuando se trata de unir a la izquierda.

Aquí está el ejemplo:

mysql> desc t1;
+-------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int(11) | NO | | NULL | |
| fid | int(11) | NO | | NULL | |
| v | varchar(20) | NO | | NULL | |
+-------+-------------+------+-----+---------+-------+

Allí está el id de la tabla t2.

mysql> desc t2;
+-------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id | int(11) | NO | | NULL | |
| v | varchar(10) | NO | | NULL | |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Consulta sobre "en cláusula":

mysql> SELECT * FROM `t1` left join t2 on fid = t2.id AND t1.v = ''K''
-> ;
+----+-----+---+------+------+
| id | fid | v | id | v |
+----+-----+---+------+------+
| 1 | 1 | H | NULL | NULL |
| 2 | 1 | B | NULL | NULL |
| 3 | 2 | H | NULL | NULL |
| 4 | 7 | K | NULL | NULL |
| 5 | 5 | L | NULL | NULL |
+----+-----+---+------+------+
5 rows in set (0.00 sec)

Consulta sobre "cláusula where":

mysql> SELECT * FROM `t1` left join t2 on fid = t2.id where t1.v = ''K'';
+----+-----+---+------+------+
| id | fid | v | id | v |
+----+-----+---+------+------+
| 4 | 7 | K | NULL | NULL |
+----+-----+---+------+------+
1 row in set (0.00 sec)

Está claro que, la primera consulta devuelve un registro de t1 y su fila dependiente de t2, si existe, para la fila t1.v = ''K''.

La segunda consulta devuelve filas de t1, pero solo para t1.v = ''K'' tendrá cualquier fila asociada con ella.

Answer 7

La forma en que lo hago es:

Ponga siempre las condiciones de unión en la cláusula on Si está haciendo una unión interna, no agregue ninguna condición where a la cláusula on, póngala en la cláusula where

Si está haciendo una combinación a la izquierda, agregue cualquiera de las condiciones a la cláusula on para la tabla en el lado derecho de la unión. Esto es obligatorio porque al agregar una cláusula where que hace referencia al lado derecho de la unión, la unión se convertirá en una unión interna (con una excepción que se describe a continuación).

La excepción es que cuando busca los registros que no están en una tabla en particular, agregaría la referencia a un identificador único (que nunca es nulo) en la tabla de combinación correcta a la cláusula where de esta manera "Donde t2. idfield es nulo ". Por lo tanto, la única vez que debería hacer referencia a una tabla en el lado derecho de la unión es encontrar aquellos registros que no están en la tabla.

Answer 8

No són la misma cosa.

Considere estas consultas:

SELECT *
FROM Orders
LEFT JOIN OrderLines ON OrderLines.OrderID=Orders.ID
WHERE Orders.ID = 12345

y

SELECT *
FROM Orders
LEFT JOIN OrderLines ON OrderLines.OrderID=Orders.ID
AND Orders.ID = 12345

El primero devolverá un pedido y sus líneas, si las hubiera, para el número de pedido 12345 . El segundo devolverá todos los pedidos, pero solo el orden 12345 tendrá líneas asociadas.

Con un INNER JOIN , las cláusulas son efectivamente equivalentes. Sin embargo, solo porque son funcionalmente iguales, ya que producen los mismos resultados, no significa que los dos tipos de cláusulas tengan el mismo significado semántico.

Answer 9

Normalmente, el filtrado se procesa en la cláusula WHERE una vez que las dos tablas ya se han unido. Sin embargo, es posible que desee filtrar una o las dos tablas antes de unirlas. es decir, la cláusula where se aplica a todo el conjunto de resultados, mientras que la cláusula on solo se aplica a la unión en cuestión.

Answer 10

Para una unión interna, WHERE y ON pueden usarse indistintamente. De hecho, es posible utilizar ON en una subconsulta correlacionada. Por ejemplo:

update mytable
set myscore=100
where exists (
select 1 from table1
inner join table2
on (table2.key = mytable.key)
inner join table3
on (table3.key = table2.key and table3.key = table1.key)
...
)

Esto es (IMHO) completamente confuso para un humano, y es muy fácil olvidarse de vincular table1 a cualquier cosa (porque la tabla "driver" no tiene una cláusula "on"), pero es legal.

Answer 11

esta es mi solucion

SELECT song_ID,songs.fullname, singers.fullname
FROM music JOIN songs ON songs.ID = music.song_ID
JOIN singers ON singers.ID = music.singer_ID
GROUP BY songs.fullname

Usted debe tener el GROUP BY para que funcione.

Espero que esto ayude.

Answer 12

para obtener un mejor rendimiento, las tablas deben tener una columna indexada especial para usar para unir.

así que si la columna en la que condicionas no es una de esas columnas indexadas, entonces sospecho que es mejor mantenerla en DÓNDE.

de modo que SE UNE utilizando las columnas indexadas, luego, después de UNIR, ejecute la condición en la columna ninguna indexada.

Answer 13

Este artículo explica claramente la diferencia. También explica el "ON joined_condition vs WHERE joined_condition o joined_alias es nulo".

La cláusula WHERE filtra tanto el lado izquierdo como el derecho de la combinación, mientras que la cláusula ON siempre filtrará el lado derecho solamente.

1. Si siempre desea obtener las filas del lado izquierdo y solo UNIRSE si alguna condición coincide, entonces debería usar la cláusula ON.
2. Si desea filtrar el producto de unir ambos lados, debe utilizar la cláusula WHERE.

Answer 14

• No importa para uniones internas.

• Materias para uniones externas

  a. Cláusula WHERE : Después de unirse. Los registros se filtrarán después de que la unión haya tenido lugar.

  segundo. Cláusula ON - Antes de unirse. Los registros (de la tabla derecha) se filtrarán antes de unirse. Esto puede terminar como nulo en el resultado (ya que OUTER se une).

Ejemplo : Considere las siguientes tablas:

 1. documents:
| id | name |
--------|-------------|
| 1 | Document1 |
| 2 | Document2 |
| 3 | Document3 |
| 4 | Document4 |
| 5 | Document5 |
2. downloads:
| id | document_id | username |
|------|---------------|----------|
| 1 | 1 | sandeep |
| 2 | 1 | simi |
| 3 | 2 | sandeep |
| 4 | 2 | reya |
| 5 | 3 | simi |

a) Dentro de la cláusula WHERE :

 SELECT documents.name, downloads.id
FROM documents
LEFT OUTER JOIN downloads
ON documents.id = downloads.document_id
WHERE username = ''sandeep''
For above query the intermediate join table will look like this.
| id(from documents) | name | id (from downloads) | document_id | username |
|--------------------|--------------|---------------------|-------------|----------|
| 1 | Document1 | 1 | 1 | sandeep |
| 1 | Document1 | 2 | 1 | simi |
| 2 | Document2 | 3 | 2 | sandeep |
| 2 | Document2 | 4 | 2 | reya |
| 3 | Document3 | 5 | 3 | simi |
| 4 | Document4 | NULL | NULL | NULL |
| 5 | Document5 | NULL | NULL | NULL |
After applying the `WHERE` clause and selecting the listed attributes, the result will be:
| name | id |
|--------------|----|
| Document1 | 1 |
| Document2 | 3 |

b) Cláusula JOIN interior

 SELECT documents.name, downloads.id
FROM documents
LEFT OUTER JOIN downloads
ON documents.id = downloads.document_id
AND username = ''sandeep''
For above query the intermediate join table will look like this.
| id(from documents) | name | id (from downloads) | document_id | username |
|--------------------|--------------|---------------------|-------------|----------|
| 1 | Document1 | 1 | 1 | sandeep |
| 2 | Document2 | 3 | 2 | sandeep |
| 3 | Document3 | NULL | NULL | NULL |
| 4 | Document4 | NULL | NULL | NULL |
| 5 | Document5 | NULL | NULL | NULL |
Notice how the rows in `documents` that did not match both the conditions are populated with `NULL` values.
After Selecting the listed attributes, the result will be:
| name | id |
|------------|------|
| Document1 | 1 |
| Document2 | 3 |
| Document3 | NULL |
| Document4 | NULL |
| Document5 | NULL |