Operadores lógicos

Os operadores lógicos retornam o resultado de uma determinada operação booleana em uma ou duas expressões de entrada. Os operadores lógicos também são chamados de operadores boolianos.

Os operadores lógicos só podem ser usados como um predicado (por exemplo, na cláusula WHERE). As expressões de entrada devem ser predicados.

Consulte também:

BOOLAND , BOOLNOT , BOOLOR , BOOLXOR

Lista de operadores lógicos

Operador

Exemplo de sintaxe

Descrição

AND

a AND b

Corresponde às duas expressões (a e b).

NOT

NOT a

Não corresponde à expressão.

OR

a OR b

Corresponde a qualquer expressão.

A ordem de precedência desses operadores é mostrada abaixo (do superior ao inferior):

  • NOT

  • AND

  • OR

Exemplos

Os exemplos a seguir usam operadores lógicos:

Como usar operadores lógicos em consultas sobre dados de tabelas

Criar uma tabela e inserir dados:

CREATE OR REPLACE TABLE logical_test1 (id INT, a INT, b VARCHAR);

INSERT INTO logical_test1 (id, a, b) VALUES (1, 8, 'Up');
INSERT INTO logical_test1 (id, a, b) VALUES (2, 25, 'Down');
INSERT INTO logical_test1 (id, a, b) VALUES (3, 15, 'Down');
INSERT INTO logical_test1 (id, a, b) VALUES (4, 47, 'Up');

SELECT * FROM logical_test1;

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  3 | 15 | Down |
|  4 | 47 | Up   |
+----+----+------+

Execução de consultas que usam um único operador lógico

Use um único operador lógico na cláusula WHERE de várias consultas:

SELECT *
  FROM logical_test1
  WHERE a > 20 AND
        b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE a > 20 OR
        b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
|  3 | 15 | Down |
|  4 | 47 | Up   |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE a > 20 OR
        b = 'Up';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  4 | 47 | Up   |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE NOT a > 20;

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  3 | 15 | Down |
+----+----+------+

Exibição da precedência dos operadores lógicos

Os exemplos a seguir mostram a precedência dos operadores lógicos.

O primeiro exemplo mostra que a precedência de AND é superior à precedência de OR. A consulta retorna as linhas que correspondem a essas condições:

  • b é igual a Down.

OR

  • a é igual a 8 AND b é igual a Up.

SELECT *
  FROM logical_test1
  WHERE b = 'Down' OR
        a = 8 AND b = 'Up';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  3 | 15 | Down |
+----+----+------+

É possível usar parênteses na cláusula WHERE para alterar a precedência. Por exemplo, a consulta a seguir retorna as linhas que correspondem a essas condições:

  • b é igual a Down OR a é igual a 8.

AND

  • b é igual a Up.

SELECT *
  FROM logical_test1
  WHERE (b = 'Down' OR a = 8) AND b = 'Up';

+----+---+----+
| ID | A | B  |
|----+---+----|
|  1 | 8 | Up |
+----+---+----+

O exemplo seguinte mostra que a precedência de NOT é superior à precedência de AND. Por exemplo, a consulta a seguir retorna as linhas que correspondem a essas condições:

  • a não (NOT) é igual a 15.

AND

  • b é igual a Down.

SELECT *
  FROM logical_test1
  WHERE NOT a = 15 AND b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
+----+----+------+

É possível usar parênteses na cláusula WHERE para alterar a precedência. Por exemplo, a consulta a seguir retorna as linhas que não (NOT) correspondem a ambas as condições:

  • a é igual a 15.

AND

  • b é igual a Down.

SELECT *
  FROM logical_test1
  WHERE NOT (a = 15 AND b = 'Down');

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  4 | 47 | Up   |
+----+----+------+

Como usar operadores lógicos em consultas sobre valores boolianos

Criar uma tabela e inserir dados:

CREATE OR REPLACE TABLE logical_test2 (a BOOLEAN, b BOOLEAN);

INSERT INTO logical_test2 VALUES (0, 1);

SELECT * FROM logical_test2;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

A consulta a seguir usa o operador OR para retornar as linhas em que a ou b é TRUE:

SELECT a, b FROM logical_test2 WHERE a OR b;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

A consulta a seguir usa o operador AND para retornar linhas em que a e b são ambos TRUE:

SELECT a, b FROM logical_test2 WHERE a AND b;

+---+---+
| A | B |
|---+---|
+---+---+

A consulta a seguir usa o operador AND e o operador NOT para retornar as linhas em que b é TRUE e a é FALSE:

SELECT a, b FROM logical_test2 WHERE b AND NOT a;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

A consulta a seguir usa o operador AND e o operador NOT para retornar as linhas em que a é TRUE e b é FALSE:

SELECT a, b FROM logical_test2 WHERE a AND NOT b;

+---+---+
| A | B |
|---+---|
+---+---+

Exibição de «tabelas de verdades» para os operadores lógicos

Os próximos exemplos mostram «tabelas de verdades» para os operadores lógicos em uma coluna booliana. Para obter mais informações sobre o comportamento dos valores boolianos no Snowflake, consulte Lógica ternária.

Crie uma nova tabela e dados:

CREATE OR REPLACE TABLE logical_test3 (x BOOLEAN);

INSERT INTO logical_test3 (x) VALUES
  (False),
  (True),
  (NULL);

Isto mostra a tabela de verdades para o operador OR:

SELECT x AS "OR",
       x OR False AS "FALSE",
       x OR True AS "TRUE",
       x OR NULL AS "NULL"
  FROM logical_test3;

+-------+-------+------+------+
| OR    | FALSE | TRUE | NULL |
|-------+-------+------+------|
| False | False | True | NULL |
| True  | True  | True | True |
| NULL  | NULL  | True | NULL |
+-------+-------+------+------+

Isto mostra a tabela de verdades para o operador AND:

SELECT x AS "AND",
       x AND False AS "FALSE",
       x AND True AS "TRUE",
       x AND NULL AS "NULL"
  FROM logical_test3;

+-------+-------+-------+-------+
| AND   | FALSE | TRUE  | NULL  |
|-------+-------+-------+-------|
| False | False | False | False |
| True  | False | True  | NULL  |
| NULL  | False | NULL  | NULL  |
+-------+-------+-------+-------+