Regras de filtragem escalar

Síntese

Uma expressão de predicado produz um valor booleano. Milvus conduz a filtragem escalar pesquisando com predicados. Uma expressão de predicado, quando avaliada, devolve TRUE (verdadeiro) ou FALSE (falso). Consulte a Referência da API do Python SDK para obter instruções sobre a utilização de expressões de predicado.

As regras da gramáticaEBNF descrevem as regras das expressões booleanas:

Expr = LogicalExpr | NIL
LogicalExpr = LogicalExpr BinaryLogicalOp LogicalExpr 
              | UnaryLogicalOp LogicalExpr
              | "(" LogicalExpr ")"
              | SingleExpr;
BinaryLogicalOp = "&&" | "and" | "||" | "or";
UnaryLogicalOp = "not";
SingleExpr = TermExpr | CompareExpr;
TermExpr = IDENTIFIER "in" ConstantArray;
Constant = INTEGER | FLOAT
ConstantExpr = Constant
               | ConstantExpr BinaryArithOp ConstantExpr
               | UnaryArithOp ConstantExpr;
                                                          
ConstantArray = "[" ConstantExpr { "," ConstantExpr } "]";
UnaryArithOp = "+" | "-"
BinaryArithOp = "+" | "-" | "*" | "/" | "%" | "**";
CompareExpr = IDENTIFIER CmpOp IDENTIFIER
              | IDENTIFIER CmpOp ConstantExpr
              | ConstantExpr CmpOp IDENTIFIER
              | ConstantExpr CmpOpRestricted IDENTIFIER CmpOpRestricted ConstantExpr;
CmpOpRestricted = "<" | "<=";
CmpOp = ">" | ">=" | "<" | "<=" | "=="| "!=";
MatchOp = "like" | "LIKE";
JsonArrayOps = JsonDefs "(" IDENTIFIER "," JsonExpr | JsonArray ")";
JsonArrayDefs = "json_contains" | "JSON_CONTAINS" 
           | "json_contains_all" | "JSON_CONTAINS_ALL" 
           | "json_contains_any" | "JSON_CONTAINS_ANY";
JsonExpr =  Constant | ConstantArray | STRING | BOOLEAN;
JsonArray = "[" JsonExpr { "," JsonExpr } "]";
ArrayOps = ArrayDefs "(" IDENTIFIER "," ArrayExpr | Array ")";
ArrayDefs = "array_contains" | "ARRAY_CONTAINS" 
           | "array_contains_all" | "ARRAY_CONTAINS_ALL" 
           | "array_contains_any" | "ARRAY_CONTAINS_ANY"
           | "array_length"       | "ARRAY_LENGTH";
ArrayExpr =  Constant | ConstantArray | STRING | BOOLEAN;
Array = "[" ArrayExpr { "," ArrayExpr } "]";

A tabela seguinte lista a descrição de cada símbolo mencionado nas regras de expressão booleana acima.

