WHERE

A cláusula WHERE permite filtrar os dados que vêm da cláusulaFROM de SELECT. Se houver uma cláusula WHERE, ela deve ser seguida de uma expressão do tipo UInt8. As linhas para as quais essa expressão resulta em 0 são excluídas de transformações posteriores ou do resultado. A expressão que segue a cláusula WHERE costuma ser usada com operadores de comparação e operadores lógicos, ou com uma das muitas funções regulares. A expressão na cláusula WHERE é avaliada considerando a possibilidade de usar índices e poda de partições, se o engine de tabela subjacente oferecer suporte a isso.

PREWHERETambém há uma otimização de filtragem chamada PREWHERE. PREWHERE é uma otimização para aplicar a filtragem com mais eficiência. Ela é habilitada por padrão mesmo que a cláusula PREWHERE não seja especificada explicitamente.

Verificar `NULL`

Se você precisar testar se um valor é NULL, use:

IS NULL ou isNull
IS NOT NULL ou isNotNull

Caso contrário, uma expressão com NULL nunca será avaliada como verdadeira.

Filtrando dados com operadores lógicos

Você pode usar as seguintes funções lógicas em conjunto com a cláusula WHERE para combinar várias condições:

and() ou AND
not() ou NOT
or() ou NOT
xor()

Usando colunas `UInt8` como condição

No ClickHouse, colunas UInt8 podem ser usadas diretamente como condições booleanas, em que 0 é false e qualquer valor diferente de zero (geralmente 1) é true. Um exemplo disso é mostrado na seção abaixo.

Usando operadores de comparação

Os seguintes operadores de comparação podem ser usados:

Operador	Função	Descrição	Exemplo
`a = b`	`equals(a, b)`	Igual a	`price = 100`
`a == b`	`equals(a, b)`	Igual a (sintaxe alternativa)	`price == 100`
`a != b`	`notEquals(a, b)`	Diferente de	`category != 'Electronics'`
`a <> b`	`notEquals(a, b)`	Diferente de (sintaxe alternativa)	`category <> 'Electronics'`
`a < b`	`less(a, b)`	Menor que	`price < 200`
`a <= b`	`lessOrEquals(a, b)`	Menor que ou igual a	`price <= 200`
`a > b`	`greater(a, b)`	Maior que	`price > 500`
`a >= b`	`greaterOrEquals(a, b)`	Maior que ou igual a	`price >= 500`
`a LIKE s`	`like(a, b)`	Correspondência de patterns (diferencia maiúsculas de minúsculas)	`name LIKE '%top%'`
`a NOT LIKE s`	`notLike(a, b)`	Não corresponde ao pattern (diferencia maiúsculas de minúsculas)	`name NOT LIKE '%top%'`
`a ILIKE s`	`ilike(a, b)`	Correspondência de patterns (sem diferenciar maiúsculas de minúsculas)	`name ILIKE '%LAPTOP%'`
`a SIMILAR TO s`	`similarTo(a, b)`	Correspondência de patterns conforme o padrão SQL (diferencia maiúsculas de minúsculas)	`name SIMILAR TO 'Lap(top)?'`
`a NOT SIMILAR TO s`	`notSimilarTo(a, b)`	Não corresponde ao pattern (sintaxe do padrão SQL, diferencia maiúsculas de minúsculas)	`name NOT SIMILAR TO 'Lap(top)?'`
`a BETWEEN b AND c`	`a >= b AND a <= c`	Verificação de intervalo (inclusive)	`price BETWEEN 100 AND 500`
`a NOT BETWEEN b AND c`	`a < b OR a > c`	Verificação fora do intervalo	`price NOT BETWEEN 100 AND 500`

Correspondência de patterns e expressões condicionais

Além dos operadores de comparação, você pode usar correspondência de patterns e expressões condicionais na cláusula WHERE.

Recurso	Sintaxe	Diferenciar maiúsculas de minúsculas	Desempenho	Melhor para
`LIKE`	`col LIKE '%pattern%'`	Sim	Rápido	Correspondência exata de pattern
`ILIKE`	`col ILIKE '%pattern%'`	Não	Mais lento	Busca sem diferenciar maiúsculas de minúsculas
`SIMILAR TO`	`col SIMILAR TO 'p[ab]+%'`	Sim	Mais lento	Patterns no padrão SQL com metacaracteres de expressões regulares
`if()`	`if(cond, a, b)`	N/A	Rápido	Condições binárias simples
`multiIf()`	`multiIf(c1, r1, c2, r2, def)`	N/A	Rápido	Múltiplas condições
`CASE`	`CASE WHEN ... THEN ... END`	N/A	Rápido	Lógica condicional padrão SQL

