Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

WHERE

View as MarkdownEdit this pageReport an issueSet up docs MCP

La cláusula WHERE le permite filtrar los datos que provienen de la cláusula FROM de SELECT.

Si hay una cláusula WHERE, debe ir seguida de una expresión de tipo UInt8. Las filas en las que esta expresión se evalúa como 0 se excluyen de transformaciones posteriores o del resultado.

La expresión que sigue a la cláusula WHERE suele usarse con operadores de comparación y operadores lógicos, o con una de las muchas funciones regulares.

Al evaluar la expresión WHERE, se tiene en cuenta si pueden utilizarse índices y la poda de particiones, siempre que el motor de tabla subyacente lo admita.

Comprobación de NULL

Si necesita comprobar si un valor es NULL, use:

De lo contrario, una expresión con NULL nunca se cumplirá.

Filtrar datos con operadores lógicos

Puede usar las siguientes funciones lógicas junto con la cláusula WHERE para combinar varias condiciones:

Uso de columnas UInt8 como condición

En ClickHouse, las columnas UInt8 pueden usarse directamente como condiciones booleanas, donde 0 es false y cualquier valor distinto de cero (normalmente 1) es true. Un ejemplo de esto se muestra en la sección siguiente.

Uso de los operadores de comparación

Se pueden usar los siguientes operadores de comparación:

Operador Función Descripción Ejemplo
a = b equals(a, b) Igual a price = 100
a == b equals(a, b) Igual a (sintaxis alternativa) price == 100
a != b notEquals(a, b) Distinto de category != 'Electronics'
a <> b notEquals(a, b) Distinto de (sintaxis alternativa) category <> 'Electronics'
a < b less(a, b) Menor que price < 200
a <= b lessOrEquals(a, b) Menor que o igual a price <= 200
a > b greater(a, b) Mayor que price > 500
a >= b greaterOrEquals(a, b) Mayor que o igual a price >= 500
a LIKE s like(a, b) Coincidencia de patrones (distingue entre mayúsculas y minúsculas) name LIKE '%top%'
a NOT LIKE s notLike(a, b) No coincide con el patrón (distingue entre mayúsculas y minúsculas) name NOT LIKE '%top%'
a ILIKE s ilike(a, b) Coincidencia de patrones (sin distinción entre mayúsculas y minúsculas) name ILIKE '%LAPTOP%'
a BETWEEN b AND c a >= b AND a <= c Comprobación de rango (inclusivo) price BETWEEN 100 AND 500
a NOT BETWEEN b AND c a < b OR a > c Comprobación fuera del rango price NOT BETWEEN 100 AND 500

Coincidencia de patrones y expresiones condicionales

Además de los operadores de comparación, puede usar la coincidencia de patrones y las expresiones condicionales en la cláusula WHERE.

Funcionalidad Sintaxis Sensible a mayúsculas/minúsculas Rendimiento Más adecuado para
LIKE col LIKE '%pattern%' Sí Rápido Coincidencia de patrones con mayúsculas/minúsculas exactas
ILIKE col ILIKE '%pattern%' No Más lento Búsquedas sin distinguir mayúsculas y minúsculas
if() if(cond, a, b) N/D Rápido Condiciones binarias simples
multiIf() multiIf(c1, r1, c2, r2, def) N/D Rápido Múltiples condiciones
CASE CASE WHEN ... THEN ... END N/D Rápido Lógica condicional estándar de SQL

Consulte "Coincidencia de patrones y expresiones condicionales" para ver ejemplos de uso.

Expresión con literales, columnas o subconsultas

La expresión que sigue a la cláusula WHERE también puede incluir literales, columnas o subconsultas, que son sentencias SELECT anidadas que devuelven valores usados en las condiciones.

Tipo Definición Evaluación Rendimiento Ejemplo
Literal Valor constante fijo Al escribir la consulta El más rápido WHERE price > 100
Columna Referencia a datos de la tabla Por fila Rápido WHERE price > cost
Subquery SELECT anidado Al ejecutar la consulta Variable WHERE id IN (SELECT ...)