Notação	Descrição
=	Definição.
,	Concatenação.
;	Terminação.
|	Alternância.
{...}	Repetição.
(...)	Agrupamento.
NIL	Vazio. A expressão pode ser uma cadeia vazia.
INTEGER	Números inteiros como 1, 2, 3.
FLOAT	Números flutuantes, como 1,0, 2,0.
CONST	Números inteiros ou números flutuantes.
IDENTIFICADOR	Identificador. Em Milvus, o IDENTIFIER representa o nome do campo.
LogicalOp	Um LogicalOp é um operador lógico que permite combinar mais do que uma operação relacional numa única comparação. O valor devolvido de uma LogicalOp é VERDADEIRO (1) ou FALSO (0). Existem dois tipos de LogicalOps, incluindo BinaryLogicalOps e UnaryLogicalOps.
UnaryLogicalOp	UnaryLogicalOp refere-se ao operador lógico unário "not".
BinaryLogicalOp	Operadores lógicos binários que executam acções em dois operandos. Numa expressão complexa com dois ou mais operandos, a ordem de avaliação depende das regras de precedência.
ArithmeticOp	Um ArithmeticOp, nomeadamente um operador aritmético, efectua operações matemáticas como a adição e a subtração de operandos.
UnaryArithOp	Um UnaryArithOp é um operador aritmético que efectua uma operação sobre um único operando. O UnaryArithOp negativo transforma uma expressão positiva numa negativa, ou o inverso.
BinaryArithOp	Um BinaryArithOp, nomeadamente um operador binário, efectua operações sobre dois operandos. Numa expressão complexa com dois ou mais operandos, a ordem de avaliação depende das regras de precedência.
CmpOp	CmpOp é um operador relacional que executa acções sobre dois operandos.
CmpOpRestricted	CmpOpRestricted é restrito a "Menor que" e "Igual".
ConstantExpr	ConstantExpr pode ser uma constante ou um BinaryArithOp sobre duas ConstExprs ou um UnaryArithOp sobre uma única ConstantExpr. É definida recursivamente.
ConstantArray	ConstantArray é envolvida por parênteses rectos, e ConstantExpr pode ser repetida entre parênteses rectos. ConstArray deve incluir pelo menos um ConstantExpr.
TermExpr	TermExpr é utilizado para verificar se o valor de um IDENTIFIER aparece numa ConstantArray. TermExpr é representado por "in".
CompareExpr	Uma CompareExpr, ou seja, uma expressão de comparação, pode ser uma operação relacional sobre dois IDENTIFIERs, ou uma operação relacional sobre um IDENTIFIER e uma ConstantExpr, ou uma operação ternária sobre duas ConstantExprs e um IDENTIFIER.
SingleExpr	SingleExpr, ou seja, uma única expressão, pode ser uma TermExpr ou uma CompareExpr.
LogicalExpr	Uma LogicalExpr pode ser uma BinaryLogicalOp sobre duas LogicalExprs, ou uma UnaryLogicalOp sobre uma única LogicalExpr, ou uma LogicalExpr agrupada entre parênteses, ou uma SingleExpr. O LogicalExpr é definido recursivamente.
Expr	Expr, uma abreviatura que significa expressão, pode ser LogicalExpr ou NIL.
MatchOp	Um MatchOp, nomeadamente um operador de correspondência, compara uma cadeia de caracteres com uma constante de cadeia de caracteres ou uma constante de prefixo, infixo ou sufixo de cadeia de caracteres.
JsonArrayOp	Um JsonOp, nomeadamente um operador JSON, verifica se o identificador especificado contém os elementos especificados.
ArrayOp	Um ArrayOp, ou seja, um operador de matriz, verifica se o identificador especificado contém os elementos especificados.

Operadores

Operadores lógicos

Os operadores lógicos efectuam uma comparação entre duas expressões.

Símbolo	Operação	Exemplo de operação	Descrição
'e' &&	e	expr1 && expr2	Verdadeiro se ambas as expressões expr1 e expr2 forem verdadeiras.
'or' ||	ou	expr1 || expr2	Verdadeiro se expr1 ou expr2 forem verdadeiros.

Operadores aritméticos binários

Os operadores aritméticos binários contêm dois operandos e podem efetuar operações aritméticas básicas e devolver o resultado correspondente.

Símbolo	Operação	Exemplo de operação	Descrição
+	Adição	a + b	Adiciona os dois operandos.
-	Subtração	a - b	Subtrair o segundo operando do primeiro operando.
*	Multiplicação	a * b	Multiplicar os dois operandos.
/	Divisão	a / b	Divide o primeiro operando pelo segundo operando.
**	Potência	a ** b	Elevar o primeiro operando à potência do segundo operando.
%	Módulo	a % b	Divide o primeiro operando pelo segundo operando e produz a parte restante.

Operadores relacionais

Os operadores relacionais utilizam 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	Verdadeiro se a for menor que b.
>	Maior que	a > b	Verdadeiro se a for maior do que b.
==	Igual	a == b	Verdadeiro se a for igual a b.
!=	Não é igual	a != b	Verdadeiro se a não for igual a b.
<=	Menor que ou igual	a <= b	Verdadeiro se a for menor ou igual a b.
>=	Maior ou igual	a >= b	Verdadeiro se a for maior ou igual a b.

Precedência e associatividade dos operadores

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

Precedência	Operador	Descrição	Associatividade
1	+ -	UnárioArithOp	Da esquerda para a direita
2	não	UnaryLogicOp	Da direita para a esquerda
3	**	BinaryArithOp	Da esquerda para a direita
4	* / %	BinárioArithOp	Da esquerda para a direita
5	+ -	BinárioArithOp	Da esquerda para a direita
6	< <= > >=	CmpOp	Da esquerda para a direita
7	== !=	CmpOp	Da esquerda para a direita
8	like LIKE	MatchOp	Da esquerda para a direita
9	json_contains JSON_CONTAINS	JsonArrayOp	Da esquerda para a direita
9	array_contains ARRAY_CONTAINS	ArrayOp	Da esquerda para a direita
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	Da esquerda para a direita
10	array_contains_all ARRAY_CONTAINS_ALL	ArrayOp	Da esquerda para a direita
11	json_contains_any JSON_CONTAINS_ANY	JsonArrayOp	Da esquerda para a direita
11	array_contains_any ARRAY_CONTAINS_ANY	ArrayOp	Da esquerda para a direita
12	array_length ARRAY_LENGTH	ArrayOp	Da esquerda para a direita
13	&& e	BinaryLogicOp	Da esquerda para a direita
14	|| ou	BinaryLogicOp	Da esquerda para a direita

