A palavra-chave exists pode ser usada dessa forma, mas na verdade é uma forma de evitar a contagem:

--this statement needs to check the entire table
select count(*) from [table] where ...

--this statement is true as soon as one match is found
exists ( select * from [table] where ... )

Isto é mais útil quando você tem if declarações condicionais, pois exists pode ser muito mais rápido do que count.

O in é melhor utilizado quando se tem uma lista estática para passar:

 select * from [table]
 where [field] in (1, 2, 3)

Quando se tem uma mesa numa declaração in faz mais sentido usar um join, mas principalmente não deve importar. O otimizador da consulta deve devolver o mesmo plano seja como for. Em algumas implementações (principalmente antigas, como o Microsoft SQL Server 2000) in as consultas irão sempre obter um aninhado join}, enquanto que join as consultas irão usar o aninhado, merge ou hash} conforme apropriado. Implementações mais modernas são mais inteligentes e podem ajustar o plano mesmo quando in é usado.

EXISTS dir-lhe-á se uma consulta devolveu algum resultado. por exemplo:

SELECT * 
FROM Orders o 
WHERE EXISTS (
    SELECT * 
    FROM Products p 
    WHERE p.ProductNumber = o.ProductNumber)

IN é usado para comparar um valor com vários, e pode usar valores literais, como este:

SELECT * 
FROM Orders 
WHERE ProductNumber IN (1, 10, 100)

Você também pode usar os resultados da consulta com a cláusula IN, Assim:

SELECT * 
FROM Orders 
WHERE ProductNumber IN (
    SELECT ProductNumber 
    FROM Products 
    WHERE ProductInventoryQuantity > 0)

Baseado no Optimizador de regras:

• EXISTS é muito mais rápido do que IN, quando os resultados da sub-consulta são muito grandes.
• IN é mais rápido do que EXISTS, quando os resultados da sub-consulta são muito pequenos.

Baseado em optimização de custos:

• não há diferença.

Estou assumindo que você sabe o que eles fazem, e assim são usados de forma diferente, então eu vou entender a sua pergunta como: quando seria uma boa idéia reescrever o SQL para usar em vez de existir, ou vice-versa.

Edit : a razão pela qual estou a pedir é que, em muitos casos, você pode reescrever um SQL baseado em para usar um existe em vez, e vice-versa, e para alguns motores de banco de dados, o otimizador de consulta irá tratar os dois diferentemente.

Por exemplo:

SELECT *
FROM Customers
WHERE EXISTS (
    SELECT *
    FROM Orders
    WHERE Orders.CustomerID = Customers.ID
)

Pode ser reescrito para:

SELECT *
FROM Customers
WHERE ID IN (
    SELECT CustomerID
    FROM Orders
)

Ou com uma junção:

SELECT Customers.*
FROM Customers
    INNER JOIN Orders ON Customers.ID = Orders.CustomerID

Então a minha pergunta ainda está de pé, é o cartaz original perguntando sobre o que dentro e existe faz, e assim como usá-lo, ou ele pergunta se reescrever um SQL usando para usar existe em vez disso, ou vice-versa, será uma boa ideia?

1. EXISTS é muito mais rápido do que IN Quando o resultado do subquery é muito grande.
   IN é mais rápido do que EXISTS quando o resultado do subquery é muito pequeno.

   CREATE TABLE t1 (id INT, title VARCHAR(20), someIntCol INT)
   GO
   CREATE TABLE t2 (id INT, t1Id INT, someData VARCHAR(20))
   GO
   
   INSERT INTO t1
   SELECT 1, 'title 1', 5 UNION ALL
   SELECT 2, 'title 2', 5 UNION ALL
   SELECT 3, 'title 3', 5 UNION ALL
   SELECT 4, 'title 4', 5 UNION ALL
   SELECT null, 'title 5', 5 UNION ALL
   SELECT null, 'title 6', 5
   
   INSERT INTO t2
   SELECT 1, 1, 'data 1' UNION ALL
   SELECT 2, 1, 'data 2' UNION ALL
   SELECT 3, 2, 'data 3' UNION ALL
   SELECT 4, 3, 'data 4' UNION ALL
   SELECT 5, 3, 'data 5' UNION ALL
   SELECT 6, 3, 'data 6' UNION ALL
   SELECT 7, 4, 'data 7' UNION ALL
   SELECT 8, null, 'data 8' UNION ALL
   SELECT 9, 6, 'data 9' UNION ALL
   SELECT 10, 6, 'data 10' UNION ALL
   SELECT 11, 8, 'data 11'
   

2. Pesquisa 1

   SELECT
   FROM    t1 
   WHERE   not  EXISTS (SELECT * FROM t2 WHERE t1.id = t2.t1id)
   

   Pesquisa 2

   SELECT t1.* 
   FROM   t1 
   WHERE  t1.id not in (SELECT  t2.t1id FROM t2 )
   

   Se em t1 o seu id tiver valor nulo, então a consulta 1 irá encontrá-los, mas a consulta 2 não consegue encontrar parâmetros nulos.

   Quero dizer IN não pode comparar nada com nulo, por isso não tem resultado para nulo, mas EXISTS pode compare tudo com nulo.

Se estiver a usar o operador IN, o motor de SQL irá analisar todos os registos obtidos a partir da pesquisa interna. Por outro lado, se estamos usando EXISTS, o motor SQL vai parar o processo de digitalização assim que encontrar uma correspondência.

