WHERE

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.

PREWHERETambién existe una optimización de filtrado llamada PREWHERE. Prewhere es una optimización que permite aplicar el filtrado de forma más eficiente. Está habilitada de forma predeterminada incluso si la cláusula PREWHERE no se especifica explícitamente.

Comprobación de `NULL`

Si necesita comprobar si un valor es NULL, use:

IS NULL o isNull
IS NOT NULL o isNotNull

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:

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

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 (sensible a mayúsculas y minúsculas)	`name LIKE '%top%'`
`a NOT LIKE s`	`notLike(a, b)`	No coincide con el patrón (sensible a mayúsculas y minúsculas)	`name NOT LIKE '%top%'`
`a ILIKE s`	`ilike(a, b)`	Coincidencia de patrones (sin distinguir entre mayúsculas y minúsculas)	`name ILIKE '%LAPTOP%'`
`a SIMILAR TO s`	`similarTo(a, b)`	Coincidencia de patrones conforme al estándar SQL (sensible a mayúsculas y minúsculas)	`name SIMILAR TO 'Lap(top)?'`
`a NOT SIMILAR TO s`	`notSimilarTo(a, b)`	No coincide con el patrón conforme al estándar SQL (sensible a mayúsculas y minúsculas)	`name NOT SIMILAR TO 'Lap(top)?'`
`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 entre mayúsculas y minúsculas
`SIMILAR TO`	`col SIMILAR TO 'p[ab]+%'`	Sí	Más lento	Patrones del estándar SQL con metacaracteres de expresiones regulares
`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 SIMILAR TO

A diferencia de LIKE, un patrón de SIMILAR TO también admite los metacaracteres de las expresiones regulares |, *, +, ?, {, }, (, ), [ y ] y, al igual que LIKE, debe coincidir con el valor completo:

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

Se puede especificar un carácter de escape personalizado mediante la cláusula ESCAPE, que también funciona con LIKE, ILIKE, NOT LIKE, NOT ILIKE y 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 la documentación del operador SIMILAR TO para conocer la gramática completa de los patrones.

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

Referencia de SQL

Tipos de datos

Motores

Funciones

Formatos

Configuración

Tablas del sistema

Lagos de datos

Comprobación de `NULL`

Filtrar datos con operadores lógicos

Uso de columnas `UInt8` como condición

Uso de los operadores de comparación

Coincidencia de patrones y expresiones condicionales

Expresión con literales, columnas o subconsultas

Ejemplos

Comprobación de `NULL`

Filtrado de datos con operadores lógicos

Uso de columnas UInt8 como condición

Uso de operadores de comparación

Coincidencia de patrones y expresiones condicionales

Ejemplos de LIKE

Ejemplos de ILIKE

Ejemplos de SIMILAR TO

Ejemplos de IF

Ejemplos de multiIf

Ejemplos de CASE

​Comprobación de NULL

​Filtrar datos con operadores lógicos

​Uso de columnas UInt8 como condición

​Uso de los operadores de comparación

​Coincidencia de patrones y expresiones condicionales

​Expresión con literales, columnas o subconsultas

​Ejemplos

​Comprobación de NULL

​Filtrado de datos con operadores lógicos

​Uso de columnas UInt8 como condición

​Uso de operadores de comparación

​Coincidencia de patrones y expresiones condicionales

​Ejemplos de LIKE

​Ejemplos de ILIKE

​Ejemplos de SIMILAR TO

​Ejemplos de IF

​Ejemplos de multiIf

​Ejemplos de CASE

Comprobación de `NULL`

Filtrar datos con operadores lógicos

Uso de columnas `UInt8` como condición

Uso de los operadores de comparación

Coincidencia de patrones y expresiones condicionales

Expresión con literales, columnas o subconsultas

Ejemplos

Comprobación de `NULL`

Filtrado de datos con operadores lógicos

Uso de columnas UInt8 como condición

Uso de operadores de comparación

Coincidencia de patrones y expresiones condicionales

Ejemplos de LIKE

Ejemplos de ILIKE

Ejemplos de SIMILAR TO

Ejemplos de IF

Ejemplos de multiIf

Ejemplos de CASE