Puede combinar literales, columnas y subconsultas en condiciones complejas:

-- 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 logical operators
WHERE (price > 100 OR category IN (SELECT category FROM featured))
  AND in_stock = true
  AND name LIKE '%Special%'

Ejemplos

Comprobación de NULL

Consultas con 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 │
└───┴───┘

Filtrado de datos con operadores lógicos

Dada la siguiente tabla y estos datos:

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 - se deben cumplir ambas condiciones:

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 - al menos una condición debe cumplirse:

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 - Niega una condición:

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 - Exactamente una condición debe cumplirse (no 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. Combinación de varios 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. Uso de la sintaxis de funciones:

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     │
   └────┴─────────┴────────┴─────────────┴──────────┘

La sintaxis con palabras clave de SQL (AND, OR, NOT, XOR) suele ser más legible, pero la sintaxis funcional puede resultar útil en expresiones complejas o al crear consultas dinámicas.

Uso de columnas UInt8 como condición

Tomando la tabla de un ejemplo anterior, puedes usar directamente el nombre de una columna como condición:

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     │
   └────┴─────────┴────────┴─────────────┴──────────┘

Uso de operadores de comparación

Los siguientes ejemplos utilizan la tabla y los datos del ejemplo anterior. Se omiten los resultados por motivos de brevedad.

1. Igualdad explícita con true (= 1 o = true):

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

2. Igualdad explícita con false (= 0 o = false):

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

3. Desigualdad (!= 0 o != false):

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

4. Mayor que:

SELECT * FROM products
WHERE in_stock > 0;

5. Menor o igual que:

SELECT * FROM products
WHERE in_stock <= 0;

6. Combinación con otras condiciones:

SELECT * FROM products
WHERE in_stock AND price < 400;

7. Uso del operador IN:

En el siguiente ejemplo, (1, true) es una tupla.

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

También puedes usar un array para ello:

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

8. Mezcla de estilos de comparación:

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

Coincidencia de patrones y expresiones condicionales

Los ejemplos siguientes usan la tabla y los datos del ejemplo anterior. Se omiten los resultados por brevedad.

Ejemplos de LIKE

-- Buscar productos con 'o' en el nombre
SELECT * FROM products WHERE name LIKE '%o%';
-- Resultado: Laptop, Monitor

-- Buscar productos que empiecen por 'L'
SELECT * FROM products WHERE name LIKE 'L%';
-- Resultado: Laptop, Lamp

-- Buscar productos con exactamente 4 caracteres
SELECT * FROM products WHERE name LIKE '____';
-- Resultado: Desk, Lamp

Ejemplos de ILIKE

-- Búsqueda sin distinción entre mayúsculas y minúsculas para 'LAPTOP'
SELECT * FROM products WHERE name ILIKE '%laptop%';
-- Resultado: Laptop

-- Coincidencia de prefijo sin distinción entre mayúsculas y minúsculas
SELECT * FROM products WHERE name ILIKE 'l%';
-- Resultado: Laptop, Lamp

Ejemplos de IF

-- Diferentes umbrales de precio por categoría
SELECT * FROM products
WHERE if(category = 'Electronics', price < 500, price < 200);
-- Resultado: Mouse, Chair, Monitor
-- (Electronics por debajo de $500 O Furniture por debajo de $200)

-- Filtro según el estado del inventario
SELECT * FROM products
WHERE if(in_stock, price > 100, true);
-- Resultado: Laptop, Chair, Monitor, Desk, Lamp
-- (Artículos en stock por encima de $100 O todos los artículos sin stock)

Ejemplos de multiIf

-- Condiciones múltiples basadas en categoría
SELECT * FROM products
WHERE multiIf(
    category = 'Electronics', price < 600,
    category = 'Furniture', in_stock = true,
    false
);
-- Resultado: Mouse, Monitor, Chair
-- (Electronics < $600 OR Furniture en stock)

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

Ejemplos de CASE

CASE simple:

-- 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 con condiciones de búsqueda:

-- 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
Navigation