Regras de expressão booleana

Este capítulo apresenta como escrever expressões de condição de consulta.

Visão Geral

Uma expressão de predicado retorna um valor booleano. O Milvus filtra escalares usando predicados. Ao avaliar uma expressão de predicado, o resultado será VERDADEIRO ou FALSO. Consulte a referência da API do Python SDK para orientações sobre o uso de expressões de predicado.

Operadores

Operadores Lógicos

Os operadores lógicos comparam duas expressões.

Símbolo Operação Exemplo Descrição
'and' && E expr1 && expr2 Retorna Verdadeiro quando tanto expr1 quanto expr2 são verdadeiros.
'or' || OU expr1 || expr2 Retorna Verdadeiro quando tanto expr1 quanto expr2 são verdadeiros.

Operadores Aritméticos Binários

Operadores aritméticos binários levam dois operandos e realizam operações aritméticas básicas, retornando o resultado correspondente.

Símbolo Operação Exemplo Descrição
+ Adição a + b Soma os dois operandos juntos.
- Subtração a - b Subtrai o segundo operando do primeiro.
* Multiplicação a * b Multiplica os dois operandos.
/ Divisão a / b Divide o primeiro operando pelo segundo.
** Exponenciação a ** b Eleva o primeiro operando à potência do segundo.
% Módulo a % b Divide o primeiro operando pelo segundo e retorna o resto.

Operadores Relacionais

Operadores relacionais usam símbolos para verificar a igualdade, desigualdade ou ordem relativa entre duas expressões.

Símbolo Operação Exemplo Descrição
< Menor que a < b Retorna Verdadeiro se a é menor que b.
> Maior que a > b Retorna Verdadeiro se a é maior que b.
== Igual a a == b Retorna Verdadeiro se a é igual a b.
!= Diferente de a != b Retorna Verdadeiro se a não é igual a b.
<= Menor ou igual a a <= b Retorna Verdadeiro se a é menor ou igual a b.
>= Maior ou igual a a >= b Retorna Verdadeiro se a é maior ou igual a b.

Precedência de Operadores e Associatividade

A seguinte tabela lista a precedência e associatividade dos operadores. Os operadores são listados em ordem de precedência de cima para baixo.

Precedência Operador Descrição Associatividade
1 + - Operadores aritméticos unários Da esquerda para a direita
2 not Operador lógico unário Da direita para a esquerda
3 ** Operador aritmético binário Da esquerda para a direita
4 * / % Operador aritmético binário Da esquerda para a direita
5 + - Operador aritmético binário Da esquerda para a direita
6 < <= > >= Operadores de comparação Da esquerda para a direita
7 == != Operadores de comparação Da esquerda para a direita
8 like LIKE Operador de correspondência Da esquerda para a direita
9 json_contains JSON_CONTAINS Operador JsonArray Da esquerda para a direita
10 json_contains_all JSON_CONTAINS_ALL Operador JsonArray Da esquerda para a direita
11 json_contains_any JSON_CONTAINS_ANY Operador JsonArray Da esquerda para a direita
12 && and Operador lógico binário Da esquerda para a direita
13 || or Operador lógico binário Da esquerda para a direita

As expressões são tipicamente avaliadas da esquerda para a direita. Expressões complexas são avaliadas uma de cada vez. A ordem de avaliação das expressões é determinada pela precedência dos operadores utilizados.

Se uma expressão contém dois ou mais operadores com a mesma precedência, o operador mais à esquerda é avaliado primeiro.

Por exemplo, 10 / 2 * 5 será avaliado como (10 / 2) e o resultado será multiplicado por 5.

Quando for necessário priorizar operações de menor precedência, elas devem ser colocadas entre parênteses.

Por exemplo, 30 / 2 + 8. Geralmente é calculado como 30 dividido por 2, e depois 8 é adicionado ao resultado. Se desejar dividir por 2 + 8, deve ser escrito como 30 / (2 + 8).

Parênteses podem ser aninhados dentro de uma expressão. Os parênteses mais internos são avaliados primeiro.

Condições de Exemplo

Aqui estão alguns exemplos de todas as expressões booleanas disponíveis no Milvus (int64 representa um campo escalar contendo dados do tipo INT64, float representa um campo escalar contendo dados do tipo de ponto flutuante e VARCHAR representa um campo escalar contendo dados do tipo VARCHAR):

  1. Expressão de comparação
"int64 > 0"

"0 < int64 < 400"

"500 < int64"

VARCHAR > "str1"
  1. Operações lógicas e parênteses
"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"
  1. Expressão in

O Milvus apenas suporta a exclusão de entidades com chaves primárias explicitamente definidas, o que só pode ser alcançado através da expressão termo in.

"int64 not in [1, 2, 3]"

VARCHAR not in ["str1", "str2"]
  1. TermExpr, BinaryLogicalOp e CmpOp (em campos diferentes)
"int64 in [1, 2, 3] and float != 2"
  1. BinaryLogicalOp e CmpOp
"int64 == 0 || int64 == 1 || int64 == 2"
  1. CmpOp e UnaryArithOp ou BinaryArithOp
"200+300 < int64"
  1. MatchOp (coincidência de prefixo)
VARCHAR like "prefix%"
  1. JsonArrayOp

  • JSON_CONTAINS(identificador, JsonExpr)

    Se a expressão JSON na declaração JSON_CONTAINS (segundo parâmetro) for uma lista, o identificador (primeiro parâmetro) deve ser uma lista de listas. Caso contrário, a declaração sempre avalia como False.

json_contains(x, 1) # ==> verdadeiro
json_contains(x, "a") # ==> falso

json_contains(x, [1,2,3]) # ==> verdadeiro
json_contains(x, [3,2,1]) # ==> falso

  • JSON_CONTAINS_ALL(identificador, JsonExpr)

    A expressão JSON na declaração JSON_CONTAINS_ALL deve sempre ser uma lista.

json_contains_all(x, [1,2,8]) # ==> verdadeiro
json_contains_all(x, [4,5,6]) # ==> falso (6 não existe)

  • JSON_CONTAINS_ANY(identificador, JsonExpr)

    A expressão JSON na declaração JSON_CONTAINS_ANY deve sempre ser uma lista. Caso contrário, seu comportamento é o mesmo que JSON_CONTAINS.

json_contains_any(x, [1,2,8]) # ==> verdadeiro
json_contains_any(x, [4,5,6]) # ==> verdadeiro
json_contains_any(x, [6,9]) # ==> falso