sql - obtener - Diferencia entre las consultas de filtrado en UNIR y DONDE?

obtener fecha sql server

Question

En SQL, estoy intentando filtrar los resultados en función de una ID y me pregunto si hay alguna diferencia lógica entre

SELECT value
FROM table1
JOIN table2 ON table1.id = table2.id
WHERE table1.id = 1

y

SELECT value
FROM table1
JOIN table2 ON table1.id = table2.id AND table1.id = 1

Para mí, parece que la lógica es diferente, aunque siempre obtendrás el mismo conjunto de resultados, pero me pregunté si habría alguna condición en la que obtendrías dos conjuntos de resultados diferentes (o siempre devolverían exactamente los mismos dos conjuntos de resultados). )

Answer 1

Creo que la respuesta marcada como "correcto" no es correcta. ¿Por qué? Intento explicar:

Tenemos opinion

"Mantenga siempre las condiciones de unión en la cláusula ON. Ponga siempre el filtro en la cláusula where"

Y esto está mal. Si está en una combinación interna, cada vez que coloque los parámetros de filtro en la cláusula ON, no en dónde. ¿Usted pregunta por qué? Intente imaginar una consulta compleja con un total de 10 tablas (si cada tabla tiene 10k registros) se unen, con una cláusula WHERE compleja (por ejemplo, funciones o cálculos utilizados). Si coloca los criterios de filtrado en la cláusula ON, no se produce UNIR entre estas 10 tablas, la cláusula WHERE no se ejecutará en absoluto. En este caso, no está realizando 10000 ^ 10 cálculos en la cláusula WHERE. Esto tiene sentido, no poner los parámetros de filtrado solo en la cláusula WHERE.

Answer 2

La respuesta es NO diferencia, pero:

Siempre preferiré hacer lo siguiente.

• Siempre mantenga las condiciones de ON en la cláusula ON
• Siempre ponga el filtro en la cláusula where

Esto hace que la consulta sea más legible .

Así que voy a utilizar esta consulta:

SELECT value
FROM table1
INNER JOIN table2
ON table1.id = table2.id
WHERE table1.id = 1

Sin embargo, cuando está utilizando OUTER JOIN''S hay una gran diferencia en mantener el filtro en la condición ON y Where .

Procesamiento lógico de consultas

La siguiente lista contiene una forma general de una consulta, junto con los números de paso asignados según el orden en que se procesan lógicamente las diferentes cláusulas.

(5) SELECT (5-2) DISTINCT (5-3) TOP(<top_specification>) (5-1) <select_list>
(1) FROM (1-J) <left_table> <join_type> JOIN <right_table> ON <on_predicate>
| (1-A) <left_table> <apply_type> APPLY <right_table_expression> AS <alias>
| (1-P) <left_table> PIVOT(<pivot_specification>) AS <alias>
| (1-U) <left_table> UNPIVOT(<unpivot_specification>) AS <alias>
(2) WHERE <where_predicate>
(3) GROUP BY <group_by_specification>
(4) HAVING <having_predicate>
(6) ORDER BY <order_by_list>;

Diagrama de flujo de procesamiento de consultas lógicas

• (1) FROM: la fase FROM identifica las tablas de origen de la consulta y procesa los operadores de la tabla. Cada operador de mesa aplica una serie de subfases. Por ejemplo, las fases involucradas en una unión son (1-J1) producto cartesiano, (1-J2) ON Filter, (1-J3) Agregar filas externas. La fase FROM genera la tabla virtual VT1.

• (1-J1) Producto cartesiano: esta fase realiza un producto cartesiano (combinación cruzada) entre las dos tablas involucradas en el operador de la tabla, generando VT1-J1.

