MaxCompute SQL operators - relational, arithmetic, bitwise, logical - MaxCompute: Central de Documentação do Alibaba Cloud

Visão geral

O MaxCompute oferece suporte aos seguintes tipos de operadores:

Tipo de operador	Descrição
Operadores relacionais	Comparam valores e retornam um resultado BOOLEAN.
Operadores de string	Concatenam strings.
Operadores aritméticos	Realizam cálculos matemáticos.
Operadores bit a bit	Operam sobre representações binárias de inteiros.
Operadores lógicos	Combinam múltiplas condições. Geralmente usados com expressões BOOLEAN.

Operadores relacionais

Os operadores relacionais comparam dois valores e retornam TRUE, FALSE ou NULL. Salvo indicação em contrário, se qualquer operando for NULL, o resultado será NULL.

Operador	Descrição
`A = B`	Retorna TRUE se A for igual a B. Retorna NULL se A ou B for NULL.
`A<=>B`	Igualdade segura para NULL. Retorna TRUE se A e B forem NULL. Retorna FALSE se apenas um deles for NULL. Caso contrário, retorna TRUE se A for igual a B ou FALSE se não for.
`A<>B`	Retorna TRUE se A não for igual a B. Retorna NULL se A ou B for NULL.
`A<B`	Retorna TRUE se A for menor que B. Retorna NULL se A ou B for NULL.
`A<=B`	Retorna TRUE se A for menor ou igual a B. Retorna NULL se A ou B for NULL.
`A>B`	Retorna TRUE se A for maior que B. Retorna NULL se A ou B for NULL.
`A>=B`	Retorna TRUE se A for maior ou igual a B. Retorna NULL se A ou B for NULL.
`A IS NULL`	Retorna TRUE se A for NULL. Caso contrário, retorna FALSE.
`A IS NOT NULL`	Retorna TRUE se A não for NULL. Caso contrário, retorna FALSE.
`A LIKE B`	Correspondência de padrão. Retorna TRUE se a string A corresponder ao padrão B. Retorna NULL se A ou B for NULL. O caractere curinga `%` corresponde a zero ou mais caracteres. O caractere curinga `_` corresponde exatamente a um caractere. Para corresponder a um `%` ou `_` literal, use escape com aspas simples (`'%'` ou `'_'`).
`A RLIKE B`	Correspondência de expressão regular. Retorna TRUE se a string A corresponder à expressão regular B. Retorna NULL se A ou B for NULL. Retorna erro se B for uma string vazia. `A RLIKE B` equivale a `A REGEXP B`.
`A IN B`	Retorna TRUE se A estiver no conjunto B. Retorna NULL se A for NULL. O conjunto B deve ser constante, conter pelo menos um elemento e todos os elementos devem ter o mesmo tipo de dados.
`A [NOT] BETWEEN B AND C`	Retorna TRUE se A for maior ou igual a B e menor ou igual a C (ou o inverso com NOT). Retorna NULL se A, B ou C for NULL.
`A IS [NOT] DISTINCT FROM B`	Compara dois valores, tratando valores NULL como iguais.

Exemplos de padrões LIKE

'aaa' LIKE 'a__'    -- TRUE (underscore matches one character)
'aaa' LIKE 'a%'     -- TRUE (percent matches zero or more characters)
'aaa' LIKE 'aab'    -- FALSE
'a%b' LIKE 'a\\%b'  -- TRUE (escaped percent matches literal %)
'axb' LIKE 'a\\%b'  -- FALSE

Exemplos de uso

SELECT * FROM user WHERE user_id = '0001';
SELECT * FROM user WHERE user_name <> 'maggie';
SELECT * FROM user WHERE age > '50';
SELECT * FROM user WHERE birth_day >= '1980-01-01 00:00:00';
SELECT * FROM user WHERE is_female IS NULL;
SELECT * FROM user WHERE is_female IS NOT NULL;
SELECT * FROM user WHERE user_id IN (0001, 0010);
SELECT * FROM user WHERE user_name LIKE 'M%';

Observações importantes

Nota

Tipos incompatíveis podem retornar NULL nas comparações. Converta os operandos para tipos compatíveis antes de comparar. Conversões de tipo.

Comparação de valores DOUBLE

Evite comparar valores DOUBLE diretamente com = devido à precisão limitada. Em vez disso, verifique se a diferença absoluta é menor que um limiar:

ABS(0.9999999999 - 1.0000000000) < 0.000000001
-- 0.9999999999 and 1.0000000000 have a precision of 10 decimal digits,
-- whereas 0.000000001 has a precision of 9 decimal digits.
-- 0.9999999999 is considered to be equal to 1.0000000000.

ABS é uma função integrada que retorna o valor absoluto da entrada.
Um valor DOUBLE no MaxCompute geralmente fornece 14 dígitos decimais de precisão.

Comparação de valores STRING e BIGINT

A comparação entre STRING e BIGINT converte implicitamente ambos para DOUBLE, o que pode causar perda de precisão. Use CAST(string_value AS BIGINT) para converter a STRING para BIGINT primeiro.

Operadores de string

Operador	Descrição
`A		B`	Concatena as strings A e B. Por exemplo, `a		b		c` equivale a `CONCAT(a, b, c)`.

