Categorias:: Funções de expressão condicional

[ NOT ] IN¶

Testa se seu argumento é ou não um dos membros de uma lista explícita ou o resultado de uma subconsulta.

Nota

Na forma de subconsulta, IN é equivalente a = ANY e NOT IN é equivalente a <> ALL.

Dica

Você pode usar o serviço de otimização de pesquisa para melhorar o desempenho de consultas que chamam essa função. Para obter mais detalhes, consulte Serviço de otimização de pesquisa.

Sintaxe¶

Para comparar valores individuais:

<value> [ NOT ] IN ( <value_1> [ , <value_2> ...  ] )

Para comparar construtores ROW (listas de valores entre parênteses):

( <value_A> [, <value_B> ... ] ) [ NOT ] IN (  ( <value_1> [ , <value_2> ... ] )  [ , ( <value_3> [ , <value_4> ... ] )  ...  ]  )

Para comparar um valor com os valores retornados por uma subconsulta:

<value> [ NOT ] IN ( <subquery> )

Parâmetros¶

value

O valor a ser pesquisado.

value_A, value_B

Os elementos de um construtor ROW pelos quais procurar.

Certifique-se de que cada valor à direita de IN (por exemplo, (value3, value4)) tenha o mesmo número de elementos que o valor à esquerda de IN (por exemplo, (value_A, value_B)).

value_#

Um valor com o qual value deve ser comparado.

Se os valores a serem comparados são construtores ROW, então cada value_# é um elemento individual de um construtor ROW.

subquery

Uma subconsulta que retorna uma lista de valores aos quais value pode ser comparado.

Notas de uso¶

Como na maioria dos contextos, NULL não é igual a NULL. Se value for NULL, o valor de retorno da função será NULL, quer a lista ou subconsulta contenha NULL ou não. Consulte Uso de NULL.
Sintaticamente, IN é tratado como um operador e não como uma função. Este exemplo mostra a diferença entre usar IN como um operador e chamar f() como uma função:
```
SELECT
    f(a, b),
    x IN (y, z) ...
```
Não é possível usar a sintaxe da função com IN. Por exemplo, não se pode reescrever o exemplo anterior como:
```
SELECT
    f(a, b),
    IN(x, (y, z)) ...
```
IN também é considerado um operador de subconsulta.
Em uma consulta que usa IN, você pode expandir uma matriz em uma lista de valores individuais usando o operador de propagação (**). Para obter mais informações e exemplos, consulte Operadores de expansão.

Detalhes do agrupamento¶

Arguments with collation specifications currently aren’t supported.

Exemplos¶

Os exemplos a seguir usam a função IN.

Uso de IN com literais simples¶

Os exemplos seguintes mostram como usar IN e NOT IN com literais simples:

SELECT 1 IN (1, 2, 3) AS RESULT;

+--------+
| RESULT |
|--------|
| True   |
+--------+

SELECT 4 NOT IN (1, 2, 3) AS RESULT;

+--------+
| RESULT |
|--------|
| True   |
+--------+

Uso de IN com uma subconsulta¶

Este exemplo mostra como usar IN em uma subconsulta.

SELECT 'a' IN (
  SELECT column1 FROM VALUES ('b'), ('c'), ('d')
  ) AS RESULT;

+--------+
| RESULT |
|--------|
| False  |
+--------+

Uso de IN com uma tabela¶

Estes exemplos mostram como usar IN com uma tabela. A instrução abaixo cria a tabela usada nos exemplos.

CREATE OR REPLACE TABLE in_function_demo (
  col_1 INTEGER,
  col_2 INTEGER,
  col_3 INTEGER);

INSERT INTO in_function_demo (col_1, col_2, col_3) VALUES
  (1, 1, 1),
  (1, 2, 3),
  (4, 5, NULL);

Este exemplo mostra como usar IN com uma única coluna de uma tabela:

SELECT col_1, col_2, col_3
  FROM in_function_demo
  WHERE (col_1) IN (1, 10, 100, 1000)
  ORDER BY col_1, col_2, col_3;

+-------+-------+-------+
| COL_1 | COL_2 | COL_3 |
|-------+-------+-------|
|     1 |     1 |     1 |
|     1 |     2 |     3 |
+-------+-------+-------+

Este exemplo mostra como usar IN com várias colunas de uma tabela:

SELECT col_1, col_2, col_3
  FROM in_function_demo
  WHERE (col_1, col_2, col_3) IN (
    (1,2,3),
    (4,5,6));

+-------+-------+-------+
| COL_1 | COL_2 | COL_3 |
|-------+-------+-------|
|     1 |     2 |     3 |
+-------+-------+-------+

Este exemplo mostra como usar IN com uma subconsulta que lê várias colunas de uma tabela:

SELECT (1, 2, 3) IN (
  SELECT col_1, col_2, col_3 FROM in_function_demo
  ) AS RESULT;

+--------+
| RESULT |
|--------|
| True   |
+--------+

Uso de NULL¶

Lembre-se de que NULL != NULL. IN e NOT IN Listas que contêm comparações com NULL (incluindo condições de igualdade) pode produzir resultados inesperados porque NULL representa um valor desconhecido. Comparações com NULL não retorne TRUE ou FALSE; eles retornam NULL. Consulte também Lógica ternária.

Por exemplo, a consulta a seguir retorna NULL, não TRUE, porque SQL não pode determinar se NULL é igual a qualquer valor, incluindo outro NULL.

SELECT NULL IN (1, 2, NULL) AS RESULT;

+--------+
| RESULT |
|--------|
| NULL   |
+--------+

Observe que se você alterar a consulta para selecionar 1, não NULL, ele retorna TRUE:

SELECT 1 IN (1, 2, NULL) AS RESULT;

+--------+
| RESULT |
|--------|
| True   |
+--------+

Neste caso, o resultado é TRUE porque 1 tem uma correspondência no IN lista. O fato de NULL também existe na IN a lista não afeta o resultado.

Da mesma forma, NOT IN Comparações com NULL também retornam NULL se algum valor na lista for NULL.

SELECT 1 NOT IN (1, 2, NULL) AS RESULT;

+--------+
| RESULT |
|--------|
| NULL  |
+--------+

O mesmo comportamento é verdadeiro para a consulta a seguir, onde o conjunto de valores 4, 5, NULL não corresponde a também 4, 5, NULL ou 7, 8, 9:

SELECT (4, 5, NULL) IN ( (4, 5, NULL), (7, 8, 9) ) AS RESULT;

O exemplo a seguir mostra o mesmo comportamento com NULL Comparações de, mas usa uma subconsulta para definir a IN Valores de lista que são comparados:

CREATE OR REPLACE TABLE in_list_table (
  val1 INTEGER,
  val2 INTEGER,
  val3 INTEGER
);

INSERT INTO in_list_table VALUES (1, 10, NULL), (2, 20, NULL), (NULL, NULL, NULL);

SELECT 1 IN (SELECT val1 FROM in_list_table) AS RESULT;

+--------+
| RESULT |
|--------|
| True   |
+--------+

SELECT NULL IN (SELECT val1 FROM in_list_table) AS RESULT;

+--------+
| RESULT |
|--------|
| NULL   |
+--------+

SELECT 3 IN (SELECT val1 FROM in_list_table) AS RESULT;

+--------+
| RESULT |
|--------|
| NULL   |
+--------+