Consulte “Correspondência de patterns e expressões condicionais” para ver exemplos de uso.

Expressão com literais, colunas ou subconsultas

A expressão após a cláusula WHERE também pode incluir literais, colunas ou subconsultas, que são instruções SELECT aninhadas que retornam valores usados em condições.

Tipo	Definição	Avaliação	Desempenho	Exemplo
Literal	Valor constante fixo	No momento da escrita da consulta	Mais rápido	`WHERE price > 100`
Coluna	Referência aos dados da tabela	Por linha	Rápido	`WHERE price > cost`
Subconsulta	`SELECT` aninhado	No momento da execução da consulta	Varia	`WHERE id IN (SELECT ...)`

Você pode combinar literais, colunas e subconsultas em condições complexas:

-- Literal + Column
WHERE price > 100 AND category = 'Electronics'

-- Column + Subquery
WHERE price > (SELECT AVG(price) FROM products) AND in_stock = true

-- Literal + Column + Subquery
WHERE category = 'Electronics'
  AND price < 500
  AND id IN (SELECT product_id FROM bestsellers)

-- All three with operador lógico
WHERE (price > 100 OR category IN (SELECT category FROM featured))
  AND in_stock = true
  AND name LIKE '%Special%'

Exemplos

Verificando `NULL`

Consultas com valores NULL:

CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE=MergeTree() ORDER BY x;
INSERT INTO t_null VALUES (1, NULL), (2, 3);

SELECT * FROM t_null WHERE y IS NULL;
SELECT * FROM t_null WHERE y != 0;

┌─x─┬────y─┐
│ 1 │ ᴺᵁᴸᴸ │
└───┴──────┘
┌─x─┬─y─┐
│ 2 │ 3 │
└───┴───┘

Filtrando dados com operadores lógicos

Considere a tabela e os dados a seguir:

CREATE TABLE products (
    id UInt32,
    name String,
    price Float32,
    category String,
    in_stock Bool
) ENGINE = MergeTree()
ORDER BY id;

INSERT INTO products VALUES
(1, 'Laptop', 999.99, 'Electronics', true),
(2, 'Mouse', 25.50, 'Electronics', true),
(3, 'Desk', 299.00, 'Furniture', false),
(4, 'Chair', 150.00, 'Furniture', true),
(5, 'Monitor', 350.00, 'Electronics', true),
(6, 'Lamp', 45.00, 'Furniture', false);

1. AND - ambas as condições devem ser atendidas:

SELECT * FROM products
WHERE category = 'Electronics' AND price < 500;

   ┌─id─┬─name────┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse   │  25.5 │ Electronics │ true     │
2. │  5 │ Monitor │   350 │ Electronics │ true     │
   └────┴─────────┴───────┴─────────────┴──────────┘

2. OR - pelo menos uma condição deve ser atendida:

SELECT * FROM products
WHERE category = 'Furniture' OR price > 500;

   ┌─id─┬─name───┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop │ 999.99 │ Electronics │ true     │
2. │  3 │ Desk   │    299 │ Furniture   │ false    │
3. │  4 │ Chair  │    150 │ Furniture   │ true     │
4. │  6 │ Lamp   │     45 │ Furniture   │ false    │
   └────┴────────┴────────┴─────────────┴──────────┘

3. NOT - Nega uma condição:

SELECT * FROM products
WHERE NOT in_stock;

   ┌─id─┬─name─┬─price─┬─category──┬─in_stock─┐
1. │  3 │ Desk │   299 │ Furniture │ false    │
2. │  6 │ Lamp │    45 │ Furniture │ false    │
   └────┴──────┴───────┴───────────┴──────────┘

4. XOR - Exatamente uma condição deve ser verdadeira (mas não ambas):

SELECT *
FROM products
WHERE xor(price > 200, category = 'Electronics')

   ┌─id─┬─name──┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse │  25.5 │ Electronics │ true     │
2. │  3 │ Desk  │   299 │ Furniture   │ false    │
   └────┴───────┴───────┴─────────────┴──────────┘

5. Combinando vários operadores:

SELECT * FROM products
WHERE (category = 'Electronics' OR category = 'Furniture')
  AND in_stock = true
  AND price < 400;

   ┌─id─┬─name────┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse   │  25.5 │ Electronics │ true     │