• (1-J2) Filtro ON : esta fase filtra las filas de VT1-J1 en función del predicado que aparece en la cláusula ON (<proceso_procedente>). Solo las filas para las cuales el predicado se evalúa como VERDADERO se insertan en VT1-J2.
• (1-J3) Agregar filas externas : si se especifica OUTER JOIN (a diferencia de CROSS JOIN o INNER JOIN), las filas de la tabla o tablas conservadas para las que no se encontró una coincidencia se agregan a las filas de VT1-J2 como externas Filas, generando VT1-J3.
• (2) DÓNDE : esta fase filtra las filas de VT1 según el predicado que aparece en la cláusula WHERE (). Solo las filas para las cuales el predicado se evalúa como VERDADERO se insertan en VT2.
• (3) GROUP BY: esta fase organiza las filas de VT2 en grupos según la lista de columnas especificada en la cláusula GROUP BY, generando VT3. En última instancia, habrá una fila de resultados por grupo.
• (4) HAVING: esta fase filtra los grupos de VT3 según el predicado que aparece en la cláusula HAVING (<having_predicate>). Solo los grupos para los cuales el predicado se evalúa como VERDADERO se insertan en VT4.
• (5) SELECT: esta fase procesa los elementos en la cláusula SELECT, generando VT5.
• (5-1) Evaluar expresiones: esta fase evalúa las expresiones en la lista SELECCIONAR, generando VT5-1.
• (5-2) DISTINTO: Esta fase elimina filas duplicadas de VT5-1, generando VT5-2.
• (5-3) TOP: esta fase filtra el número superior especificado o el porcentaje de filas de VT5-2 según el orden lógico definido por la cláusula ORDER BY, generando la tabla VT5-3.
• (6) ORDER BY: esta fase ordena las filas de VT5-3 según la lista de columnas especificada en la cláusula ORDER BY, generando el cursor VC6.

Se remite desde este excelente enlace .

Answer 3

Si bien no hay diferencias cuando se usa UNIONES INTERIORES , como lo señaló VR46, hay una diferencia significativa cuando se usan JUNTAS EXTERIORES y se evalúa un valor en la segunda tabla (para las combinaciones a la izquierda: primera tabla para las combinaciones a la derecha). Considere la siguiente configuración:

DECLARE @Table1 TABLE ([ID] int)
DECLARE @Table2 TABLE ([Table1ID] int, [Value] varchar(50))
INSERT INTO @Table1
VALUES
(1),
(2),
(3)
INSERT INTO @Table2
VALUES
(1, ''test''),
(1, ''hello''),
(2, ''goodbye'')

Si seleccionamos una combinación externa izquierda y ponemos una condición en la cláusula where:

SELECT * FROM @Table1 T1
LEFT OUTER JOIN @Table2 T2
ON T1.ID = T2.Table1ID
WHERE T2.Table1ID = 1

Obtenemos los siguientes resultados:

ID Table1ID Value
----------- ----------- --------------------------------------------------
1 1 test
1 1 hello

Esto se debe a que la cláusula where limita el conjunto de resultados, por lo que solo estamos incluyendo registros de la tabla 1 que tienen un ID de 1. Sin embargo, si cambiamos la condición a la cláusula on:

SELECT * FROM @Table1 T1
LEFT OUTER JOIN @Table2 T2
ON T1.ID = T2.Table1ID
AND T2.Table1ID = 1

Obtenemos los siguientes resultados:

ID Table1ID Value
----------- ----------- --------------------------------------------------
1 1 test
1 1 hello
2 NULL NULL
3 NULL NULL

Esto se debe a que ya no estamos filtrando el conjunto de resultados por el ID de 1 de la tabla1, sino que estamos filtrando la UNIÓN. Por lo tanto, aunque la ID de 2 de table1 tiene una coincidencia en la segunda tabla, se excluye de la unión, pero NO del conjunto de resultados (de ahí los valores nulos).

Por lo tanto, para las uniones internas no importa, pero debe mantenerlo en la cláusula where para facilitar la lectura y la coherencia. Sin embargo, para las uniones externas, debe tener en cuenta que SÍ importa en qué situación, ya que afectará su conjunto de resultados.