ESQL suporta vários operadores para tarefas de comparação complexas.
Se desejar usar ESQL para executar uma comparação simples, consulte Operadores de Comparação Simples do ESQL.
Operador BETWEEN .-ASYMMETRIC-. >>-expression--+-----+--BETWEEN--+------------+-----------------> '-NOT-' '-SYMMETRIC--' >--endpoint_1--AND--endpoint_2---------------------------------><
Este operador existe em dois formatos, SYMMETRIC e ASYMMETRIC (que é o padrão se nenhum for especificado). O formato SYMMETRIC é equivalente a:
(source >= boundary1 AND source <= boundary2) OR
(source >= boundary2 AND source <= boundary1)
O formato ASYMMETRIC é equivalente a:
source >= boundary1 AND source <= boundary2
O formato ASYMMETRIC é mais simples, mas retorna apenas o resultado esperado quando o primeiro valor de limite tiver um valor menor do que o segundo valor de limite. Ele é útil apenas quando as expressões de condição de limite são literais.
Se os operandos possuem tipos diferentes, as regras especiais se aplicam. Estas regras são descritas em Casts Implícitos.
O operador EXISTS retorna um valor Booleano que indica se uma função SELECT retornou um ou mais valores (TRUE) ou nenhum (FALSE).Operador EXISTS >>-Operand--(--ListExpression--)-------------------------------><
EXISTS(SELECT * FROM alguma coisa WHERE predicado)
Operador IN .-,---------. V | >>-operand_1--+-----+--IN--(----operand_2-+--)----------------->< '-NOT-'
O resultado será TRUE se o operando esquerdo não for NULL e for igual a um dos operados direitos. O resultado é FALSE se o operando esquerdo não é NULL e não é igual a um ou mais dos operandos à direita, nenhum dos quais possui valores NULL. De outra maneira, o resultado será UNKNOWN. Se os operandos possuem tipos diferentes, as regras especiais se aplicam. Estas regras são descritas em Casts Implícitos.
operand_1 deve ser avaliado como um valor escalar. operand_2 pode ser uma sequência de expressões que retorna os tipos comparáveis com operand_1 ou pode ser uma única expressão que retorna uma LISTA. Se a LISTA for aquela retornada a partir da função SELECT, poderá existir apenas uma única coluna na SelectClause e cada LINHA nessa coluna será comparada com operand_1 para igualdade.
SET OutputRoot.XMLNSC.Top.Result1 = 30 NOT IN(34, 42, 45)
SET OutputRoot.XMLNSC.Top.Result2 = var1 IN(var2, var3, var4);
SET OutputRoot.XMLNSC.Top.Result3 = 42 IN(
SELECT A FROM InputRoot.XMLNSC.Top.a[] AS A);
SET OutputRoot.XMLNSC.Top.Result4 = 42 IN(
LIST{34,36,37,38,39,40,41,42,43,44});
SET OutputRoot.XMLNSC.Top.Result5 = var1 IN(
InputRoot.XMLNSC.Top.test[]);
Operador IS .-TRUE-------. >>-Operando --IS--+-----+--+-FALSE------+---------------------->< '-NOT-' +-INF--------+ +-+INF-------+ +- -INF------+ +-INFINITY---+ +-+INFINITY--+ +- -INFINITY-+ +-NAN--------+ +-NULL-------+ +-NUM--------+ +-NUMBER-----+ '-UNKNOWN----'
O propósito primário do operador IS é testar se um valor é NULL. Não é possível usar o operador de comparação (=) para testar para um valor NULL, porque o resultado da comparação de qualquer valor com NULL é NULL.
Também é possível usar o operando IS para testar valores Booleanos TRUE e FALSE, e para testar valores decimais para valores especiais. Estes valores são denotados por INF, +INF, -INF, NAN (não um número) e NUM (um número válido) em letras minúsculas, maiúsculas ou mistas. As formas alternativas +INFINITY, -INFINITY e NUMBER também são aceitas.
Se aplicado em tipos não-numéricos, o resultado será FALSE.
Operador LIKE >>-origem--+-----+--LIKE--pattern--+--------------------+------>< '-NOT-' '-ESCAPE--EscapeChar-'
O resultado é TRUE se nenhum dos operadores for NULL e o operando source corresponder ao operando padrão. O resultado será FALSE se nenhum dos operadores for NULL e o operando source não corresponder ao operando padrão. De outra maneira, o resultado será UNKNOWN.
O padrão é especificado por uma cadeia na qual os caracteres porcentagem (%) e sublinhado (_) podem ser utilizados para ter significado especial:
Body.Trade.Company LIKE 'I__'
Body.Trade.Company LIKE 'I%'
Para utilizar os caracteres porcentagem e sublinhado nas expressões que devem ser correspondidas, preceda-os com um caractere ESCAPE, que assume como padrão o caractere barra invertida (\).
Por exemplo, o predicado a seguir localiza uma correspondência para IBM_Corp.
Body.Trade.Company LIKE 'IBM\_Corp'
Você pode especificar um caractere de escape diferente, utilizando a cláusula ESCAPE. Por exemplo, você também poderia especificar o exemplo anterior desta maneira:
Body.Trade.Company LIKE
'IBM$_Corp' ESCAPE '$'
O operador SINGULAR retorna um valor booleano TRUE, se a lista possuir exatamente um elemento; caso contrário, retorna FALSE.Operador SINGULAR >>-Operand--(--ListExpression--)-------------------------------><