> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-1d264819.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentação sobre Operadores # Operadores O ClickHouse transforma os operadores nas funções correspondentes durante a etapa de análise sintática da consulta, de acordo com sua prioridade, precedência e associatividade.
## Operadores de acesso
`a[N]` – Acesso a um elemento de um Array. A função `arrayElement(a, N)`. `a.N` – Acesso a um elemento de uma tupla. A função `tupleElement(a, N)`.
## Operador de negação numérica
`-a` – A função `negate(a)`. Para a negação de tuplas: [tupleNegate](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleNegate).
## Operadores de Multiplicação e Divisão
`a * b` – A função `multiply(a, b)`. Para multiplicar tupla por um número: [tupleMultiplyByNumber](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleMultiplyByNumber); para produto escalar: [dotProduct](/pt-BR/reference/functions/regular-functions/array-functions#arrayDotProduct). `a / b` – A função `divide(a, b)`. Para dividir tupla por um número: [tupleDivideByNumber](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleDivideByNumber). `a % b` – A função `modulo(a, b)`.
## Operadores de adição e subtração
`a + b` – A função `plus(a, b)`. Para adição de tuplas: [tuplePlus](/pt-BR/reference/functions/regular-functions/tuple-functions#tuplePlus). `a - b` – A função `minus(a, b)`. Para subtração de tuplas: [tupleMinus](/pt-BR/reference/functions/regular-functions/tuple-functions#tupleMinus).
## Operadores de comparação
### função equals
`a = b` – A função `equals(a, b)`. `a == b` – A função `equals(a, b)`.
### função notEquals
`a != b` – A função `notEquals(a, b)`. `a <> b` – A função `notEquals(a, b)`.
### função lessOrEquals
`a <= b` – a função `lessOrEquals(a, b)`.
### função greaterOrEquals
`a >= b` – A função `greaterOrEquals(a, b)`.
### função less
`a < b` – A função `less(a, b)`.
### função greater
`a > b` – A função `greater(a, b)`.
### função like
`a LIKE b` – a função `like(a, b)`.
### Função notLike
`a NOT LIKE b` – a função `notLike(a, b)`.
### função ilike
`a ILIKE b` – a função `ilike(a, b)`.
### Função BETWEEN
`a BETWEEN b AND c` – Equivale a `a >= b AND a <= c`. `a NOT BETWEEN b AND c` – Equivale a `a < b OR a > c`.
### operador `is not distinct from` (`<=>`)
A partir da versão 25.10, você pode usar `<=>` da mesma forma que qualquer outro operador. Antes da versão 25.10, ele só podia ser usado em expressões JOIN, por exemplo: ```sql theme={null} CREATE TABLE a (x String) ENGINE = Memory; INSERT INTO a VALUES ('ClickHouse'); SELECT * FROM a AS a1 JOIN a AS a2 ON a1.x <=> a2.x; ┌─x──────────┬─a2.x───────┐ │ ClickHouse │ ClickHouse │ └────────────┴────────────┘ ``` O operador `<=>` é o operador de igualdade compatível com `NULL`, equivalente a `IS NOT DISTINCT FROM`. Ele funciona como o operador de igualdade comum (`=`), mas trata valores `NULL` como comparáveis. Dois valores `NULL` são considerados iguais, e um `NULL` comparado com qualquer valor não `NULL` retorna 0 (falso), em vez de `NULL`. ```sql theme={null} SELECT 'ClickHouse' <=> NULL, NULL <=> NULL ``` ```response theme={null} ┌─isNotDistinc⋯use', NULL)─┬─isNotDistinc⋯NULL, NULL)─┐ │ 0 │ 1 │ └──────────────────────────┴──────────────────────────┘ ```
## Operadores para trabalhar com strings
### OVERLAY
* `OVERLAY(string PLACING replacement FROM offset)` - A função `overlay(string, replacement, offset)`. * `OVERLAY(string PLACING replacement FROM offset FOR length)` - A função `overlay(string, replacement, offset, length)`. * `OVERLAYUTF8(string PLACING replacement FROM offset)` - A função `overlayUTF8(string, replacement, offset)`. * `OVERLAYUTF8(string PLACING replacement FROM offset FOR length)` - A função `overlayUTF8(string, replacement, offset, length)`.
## Operadores para trabalhar com conjuntos de dados
Consulte os [operadores IN](/pt-BR/reference/statements/in) e o operador [EXISTS](/pt-BR/reference/operators/exists).
### função in
`a IN ...` – a função `in(a, b)`.
### função notIn
`a NOT IN ...` – a função `notIn(a, b)`.
### função globalIn
`a GLOBAL IN ...` – a função `globalIn(a, b)`.
### função globalNotIn
`a GLOBAL NOT IN ...` – A função `globalNotIn(a, b)`.
### função in de subconsulta
`a = ANY (subquery)` – A função `in(a, subquery)`.
### notIn subconsulta function
`a != ANY (subquery)` – O mesmo que `a NOT IN (SELECT singleValueOrNull(*) FROM subquery)`.
### função in subconsulta
`a = ALL (subquery)` – O mesmo que `a IN (SELECT singleValueOrNull(*) FROM subquery)`.
### função de subconsulta `notIn`
`a != ALL (subquery)` – A função `notIn(a, subquery)`. **Exemplos** Consulta com ALL: ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ALL (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ``` Consulta com ANY: ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ANY (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 4 │ │ 5 │ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ```
## Operadores para trabalhar com datas e horas
### EXTRACT
```sql theme={null} EXTRACT(part FROM date); ``` Extrai partes de uma determinada data. Por exemplo, você pode obter o mês de uma data ou os segundos de um horário. O parâmetro `part` especifica qual parte da data deve ser recuperada. Os seguintes valores estão disponíveis: * `SECOND` — O segundo. Valores possíveis: 0–59. * `MINUTE` — O minuto. Valores possíveis: 0–59. * `HOUR` — A hora. Valores possíveis: 0–23. * `DAY` — O dia do mês. Valores possíveis: 1–31. * `WEEK` — O número da semana ISO 8601. Valores possíveis: 1–53. * `MONTH` — O número do mês. Valores possíveis: 1–12. * `QUARTER` — O trimestre. Valores possíveis: 1–4. * `YEAR` — O ano. * `EPOCH` — O Unix timestamp (segundos desde 1970-01-01 00:00:00 UTC). Observação: para `DateTime64`, a parte fracionária dos segundos é truncada. * `DOW` — O dia da semana (compatível com PostgreSQL). 0 = domingo, 6 = sábado. * `DOY` — O dia do ano. Valores possíveis: 1–366. * `ISODOW` — O dia ISO da semana. 1 = segunda-feira, 7 = domingo. * `ISOYEAR` — O ano de numeração de semanas ISO 8601. * `CENTURY` — O século. Por exemplo, o ano de 2024 está no século 21. * `DECADE` — A década (ano dividido por 10). Por exemplo, o ano de 2024 tem década 202. * `MILLENNIUM` — O milênio. Por exemplo, o ano de 2024 está no 3º milênio. O parâmetro `part` não diferencia maiúsculas de minúsculas. O parâmetro `date` especifica a data ou o horário a ser processado. Os tipos [Date](/pt-BR/reference/data-types/date), [Date32](/pt-BR/reference/data-types/date32), [DateTime](/pt-BR/reference/data-types/datetime), e [DateTime64](/pt-BR/reference/data-types/datetime64) são suportados. Exemplos: ```sql theme={null} SELECT EXTRACT(DAY FROM toDate('2017-06-15')); SELECT EXTRACT(MONTH FROM toDate('2017-06-15')); SELECT EXTRACT(YEAR FROM toDate('2017-06-15')); SELECT EXTRACT(EPOCH FROM toDateTime('2024-01-15 12:30:45', 'UTC')); SELECT EXTRACT(DOW FROM toDate('2024-01-15')); SELECT EXTRACT(CENTURY FROM toDate('2024-01-01')); ``` No exemplo a seguir, criamos uma tabela e inserimos nela um valor do tipo `DateTime`. ```sql theme={null} CREATE TABLE test.Orders ( OrderId UInt64, OrderName String, OrderDate DateTime ) ENGINE = MergeTree ORDER BY (); ``` ```sql theme={null} INSERT INTO test.Orders VALUES (1, 'Jarlsberg Cheese', toDateTime('2008-10-11 13:23:44')); ``` ```sql theme={null} SELECT toYear(OrderDate) AS OrderYear, toMonth(OrderDate) AS OrderMonth, toDayOfMonth(OrderDate) AS OrderDay, toHour(OrderDate) AS OrderHour, toMinute(OrderDate) AS OrderMinute, toSecond(OrderDate) AS OrderSecond FROM test.Orders; ``` ```text theme={null} ┌─OrderYear─┬─OrderMonth─┬─OrderDay─┬─OrderHour─┬─OrderMinute─┬─OrderSecond─┐ │ 2008 │ 10 │ 11 │ 13 │ 23 │ 44 │ └───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘ ``` Você pode ver mais exemplos nos [testes](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00619_extract.sql).
### INTERVAL
Cria um valor do tipo [Interval](/pt-BR/reference/data-types/special-data-types/interval) que deve ser usado em operações aritméticas com valores do tipo [Date](/pt-BR/reference/data-types/date) e [DateTime](/pt-BR/reference/data-types/datetime). Tipos de intervalos: * `SECOND` * `MINUTE` * `HOUR` * `DAY` * `WEEK` * `MONTH` * `QUARTER` * `YEAR` Você também pode usar um literal de string ao definir um valor `INTERVAL`. Por exemplo, `INTERVAL 1 HOUR` é idêntico a `INTERVAL '1 hour'` ou `INTERVAL '1' hour`. Intervalos de tipos diferentes não podem ser combinados. Não é possível usar expressões como `INTERVAL 4 DAY 1 HOUR`. Especifique intervalos em unidades menores ou iguais à menor unidade do intervalo, por exemplo, `INTERVAL 25 HOUR`. Você pode usar operações consecutivas, como no exemplo abaixo. Exemplos: ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:09:50 │ 2020-11-08 01:09:50 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4 day' + INTERVAL '3 hour'; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:12:10 │ 2020-11-08 01:12:10 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4' day + INTERVAL '3' hour; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay('4')), toIntervalHour('3'))─┐ │ 2020-11-03 22:33:19 │ 2020-11-08 01:33:19 │ └─────────────────────┴────────────────────────────────────────────────────────────┘ ``` A sintaxe `INTERVAL` ou a função `addDays` devem ser sempre preferidas. A simples adição ou subtração (com sintaxe como `now() + ...`) não leva em conta as configurações de horário. Por exemplo, o horário de verão. Exemplos: ```sql theme={null} SELECT toDateTime('2014-10-26 00:00:00', 'Asia/Istanbul') AS time, time + 60 * 60 * 24 AS time_plus_24_hours, time + toIntervalDay(1) AS time_plus_1_day; ``` ```text theme={null} ┌────────────────time─┬──time_plus_24_hours─┬─────time_plus_1_day─┐ │ 2014-10-26 00:00:00 │ 2014-10-26 23:00:00 │ 2014-10-27 00:00:00 │ └─────────────────────┴─────────────────────┴─────────────────────┘ ``` **Veja também** * tipo de dado [Interval](/pt-BR/reference/data-types/special-data-types/interval) * [toInterval](/pt-BR/reference/functions/regular-functions/type-conversion-functions#toIntervalYear) funções de conversão de tipo
### Adição de data e hora
Um valor [Date](/pt-BR/reference/data-types/date) ou [Date32](/pt-BR/reference/data-types/date32) pode ser somado a um valor [Time](/pt-BR/reference/data-types/time) ou [Time64](/pt-BR/reference/data-types/time64) usando o operador `+`. O resultado é um [DateTime](/pt-BR/reference/data-types/datetime) ou [DateTime64](/pt-BR/reference/data-types/datetime64) que representa a data no horário informado. A operação é comutativa. O tipo do resultado depende dos tipos dos operandos: | Operando esquerdo | Operando direito | Tipo do resultado | | ----------------- | ---------------- | ----------------- | | `Date` | `Time` | `DateTime` | | `Date` | `Time64(s)` | `DateTime64(s)` | | `Date32` | `Time` | `DateTime64(0)` | | `Date32` | `Time64(s)` | `DateTime64(s)` | O resultado usa o [fuso horário da sessão](/pt-BR/reference/settings/session-settings#session_timezone) (ou o fuso horário padrão do servidor, se nenhum fuso horário da sessão estiver definido). A configuração [`date_time_overflow_behavior`](/pt-BR/reference/settings/formats#date_time_overflow_behavior) controla o que acontece quando o resultado fica fora do intervalo representável. Exemplos: ```sql theme={null} SET use_legacy_to_time = 0; SELECT toDate('2024-07-15') + toTime('14:30:25') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25 │ DateTime │ └─────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toDate('2024-07-15') + toTime64('14:30:25.123456', 6) AS dt, toTypeName(dt); ``` ```text theme={null} ┌─────────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25.123456 │ DateTime64(6) │ └────────────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toTime64('23:59:59.999', 3) + toDate32('2024-07-15') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 23:59:59.999 │ DateTime64(3) │ └─────────────────────────┴────────────────┘ ```
## Operador lógico AND
Sintaxe `SELECT a AND b` — calcula a conjunção lógica entre `a` e `b` usando a função [and](/pt-BR/reference/functions/regular-functions/logical-functions#and).
## Operador lógico OR
Sintaxe `SELECT a OR b` — calcula a disjunção lógica entre `a` e `b` usando a função [or](/pt-BR/reference/functions/regular-functions/logical-functions#or).
## Operador de negação lógica
Sintaxe `SELECT NOT a` — calcula a negação lógica de `a` usando a função [not](/pt-BR/reference/functions/regular-functions/logical-functions#not).
## Operador condicional
`a ? b : c` – A função `if(a, b, c)`. Observação: O operador condicional calcula os valores de b e c, verifica se a condição a é satisfeita e, em seguida, retorna o valor correspondente. Se `b` ou `C` for a função [arrayJoin()](/pt-BR/reference/functions/regular-functions/array-join), cada linha será replicada independentemente da condição "a".
## Expressão condicional
```sql theme={null} CASE [x] WHEN a THEN b [WHEN ... THEN ...] [ELSE c] END ``` Se `x` for especificado, será usada a função `transform(x, [a, ...], [b, ...], c)`. Caso contrário, `multiIf(a, b, ..., c)`. Se não houver a cláusula `ELSE c` na expressão, o valor padrão será `NULL`. A função `transform` não funciona com `NULL`.
## Operador de concatenação
`s1 || s2` – A função `concat(s1, s2) function.`
## Operador de criação de lambda
`x -> expr` – a função `lambda(x, expr)`. Os operadores a seguir não têm prioridade, pois são parênteses:
## Operador de criação de Array
`[x1, ...]` – A `função array(x1, ...).`
## Operador de criação de tupla
`(x1, x2, ...)` – A `função tuple(x2, x2, ...).`
## Associatividade
Todos os operadores binários têm associatividade à esquerda. Por exemplo, `1 + 2 + 3` é transformado em `plus(plus(1, 2), 3)`. Às vezes, isso não funciona como você espera. Por exemplo, `SELECT 4 > 2 > 3` resultará em 0. Para maior eficiência, as funções `and` e `or` aceitam qualquer número de argumentos. As cadeias correspondentes de operadores `AND` e `OR` são transformadas em uma única chamada dessas funções.
## Verificando `NULL`
O ClickHouse oferece suporte aos operadores `IS NULL` e `IS NOT NULL`.
### IS NULL
* Para valores do tipo [Nullable](/pt-BR/reference/data-types/nullable), o operador `IS NULL` retorna: * `1`, se o valor for `NULL`. * `0`, caso contrário. * Para outros valores, o operador `IS NULL` sempre retorna `0`. Pode ser otimizado habilitando a configuração [optimize\_functions\_to\_subcolumns](/pt-BR/reference/settings/session-settings#optimize_functions_to_subcolumns). Com `optimize_functions_to_subcolumns = 1`, a função lê apenas a subcoluna [null](/pt-BR/reference/data-types/nullable#finding-null), em vez de ler e processar todos os dados da coluna. A consulta `SELECT n IS NULL FROM table` é transformada em `SELECT n.null FROM TABLE`. ```sql theme={null} SELECT x+100 FROM t_null WHERE y IS NULL ``` ```text theme={null} ┌─plus(x, 100)─┐ │ 101 │ └──────────────┘ ```
### IS NOT NULL
* Para valores do tipo [Nullable](/pt-BR/reference/data-types/nullable), o operador `IS NOT NULL` retorna: * `0`, se o valor for `NULL`. * `1`, caso contrário. * Para outros valores, o operador `IS NOT NULL` sempre retorna `1`. ```sql theme={null} SELECT * FROM t_null WHERE y IS NOT NULL ``` ```text theme={null} ┌─x─┬─y─┐ │ 2 │ 3 │ └───┴───┘ ``` Pode ser otimizado ativando a configuração [optimize\_functions\_to\_subcolumns](/pt-BR/reference/settings/session-settings#optimize_functions_to_subcolumns). Com `optimize_functions_to_subcolumns = 1`, a função lê apenas a subcoluna [null](/pt-BR/reference/data-types/nullable#finding-null), em vez de ler e processar todos os dados da coluna. A consulta `SELECT n IS NOT NULL FROM table` é transformada em `SELECT NOT n.null FROM TABLE`.