A palavra-chave Exists avalia o verdadeiro ou o falso, mas IN a palavra-chave compara todos os valores na coluna correspondente da sub-consulta. Outro Select 1 pode ser usado com o comando Exists. Exemplo:

SELECT * FROM Temp1 where exists(select 1 from Temp2 where conditions...)

Mas IN é menos eficiente por isso Exists mais rápido.

Em apóia apenas as relações de igualdade(ou desigualdade quando precedida por NÃO ).
É um sinônimo de = Qualquer / =Alguns , por exemplo

select    * 
from      t1 
where     x in (select x from t2)
;

Existe suporta tipos variantes de relações, que não podem ser expressas usando em , por exemplo -

select    * 
from      t1 
where     exists (select    null 
                  from      t2 
                  where     t2.x=t1.x 
                        and t2.y>t1.y 
                        and t2.z like '℅' || t1.z || '℅'
                  )
;

E numa nota diferente -

As alegadas diferenças de desempenho e técnicas entre existem e em podem resultar de vendas específicas. implementações / limitações / bugs, mas muitas vezes eles não passam de mitos criados devido à falta de compreensão das bases de dados internas.

A definição das tabelas, a precisão das estatísticas, a configuração da base de dados e a versão do optimizer têm todo o impacto no plano de execução e, por conseguinte, nas métricas de desempenho.

• EXISTS é quando você precisa combinar os resultados da consulta com outro subquery. Os resultados da consulta#1 precisam ser recuperados onde os resultados de SubQuery coincidem. Uma espécie de Adesão.. Por exemplo, seleccione a tabela de clientes#1 que também colocou a tabela de encomendas#2

• IN is to retrieve if the value of a specific column lies IN a list (1,2,3,4,5) Por exemplo, selecione clientes que se encontram nos seguintes zipcodes, ou seja, os valores de zip_code estão em (....) lista.

Quando use um sobre o outro... quando você sente que lê apropriadamente (comunica intenção melhor).

A diferença está aqui:

select * 
from abcTable
where exists (select null)

A consulta acima irá devolver todos os registos enquanto por baixo um retornaria vazio.

select *
from abcTable
where abcTable_ID in (select null)

De acordo com o meu conhecimento, quando um subquery devolve um valor NULL, então toda a declaração torna-se NULL. Nesse caso, estamos usando a palavra-chave EXITS. Se queremos comparar valores particulares em subqueries, então estamos usando a palavra-chave IN.

Qual é mais rápido depende do número de consultas obtidas pela consulta interna:

• Quando a tua consulta interior a obter milhares de linhas então existiria seria melhor escolha
• Quando a sua pesquisa interna obter algumas linhas, então para dentro será mais rápido

Existe avaliar em verdadeiro ou falso, mas em COMPARAR valor múltiplo. Quando você não sabe que o registro existe ou não, você deve escolher EXIST

A razão é que o operador existe trabalha com base no princípio "pelo menos encontrado". Retorna true e pára de digitalizar a tabela uma vez que pelo menos uma linha correspondente encontrada.

Por outro lado, quando o operador IN é combinado com um subquery, MySQL deve processar o subquery primeiro, e então usa o resultado do subquery para processar toda a consulta.

A regra geral é que se a subquadia contiver um grande volume de dados, o operador existe fornece melhor.

No entanto, a consulta que usa o operador IN irá executar mais rápido se o conjunto de resultados retornados do subquery é muito pequeno.

A mesma razão pela qual a consulta não devolve o valor para = null vs É nula. http://sqlinthewild.co.za/index.php/2010/02/18/not-exists-vs-not-in/

Quanto ao argumento booleano vs comparador, para gerar um booleano ambos os valores precisam ser comparados e é assim que qualquer condição if works.So eu não entendo como dentro e existe comportar-se de forma diferente .

Se a subconsulta não retorna mais de um valor, você pode precisar para executar a consulta externa - se os valores em uma coluna especificada na condição de correspondência de qualquer valor do conjunto de resultado da subconsulta. Para executar esta tarefa, você precisa usar a palavra-chave in.

Pode usar um subcontingente para verificar se existe um conjunto de registos. Para isso, você precisa usar a cláusula exists com um subcontingente. A palavra-chave exists devolve sempre o valor verdadeiro ou falso.

Se você é um desenvolvedor de MS SQL, aqui está a resposta diretamente da Microsoft.

IN:

Determina se um valor indicado corresponde a qualquer valor numa sub-pesquisa ou numa lista.

EXISTS:

Especifica uma subconta para testar a existência de linhas.

Eu descobri que usar a palavra-chave existe é muitas vezes muito lento (isso é muito verdadeiro no Microsoft Access). Em vez disso, Uso o operador de junção desta forma : should-I-use-the-keyword-exists-in-sql

In certain circumstances, it is better to use IN rather than EXISTS. In general, if the selective predicate is in the subquery, then use IN. If the selective predicate is in the parent query, then use EXISTS.

Https://docs.oracle.com/cd/B19306_01/server.102/b14211/sql_1016.htm#i28403

Existe é mais rápido no desempenho do que no. Se a maioria dos critérios do filtro está em subquery então melhor usar em e se a maioria dos critérios do filtro está na consulta principal então melhor usar existe.

Se estiver a usar o operador IN, o motor SQL irá analisar todos os registos obtidos a partir da consulta interna. Por outro lado, se estamos usando existe, o motor SQL vai parar o processo de digitalização assim que ele encontrou uma correspondência.