tabelas - right join left join sql




Junção SQL: where cláusula vs. cláusula on (10)

A maneira que eu faço é:

  • Sempre coloque as condições de junção na cláusula ON se você estiver fazendo um INNER JOIN . Portanto, não adicione nenhuma condição WHERE à cláusula ON, coloque-as na cláusula WHERE .

  • Se você estiver fazendo um LEFT JOIN , adicione quaisquer condições WHERE à cláusula ON para a tabela no lado direito da junção. Isso é obrigatório, porque adicionar uma cláusula WHERE que faça referência ao lado direito da junção converterá a junção em um INNER JOIN.

    A exceção é quando você está procurando os registros que não estão em uma tabela específica. Você adicionaria a referência a um identificador exclusivo (que nunca é NULL) na tabela RIGHT JOIN à cláusula WHERE desta forma: WHERE t2.idfield IS NULL . Portanto, a única vez que você deve referenciar uma tabela no lado direito da junção é encontrar os registros que não estão na tabela.

Depois de lê-lo, isso não é uma duplicata de junções SQL explícitas vs implícitas . A resposta pode estar relacionada (ou até a mesma), mas a questão é diferente.

Qual é a diferença e o que deve acontecer em cada um?

Se eu entendi a teoria corretamente, o otimizador de consulta deve ser capaz de usar os dois intercambiáveis.


Eles não são a mesma coisa.

Considere estas consultas:

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

e

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

O primeiro retornará um pedido e suas linhas, se houver, para o número de pedido 12345 . O segundo retornará todos os pedidos, mas apenas o 12345 terá linhas associadas a ele.

Com um INNER JOIN , as cláusulas são efetivamente equivalentes. No entanto, apenas porque são funcionalmente iguais, na medida em que produzem os mesmos resultados, não significa que os dois tipos de cláusulas tenham o mesmo significado semântico.


Em uma junção interna, eles significam a mesma coisa. No entanto, você obterá resultados diferentes em uma junção externa, dependendo se você colocar a condição de junção na cláusula WHERE vs ON. Dê uma olhada nesta questão relacionada e nesta resposta (por mim).

Eu acho que faz mais sentido ter o hábito de sempre colocar a condição de junção na cláusula ON (a menos que seja uma junção externa e você realmente a queira na cláusula where), pois ela fica mais clara para qualquer um que esteja lendo sua consulta. em que condições as tabelas estão sendo unidas, e também ajuda a evitar que a cláusula WHERE tenha dezenas de linhas.


Eu acho que é o efeito de seqüência de junção. No caso de junção superior esquerdo, SQL do Left associa primeiro e depois faz o filtro where. No caso negativo, localize Orders.ID = 12345 primeiro e, em seguida, junte-se.


No INNER JOIN s eles são intercambiáveis, eo otimizador irá reorganizá-los à vontade.

Em OUTER JOIN s, eles não são necessariamente intercambiáveis, dependendo de qual lado da junção eles dependem.

Eu os coloco em qualquer lugar, dependendo da legibilidade.


No SQL, a cláusula 'WHERE' e 'ON', são do tipo Statemalts condicionais, mas a principal diferença entre eles é que a cláusula 'Where' é usada em Select / Update Statements para especificar as condições, enquanto a cláusula 'ON' é usado em Joins, onde verifica ou verifica se os registros são correspondidos nas tabelas de destino e de origem, antes de as tabelas serem ingressadas

Por exemplo: - 'WHERE'

SELECT * FROM empregado WHERE employee_id = 101

Por exemplo: - 'ON'

* Existem duas tabelas employee e employee_details, as colunas correspondentes são employee_id. *

SELECT * FROM empregado INNER JOIN employee_details ON employee.employee_id = employee_details.employee_id

Espero ter respondido sua pergunta. Voltar para esclarecimentos.


Para uma junção interna, WHERE e ON podem ser usados ​​de forma intercambiável. Na verdade, é possível usar ON em uma subconsulta correlacionada. Por exemplo:

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

Isto é (IMHO) completamente confuso para um ser humano, e é muito fácil esquecer ligar a tabela table1 a qualquer coisa (porque a tabela "driver" não tem uma cláusula "on"), mas é legal.


esta é minha solução.

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

Você deve ter o GROUP BY para fazê-lo funcionar.

Espero que esta ajuda.


Este artigo explica claramente a diferença. Também explica o "ON joined_condition vs WHERE joined_condition ou joined_alias é nulo".

A cláusula WHERE filtra os lados esquerdo e direito do JOIN, enquanto a cláusula ON sempre filtrará apenas o lado direito.

  1. Se você sempre quiser buscar as linhas do lado esquerdo e somente JOIN se alguma condição for compatível, então você deve usar a cláusula ON.
  2. Se você quiser filtrar o produto de unir os dois lados, use a cláusula WHERE.

  • Não importa para junções internas
  • Assuntos para junções externas

    uma. Cláusula WHERE : depois de entrar. Os registros serão filtrados após a união ter ocorrido.

    b. Cláusula ON - Antes de entrar. Registros (da tabela da direita) serão filtrados antes da adesão. Isso pode acabar como nulo no resultado (desde a associação OUTER).



Exemplo : considere as tabelas abaixo:

    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 da 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 Inside JOIN

  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 | 




on-clause