Não existe

Também esteja ciente de que não IN não é equivalente a não existir quando se trata de null.

Este post explica muito bem

Http://sqlinthewild.co.za/index.php/2010/02/18/not-exists-vs-not-in/

Quando a sub-pesquisa voltar, mesmo que seja um nulo, não irá corresponder a nenhum linhas.

A razão para isso pode ser encontrada olhando para os detalhes do que o Na verdade, não está em operação.

Digamos, para ilustrar que há 4 linhas na tabela chamada t, há uma coluna chamada ID com valores 1..4

WHERE SomeValue NOT IN (SELECT AVal FROM t)

É equivalente a

WHERE SomeValue != (SELECT AVal FROM t WHERE ID=1)
AND SomeValue != (SELECT AVal FROM t WHERE ID=2)
AND SomeValue != (SELECT AVal FROM t WHERE ID=3)
AND SomeValue != (SELECT AVal FROM t WHERE ID=4)

Vamos dizer Ainda que Avalal é nula onde ID = 4. Daí isso != a comparação retorna desconhecida. A tabela lógica da verdade para e Estados esse desconhecido e verdadeiro é Desconhecido, desconhecido e falso é falso. Há nenhum valor que possa ser e seja desconhecido para produzir o resultado verdadeiro

Por isso, se alguma linha desse subcontingente retornar nula, o inteiro não em o operador irá avaliar para falso ou nulo e nenhum registro será devolvidos

SELECT ProductID, ProductName 
    FROM Northwind..Products p  
          outer join Northwind..[Order Details] od on p.ProductId = od.ProductId)
WHERE od.ProductId is null

Eu tenho uma tabela que tem cerca de 120 mil registros e precisa selecionar apenas aqueles que não existem (correspondido com uma coluna varchar) em quatro outras tabelas com o número de linhas aprox 1500, 4000, 40000, 200. Todos os quadros envolvidos têm um índice único na coluna em causa Varchar.

NOT IN demorou cerca de 10 minutos, demorou 4 segundos.

Tenho uma pergunta recursiva que pode ter alguma secção não lançada que pode ter contribuído para os 10 minutos, mas a outra opção a tomar 4 segundos explica-me, pelo menos para mim que NOT EXISTS é muito melhor ou pelo menos que IN e EXISTS não são exactamente os mesmos e sempre vale a pena verificar antes de avançar com o código.

No seu exemplo específico são os mesmos, porque o Optimizador descobriu que o que está a tentar fazer é o mesmo em ambos os exemplos. Mas é possível que em exemplos não-triviais o otimizador pode não fazer isso, e nesse caso há razões para preferir um a outro na ocasião.

NOT IN deverá ser preferido se estiver a testar várias linhas no seu selecto exterior. O subquery dentro da declaração {[[0]} pode ser avaliado no início da execução, e o a tabela temporária pode ser assinalada com cada valor na opção externa, em vez de executar de novo a sub-selecção de cada vez, como seria necessário com a instrução NOT EXISTS.

Se o subconjunto deve estar correlacionado com a selecção exterior, então NOT EXISTS pode ser preferível, uma vez que o Optimizador pode descobrir uma simplificação que impede a criação de quaisquer tabelas temporárias para desempenhar a mesma função.

Eu estava a usar

SELECT * from TABLE1 WHERE Col1 NOT IN (SELECT Col1 FROM TABLE2)

E descobriu que estava a dar resultados errados (por errado quero dizer sem resultados). Como havia um NULL no quadro 2.Col1.

Ao mudar a pesquisa para

SELECT * from TABLE1 T1 WHERE NOT EXISTS (SELECT Col1 FROM TABLE2 T2 WHERE T1.Col1 = T2.Col2)

Deu-me os resultados correctos.

Desde então eu comecei a usar não existe em todos os lugares.

Em termos de eficiência, eu descobri que a junção à esquerda é nula mais eficiente (quando uma abundância de linhas são para ser selecionadas que é)

SELECT x.col
FROM big_table x
WHERE x.key IN( SELECT key FROM really_big_table );

Não seria relativamente lento o isn't much to limit size of what the query check to see if they key is in. Seria preferível neste caso.

Como um exemplo de quando existe é melhor

SELECT x.col
FROM big_table x
WHERE EXISTS( SELECT key FROM really_big_table WHERE key = x.key);
  AND id = very_limiting_criteria