Questão 1131625

• Banca: CS-UFG
• Órgão: UEAP
• Ano: 2014
• Provas: CS-UFG - 2014 - UEAP - Analista de Tecnologia da Informação - Banco de Dados
• Disciplina: Banco de Dados
• Assuntos: SQL

Duas consultas, C1 e C2, foram escritas em SQL das seguintes formas:

C1) SELECT Nome FROM X WHERE Chave IN (SELECT Chave FROM Y)

(C2) SELECT Nome FROM X WHERE EXISTS (SELECT Y.Chave FROM Y WHERE X.Chave = Y.Chave)

Suponha que as relações X e Y possuem 200.000 e 100.000 tuplas, respectivamente. Na comparação dos tempos de processamento de ambas as consultas, constata-se que

• A. o processamento de C1 é mais rápido do que o processamento de C2.
• B. o processamento de C2 é mais rápido do que o processamento de C1.
• C. ambas as consultas têm o tempo de processamento idêntico e superior a zero.
• D. ambas as consultas têm o tempo de processamento igual a zero.

Gabarito: A

Comentários

• Algum comentário galera?

  Marquei a B, mas confesso que estou com sérias dúvidas sobre a questão. Primeiramente pelo do uso do EXISTS que geralmente é mais rápido do que IN e sobre o conceito subjeito da questão.

• Bolei. Só alguem criando na prática pra testar!
  

• Fiz o teste no MySQL e o IN foi bem mais rápido, para quem quiser reproduzir o teste:
  
  

  CREATE TABLE `x` (

    `chave` bigint(20) unsigned NOT NULL AUTO_INCREMENT,

    `nome` text,

    UNIQUE KEY `chave` (`chave`)

  );

  CREATE TABLE `y` (

    `chave` bigint(20) unsigned NOT NULL AUTO_INCREMENT,

    `nome` text,

    UNIQUE KEY `chave` (`chave`)

  );

  CREATE DEFINER=`root`@`localhost` PROCEDURE `insereX`(p1 INT)

  BEGIN

     DECLARE x  INT;

     SET x = 1;

     WHILE x  <= p1 DO

                 insert into x(nome) values (uuid());

                 SET x = x + 1;

     END WHILE;

  END

  CREATE DEFINER=`root`@`localhost` PROCEDURE `insereY`(p1 INT)

  BEGIN

     DECLARE x  INT;

     SET x = 1;

     WHILE x  <= p1 DO

                 insert into y(nome) values (uuid());

                 SET x = x + 1;

     END WHILE;

  END

  call insereX(200000);

  call insereY(100000);

  select count(*) from x;

  select count(*) from y;

  Agora execute as Queries.

• Questão um pouco complicada pois a resposta depente muito do contexto, por exemplo, conforme http://www.dba-oracle.com/t_exists_clause_vs_in_clause.htm :

   

  "A cláusula EXISTS é muito mais rápida do que IN quando os resultados da subconsulta são muito grandes. Por outro lado, a cláusula IN é mais rápida do que EXISTE quando os resultados da subconsulta são muito pequenos."

   

  É preciso considerados alguns conceitos da álgebra relacional, bem como, neste caso específico entender bem o funcionamento da cláusula WHERE. Sem entrar muito na questão teórica, observemos o seguinte:

  primeiro ponto: é preciso considerar que nas duas consultas temos sub-consultas (uma na cláusula IN e outra na cláusua EXISTS), isso é algo que geralmente compromete o desempenho de qualquer consultar, por isso é sempre preferível a utilização de joins 

  segundo ponto: ambas efetuam comparções em uma coluna indexada (toda chave primária é indexada). se uma consulta utilizasse um campo indexado e outra não, isso poderia interferir (mas não é o caso)

  Apesar do fato de que o autor considerar o volume de dados um fator relevante para a avaliação da performance entre os dois operadores em questão, temos que observar o seguinte, o que torna a segunda consulta menos performática é o fato de que se comparadas as consultas nela acaba ocorrendo uma verificação a mais, pois além do true/false avaliado pelo operador EXISTS há uma verificação na cláusula WHERE da sub-consulta, ao passo que na primeira ocorre somente uma avaliação no operador IN. 

  Para ficar mais fácil de exemplificar:

  na primeira consulta, para cada uma tupla das 200.000 tuplas da tabela X haverá uma verificação se a  chave dessa tupla (da tabela X) se encontra NA tabela resultante da sub-consulta na tabela Y  (100.000 tuplas). 

  Já na segunda consulta,  para cada uma tupla das 200.000 tuplas da tabela X haverá uma verificação se EXISTE alguma tupla resultante de uma segunda verificação (uma segunda cláusula WHERE), onde (e é aqui o desempenho é menor) a sua sub-consulta verifica em cada uma de suas 100.000 tuplas se a chave da tabela X é igual a chave de cada uma das 100.000 tuplas de Y.

  PERCEBAM QUE NA SEGUNDA CONSULTA POR CONTA DA CLÁUSULA WHERE OBRIGATORIAMENTE A COMPARAÇÃO SERÁ FEITA PARA TODAS AS 100.000 TUPLAS DE Y,  AO PASSO QUE NA PRIMEIRA CONSULTA ISSO NÃO OCORRE, POIS O OPERADOR IN NÃO PRECISARÁ PASSAR PELOS 100.000 REGISTROS DE Y PARA ENCONTRAR A CHAVE ELE PROCURA