2. │  4 │ Chair   │   150 │ Furniture   │ true     │
3. │  5 │ Monitor │   350 │ Electronics │ true     │
   └────┴─────────┴───────┴─────────────┴──────────┘

6. Usando sintaxe de função:

SELECT * FROM products
WHERE and(or(category = 'Electronics', price > 100), in_stock);

   ┌─id─┬─name────┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop  │ 999.99 │ Electronics │ true     │
2. │  2 │ Mouse   │   25.5 │ Electronics │ true     │
3. │  4 │ Chair   │    150 │ Furniture   │ true     │
4. │  5 │ Monitor │    350 │ Electronics │ true     │
   └────┴─────────┴────────┴─────────────┴──────────┘

A sintaxe com palavras-chave SQL (AND, OR, NOT, XOR) geralmente é mais legível, mas a sintaxe de função pode ser útil em expressões complexas ou ao criar consultas dinâmicas.

Usando colunas UInt8 como condição

Usando a tabela de um exemplo anterior, você pode usar o nome de uma coluna diretamente como condição:

SELECT * FROM products
WHERE in_stock

   ┌─id─┬─name────┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop  │ 999.99 │ Electronics │ true     │
2. │  2 │ Mouse   │   25.5 │ Electronics │ true     │
3. │  4 │ Chair   │    150 │ Furniture   │ true     │
4. │  5 │ Monitor │    350 │ Electronics │ true     │
   └────┴─────────┴────────┴─────────────┴──────────┘

Usando operadores de comparação

Os exemplos abaixo usam a tabela e os dados do exemplo acima. Os resultados foram omitidos por brevidade. 1. Igualdade explícita com true (= 1 ou = true):

SELECT * FROM products
WHERE in_stock = true;
-- ou
WHERE in_stock = 1;

2. Igualdade explícita com false (= 0 ou = false):

SELECT * FROM products
WHERE in_stock = false;
-- ou
WHERE in_stock = 0;

3. Desigualdade (!= 0 ou != false):

SELECT * FROM products
WHERE in_stock != false;
-- ou
WHERE in_stock != 0;

4. Maior que:

SELECT * FROM products
WHERE in_stock > 0;

5. Menor ou igual a:

SELECT * FROM products
WHERE in_stock <= 0;

6. Em combinação com outras condições:

SELECT * FROM products
WHERE in_stock AND price < 400;

7. Usando o operador IN: No exemplo abaixo, (1, true) é uma tupla.

SELECT * FROM products
WHERE in_stock IN (1, true);

Você também pode usar um array para isso:

SELECT * FROM products
WHERE in_stock IN [1, true];

8. Mistura de estilos de comparação:

SELECT * FROM products
WHERE category = 'Electronics' AND in_stock = true;

Correspondência de padrões e expressões condicionais

Os exemplos abaixo usam a tabela e os dados do exemplo acima. Os resultados foram omitidos por brevidade.

Exemplos de LIKE

-- Encontrar produtos com 'o' no nome
SELECT * FROM products WHERE name LIKE '%o%';
-- Resultado: Laptop, Monitor

-- Encontrar produtos que começam com 'L'
SELECT * FROM products WHERE name LIKE 'L%';
-- Resultado: Laptop, Lamp

-- Encontrar produtos com exatamente 4 caracteres
SELECT * FROM products WHERE name LIKE '____';
-- Resultado: Desk, Lamp

Exemplos de ILIKE

-- Busca sem distinção entre maiúsculas e minúsculas por 'LAPTOP'
SELECT * FROM products WHERE name ILIKE '%laptop%';
-- Result: Laptop

-- Correspondência de prefixo sem distinção entre maiúsculas e minúsculas
SELECT * FROM products WHERE name ILIKE 'l%';
-- Result: Laptop, Lamp

Exemplos de SIMILAR TO

Diferentemente de LIKE, um pattern de SIMILAR TO também aceita os metacaracteres de expressão regular |, *, +, ?, {, }, (, ), [ e ] e, assim como no LIKE, deve corresponder ao valor inteiro:

-- Alternation: either of two names
SELECT * FROM products WHERE name SIMILAR TO 'Desk|Lamp';
-- Result: Desk, Lamp

-- A bracket expression combined with the LIKE wildcard `%`
SELECT * FROM products WHERE name SIMILAR TO '[LM]%';
-- Result: Laptop, Mouse, Monitor, Lamp