Exemplo

SELECT first_name || ' ' || last_name AS full_name FROM employees;

Operadores aritméticos

Os operadores aritméticos realizam cálculos matemáticos em valores numéricos.

Operador	Descrição
`A+B`	Retorna a soma de A e B. Retorna NULL se A ou B for NULL.
`A-B`	Retorna a diferença de A menos B. Retorna NULL se A ou B for NULL.
`A*B`	Retorna o produto de A multiplicado por B. Retorna NULL se A ou B for NULL.
`A/B`	Retorna o quociente de A dividido por B. Retorna NULL se A ou B for NULL. Se A e B forem do tipo BIGINT, o resultado será do tipo DOUBLE.
`A%B`	Retorna o resto da divisão de A por B. Retorna NULL se A ou B for NULL.
`+A`	Retorna A (mais unário).
`-A`	Retorna a negação de A. Retorna NULL se A for NULL.
`A DIV B`	Realiza a divisão inteira de A por B, descartando a parte fracionária. Retorna NULL se A ou B for NULL.

Exemplo

SELECT age + 10, age - 10, age % 10, -age, age * age, age / 10, age DIV 10 FROM user;

Regras de tipos de dados

Apenas operandos STRING, BIGINT, DOUBLE e TIMESTAMP_NTZ oferecem suporte a operações aritméticas. Valores de data e BOOLEAN não são suportados. Tipos de dados TIMESTAMP_NTZ do MaxCompute.
Operandos STRING são convertidos implicitamente para DOUBLE antes do cálculo.
Ao misturar operandos BIGINT e DOUBLE, o valor BIGINT é convertido implicitamente para DOUBLE e o resultado é DOUBLE.
Se A e B forem BIGINT, A / B retorna DOUBLE. Todas as outras operações aritméticas com dois operandos BIGINT retornam BIGINT.

Operadores bit a bit

Os operadores bit a bit atuam na representação binária de inteiros. Ambos os operandos devem ser BIGINT. Não há conversões implícitas de tipo.

Operador	Sintaxe	Descrição
`&` / `BITAND`	`A & B` ou `BITAND(A, B)`	Retorna o AND bit a bit de A e B. Por exemplo, `1 & 2` retorna `0`, e `BITAND(1, 3)` retorna `1`. Retorna NULL se A ou B for NULL.
`	` / `BITOR`	`A	B` ou `BITOR(A, B)`	Retorna o OR bit a bit de A e B. Por exemplo, `1	2` retorna `3`, e `BITOR(1, 3)` retorna `3`. Retorna NULL se A ou B for NULL.
`~` / `BITNOT`	`~A` ou `BITNOT(A)`	Retorna o NOT bit a bit de A. Por exemplo, `~1` retorna `-2`, e `BITNOT(7)` retorna `-8`. Retorna NULL se A for NULL.
`^` / `BITXOR`	`A ^ B` ou `BITXOR(A, B)`	Retorna o XOR bit a bit de A e B. Por exemplo, `1 ^ 2` retorna `3`, e `BITXOR(4, 5)` retorna `1`. Retorna NULL se A ou B for NULL.

Operadores lógicos

Os operadores lógicos combinam expressões BOOLEAN. Apenas operandos BOOLEAN são suportados; não há conversões implícitas de tipo.

As tabelas-verdade a seguir mostram os resultados para todas as combinações de TRUE, FALSE e NULL:

AND

A	B	A AND B
TRUE	TRUE	TRUE
TRUE	FALSE	FALSE
FALSE	TRUE	FALSE
FALSE	FALSE	FALSE
FALSE	NULL	FALSE
NULL	FALSE	FALSE
TRUE	NULL	NULL
NULL	TRUE	NULL
NULL	NULL	NULL

OR

A	B	A OR B
TRUE	TRUE	TRUE
TRUE	FALSE	TRUE
FALSE	TRUE	TRUE
FALSE	FALSE	FALSE
FALSE	NULL	NULL
NULL	FALSE	NULL
TRUE	NULL	TRUE
NULL	TRUE	TRUE
NULL	NULL	NULL

NOT

A	NOT A
TRUE	FALSE
FALSE	TRUE
NULL	NULL

Precedência de operadores

Quando uma expressão contém múltiplos operadores, o MaxCompute os avalia na seguinte ordem. Números menores indicam maior precedência. Operadores no mesmo nível são avaliados da esquerda para a direita.

Precedência	Operadores
1 (maior)	`IS (NOT) NULL`
2	`^`
3	`*`, `/`, `%`, `DIV`
4	`+`, `-`
5
6	&
7
8	`(NOT) LIKE`, `(NOT) RLIKE`, `=`, `==`, `IS (NOT) DISTINCT FROM`, `<>`, `!=`, `<=`, `<`, `>=`, `>`
9	`(NOT) IN`, `(NOT) BETWEEN AND`
10	`NOT`
11	`AND`
12 (menor)	`OR`

Use parênteses para substituir a precedência padrão. Por exemplo:

a = 1 AND b = 1 OR c = 1       -- Evaluates AND first, then OR.
a = 1 AND (b = 1 OR c = 1)     -- Evaluates OR first (inside parentheses), then AND.