As expressões são normalmente avaliadas da esquerda para a direita. As expressões complexas são avaliadas uma de cada vez. A ordem pela qual as expressões são avaliadas é determinada pela precedência dos operadores utilizados.

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

Quando uma operação de precedência inferior deve ser processada em primeiro lugar, deve ser colocada entre parênteses.

Os parênteses podem ser aninhados dentro de expressões. As expressões parentéticas mais internas são avaliadas primeiro.

Utilização

As amostras de todas as utilizações de expressões booleanas disponíveis no Milvus são apresentadas da seguinte forma (int64 representa o campo escalar que contém dados do tipo INT64, float representa o campo escalar que contém dados do tipo vírgula flutuante e VARCHAR representa o campo escalar que contém dados do tipo VARCHAR):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp e parênteses

"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"

3. TermExpr e UnaryLogicOp

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

VARCHAR not in ["str1", "str2"]

4. TermExpr, BinaryLogicalOp e CmpOp (em campos diferentes)

"int64 in [1, 2, 3] and float != 2"

5. BinaryLogicalOp e CmpOp

"int64 == 0 || int64 == 1 || int64 == 2"

6. CmpOp e UnaryArithOp ou BinaryArithOp

"200+300 < int64 <= 500+500"

7. MatchOp

VARCHAR like "prefix%"
VARCHAR like "%suffix"
VARCHAR like "%middle%"
VARCHAR like "_suffix"

8. JsonArrayOp

• JSON_CONTAINS(identifier, JsonExpr)

  Se a expressão JSON de uma instrução JSON_CONTAINS (o segundo argumento) for uma lista, o identificador (o primeiro argumento) deverá ser uma lista de listas. Caso contrário, a declaração é sempre avaliada como False.

  # {"x": [1,2,3]}
  json_contains(x, 1) # ==> true
  json_contains(x, "a") # ==> false
      
  # {"x": [[1,2,3], [4,5,6], [7,8,9]]}
  json_contains(x, [1,2,3]) # ==> true
  json_contains(x, [3,2,1]) # ==> false
  

• JSON_CONTAINS_ALL(identifier, JsonExpr)

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

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_all(x, [1,2,8]) # ==> true
  json_contains_all(x, [4,5,6]) # ==> false 6 is not exists
  

• JSON_CONTAINS_ANY(identifier, JsonExpr)

  A expressão JSON numa declaração JSON_CONTAINS_ANY deve ser sempre uma lista. Caso contrário, actua da mesma forma que JSON_CONTAINS.

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_any(x, [1,2,8]) # ==> true
  json_contains_any(x, [4,5,6]) # ==> true
  json_contains_any(x, [6,9]) # ==> false
  

9. ArrayOp

• ARRAY_CONTAINS(identifier, ArrayExpr)

  Se a expressão de matriz de uma declaração ARRAY_CONTAINS (o segundo argumento) for uma lista, o identificador (o primeiro argumento) deverá ser uma lista de listas. Caso contrário, a declaração é sempre avaliada como False.

  # 'int_array': [1,2,3]
  array_contains(int_array, 1) # ==> true
  array_contains(int_array, "a") # ==> false
  

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  A expressão da matriz numa declaração ARRAY_CONTAINS_ALL deve ser sempre uma lista.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_all(int_array, [1,2,8]) # ==> true
  array_contains_all(int_array, [4,5,6]) # ==> false 6 is not exists
  

• ARRAY_CONTAINS_ANY(identifier, ArrayExpr)

  A expressão de matriz numa declaração ARRAY_CONTAINS_ANY deve ser sempre uma lista. Caso contrário, actua da mesma forma que ARRAY_CONTAINS.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_any(int_array, [1,2,8]) # ==> true
  array_contains_any(int_array, [4,5,6]) # ==> true
  array_contains_any(int_array, [6,9]) # ==> false
  

• ARRAY_LENGTH(identifier)

  Verificar o número de elementos de uma matriz.

  # "int_array": [1,2,3,4,5,7,8]
  array_length(int_array) # ==> 7
  

O que se segue

Agora que já sabe como funcionam os conjuntos de bits no Milvus, também pode querer:

• Aprender a efetuar uma Pesquisa Híbrida.
• Aprender a utilizar cadeias de caracteres para filtrar os resultados da pesquisa.
• Aprender a utilizar campos dinâmicos na construção de expressões booleanas.