-- Repetition: a name of five or more characters
SELECT * FROM products WHERE name SIMILAR TO '_{5,}';
-- Result: Laptop, Mouse, Chair, Monitor

-- Negation
SELECT * FROM products WHERE name NOT SIMILAR TO '(Desk|Lamp)';
-- Result: Laptop, Mouse, Chair, Monitor

É possível definir um caractere de escape personalizado com a cláusula ESCAPE, que também funciona com LIKE, ILIKE, NOT LIKE, NOT ILIKE e NOT SIMILAR TO:

-- `#%` denotes a literal `%`, so this matches names containing a percent sign
SELECT * FROM products WHERE name SIMILAR TO '%#%%' ESCAPE '#';
-- Result: (none)

Consulte a documentação do operador SIMILAR TO para ver a gramática completa do pattern.

Exemplos de IF

-- Diferentes limites de preço por categoria
SELECT * FROM products
WHERE if(category = 'Electronics', price < 500, price < 200);
-- Resultado: Mouse, Chair, Monitor
-- (Electronics abaixo de $500 OU Furniture abaixo de $200)

-- Filtrar com base no status do estoque
SELECT * FROM products
WHERE if(in_stock, price > 100, true);
-- Resultado: Laptop, Chair, Monitor, Desk, Lamp
-- (Itens em estoque acima de $100 OU todos os itens fora de estoque)

Exemplos de multiIf

-- Múltiplas condições baseadas em categoria
SELECT * FROM products
WHERE multiIf(
    category = 'Electronics', price < 600,
    category = 'Furniture', in_stock = true,
    false
);
-- Resultado: Mouse, Monitor, Chair
-- (Electronics < $600 OU Furniture em estoque)

-- Filtragem em camadas
SELECT * FROM products
WHERE multiIf(
    price > 500, category = 'Electronics',
    price > 100, in_stock = true,
    true
);
-- Resultado: Laptop, Chair, Monitor, Lamp

Exemplos de CASE

CASE simples:

-- Different rules per category
SELECT * FROM products
WHERE CASE category
    WHEN 'Electronics' THEN price < 400
    WHEN 'Furniture' THEN in_stock = true
    ELSE false
END;
-- Result: Mouse, Monitor, Chair

CASE com condição:

-- Price-based tiered logic
SELECT * FROM products
WHERE CASE
    WHEN price > 500 THEN in_stock = true
    WHEN price > 100 THEN category = 'Electronics'
    ELSE true
END;
-- Result: Laptop, Monitor, Mouse, Lamp

Referência de SQL

Tipos de dados

Motores

Funções

Formatos

Configurações

Tabelas de sistema

Lagos de dados

Verificar `NULL`

Filtrando dados com operadores lógicos

Usando colunas `UInt8` como condição

Usando operadores de comparação

Correspondência de patterns e expressões condicionais

Expressão com literais, colunas ou subconsultas

Exemplos

Verificando `NULL`

Filtrando dados com operadores lógicos

Usando colunas UInt8 como condição

Usando operadores de comparação

Correspondência de padrões e expressões condicionais

Exemplos de LIKE

Exemplos de ILIKE

Exemplos de SIMILAR TO

Exemplos de IF

Exemplos de multiIf

Exemplos de CASE

​Verificar NULL

​Filtrando dados com operadores lógicos

​Usando colunas UInt8 como condição

​Usando operadores de comparação

​Correspondência de patterns e expressões condicionais

​Expressão com literais, colunas ou subconsultas

​Exemplos

​Verificando NULL

​Filtrando dados com operadores lógicos

​Usando colunas UInt8 como condição

​Usando operadores de comparação

​Correspondência de padrões e expressões condicionais

​Exemplos de LIKE

​Exemplos de ILIKE

​Exemplos de SIMILAR TO

​Exemplos de IF

​Exemplos de multiIf

​Exemplos de CASE

Verificar `NULL`

Filtrando dados com operadores lógicos

Usando colunas `UInt8` como condição

Usando operadores de comparação

Correspondência de patterns e expressões condicionais

Expressão com literais, colunas ou subconsultas

Exemplos

Verificando `NULL`

Filtrando dados com operadores lógicos

Usando colunas UInt8 como condição

Usando operadores de comparação

Correspondência de padrões e expressões condicionais

Exemplos de LIKE

Exemplos de ILIKE

Exemplos de SIMILAR TO

Exemplos de IF

Exemplos de multiIf

Exemplos de CASE