Reglas de filtrado escalar

Resumen

Una expresión de predicado produce un valor booleano. Milvus realiza el filtrado escalar buscando con predicados. Una expresión predicada, cuando se evalúa, devuelve TRUE o FALSE. Consulte la Referencia de la API del SDK de Python para obtener instrucciones sobre el uso de expresiones de predicado.

Las reglas de la gramáticaEBNF describen las reglas de las expresiones 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 } "]";

La siguiente tabla muestra la descripción de cada símbolo mencionado en las reglas de expresiones booleanas anteriores.

Notación	Descripción
=	Definición.
,	Concatenación.
;	Terminación.
|	Alternancia.
{...}	Repetición.
(...)	Agrupación.
NIL	Vacío. La expresión puede ser una cadena vacía.
INTEGER	Números enteros como 1, 2, 3.
FLOAT	Números flotantes como 1.0, 2.0.
CONST	Números enteros o flotantes.
IDENTIFICADOR	Identificador. En Milvus, el IDENTIFIER representa el nombre del campo.
LogicalOp	Una LogicalOp es un operador lógico que permite combinar más de una operación relacional en una comparación. El valor devuelto por una LogicalOp es TRUE (1) o FALSE (0). Existen dos tipos de LogicalOps: BinaryLogicalOps y UnaryLogicalOps.
UnaryLogicalOp	UnaryLogicalOp hace referencia al operador lógico unario "not".
BinaryLogicalOp	Operadores lógicos binarios que realizan acciones sobre dos operandos. En una expresión compleja con dos o más operandos, el orden de evaluación depende de las reglas de precedencia.
ArithmeticOp	Un ArithmeticOp, es decir, un operador aritmético, realiza operaciones matemáticas como sumas y restas sobre operandos.
UnaryArithOp	Un UnaryArithOp es un operador aritmético que realiza una operación sobre un único operando. El UnaryArithOp negativo cambia una expresión positiva en negativa, o al revés.
BinaryArithOp	Un BinaryArithOp, es decir, un operador binario, realiza operaciones sobre dos operandos. En una expresión compleja con dos o más operandos, el orden de evaluación depende de las reglas de precedencia.
CmpOp	CmpOp es un operador relacional que realiza acciones sobre dos operandos.
CmpOpRestricted	CmpOpRestricted está restringido a "Menor que" e "Igual a".
ConstantExpr	ConstantExpr puede ser una Constante o un BinaryArithOp sobre dos ConstExprs o un UnaryArithOp sobre una única ConstantExpr. Se define de forma recursiva.
ConstantArray	ConstantArray está envuelto por corchetes, y ConstantExpr puede repetirse en los corchetes. ConstArray debe incluir al menos una ConstantExpr.
TermExpr	TermExpr se utiliza para comprobar si el valor de un IDENTIFIER aparece en un ConstantArray. TermExpr se representa mediante "in".
CompareExpr	Una CompareExpr, es decir, una expresión de comparación, puede ser una operación relacional sobre dos IDENTIFIERs, o una operación relacional sobre un IDENTIFIER y una ConstantExpr, o una operación ternaria sobre dos ConstantExprs y un IDENTIFIER.
SingleExpr	SingleExpr, es decir, una única expresión, puede ser un TermExpr o un CompareExpr.
LogicalExpr	Una LogicalExpr puede ser una BinaryLogicalOp sobre dos LogicalExprs, o una UnaryLogicalOp sobre una única LogicalExpr, o una LogicalExpr agrupada entre paréntesis, o una SingleExpr. La LogicalExpr se define de forma recursiva.
Expr	Expr, abreviatura que significa expresión, puede ser LogicalExpr o NIL.
MatchOp	Un MatchOp, es decir, un operador de coincidencia, compara una cadena con una constante de cadena o una constante prefija, infija o sufija de cadena.
JsonArrayOp	Un JsonOp, es decir, un operador JSON, comprueba si el identificador especificado contiene los elementos especificados.
ArrayOp	Un ArrayOp, es decir, un operador de matriz, comprueba si el identificador especificado contiene los elementos especificados.

Operadores

Operadores lógicos

Los operadores lógicos comparan dos expresiones.

Símbolo	Operación	Ejemplo	Descripción
y' &&	y	expr1 && expr2	Verdadero si tanto expr1 como expr2 son verdaderos.
o' ||	o	expr1 || expr2	Verdadero si expr1 o expr2 son verdaderos.

Operadores aritméticos binarios

Los operadores aritméticos binarios contienen dos operandos y pueden realizar operaciones aritméticas básicas y devolver el resultado correspondiente.

Símbolo	Operación	Ejemplo	Descripción
+	Suma	a + b	Suma los dos operandos.
-	Resta	a - b	Restar el segundo operando del primer operando.
*	Multiplicación	a * b	Multiplicar los dos operandos.
/	División	a / b	Divide el primer operando por el segundo operando.
**	Potencia	a ** b	Eleva el primer operando a la potencia del segundo operando.
%	Módulo	a % b	Divide el primer operando por el segundo y devuelve la parte del resto.

Operadores relacionales

Los operadores relacionales utilizan símbolos para comprobar la igualdad, desigualdad u orden relativo entre dos expresiones.

Símbolo	Operación	Ejemplo	Descripción
<	Menor que	a < b	Verdadero si a es menor que b.
>	Mayor que	a > b	Verdadero si a es mayor que b.
==	Igual	a == b	Verdadero si a es igual a b.
!=	No es igual	a != b	Verdadero si a no es igual a b.
<=	Menor o igual que	a <= b	Verdadero si a es menor o igual que b.
>=	Mayor o igual que	a >= b	Verdadero si a es mayor o igual que b.

Precedencia y asociatividad de los operadores

La siguiente tabla muestra la precedencia y asociatividad de los operadores. Los operadores se enumeran de arriba a abajo, en orden descendente de precedencia.

Precedencia	Operador	Descripción	Asociatividad
1	+ -	UnaryArithOp	De izquierda a derecha
2	no	UnaryLogicOp	De derecha a izquierda
3	**	BinaryArithOp	De izquierda a derecha
4	* / %	BinaryArithOp	De izquierda a derecha
5	+ -	BinaryArithOp	De izquierda a derecha
6	< <= > >=	CmpOp	De izquierda a derecha
7	== !=	CmpOp	De izquierda a derecha
8	como LIKE	MatchOp	De izquierda a derecha
9	json_contains JSON_CONTAINS	JsonArrayOp	De izquierda a derecha
9	array_contains ARRAY_CONTAINS	ArrayOp	De izquierda a derecha
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	De izquierda a derecha
10	array_contains_all ARRAY_CONTAINS_ALL	ArrayOp	De izquierda a derecha
11	json_contains_any JSON_CONTAINS_ANY	JsonArrayOp	De izquierda a derecha
11	array_contains_any ARRAY_CONTAINS_ANY	ArrayOp	De izquierda a derecha
12	array_length ARRAY_LENGTH	ArrayOp	De izquierda a derecha
13	&& y	BinaryLogicOp	De izquierda a derecha
14	|| o	BinaryLogicOp	De izquierda a derecha

Las expresiones se evalúan normalmente de izquierda a derecha. Las expresiones complejas se evalúan de una en una. El orden en que se evalúan las expresiones viene determinado por la precedencia de los operadores utilizados.

Si una expresión contiene dos o más operadores con la misma precedencia, se evalúa primero el operador de la izquierda.

Cuando una operación de menor precedencia debe procesarse primero, debe ir entre paréntesis.

Los paréntesis pueden anidarse dentro de expresiones. Las expresiones entre paréntesis más internas se evalúan primero.

Utilización

A continuación se muestran ejemplos del uso de todas las expresiones booleanas disponibles en Milvus (int64 representa el campo escalar que contiene datos de tipo INT64, float representa el campo escalar que contiene datos de tipo coma flotante, y VARCHAR representa el campo escalar que contiene datos de tipo VARCHAR):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp y paréntesis

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

3. TermExpr y UnaryLogicOp

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

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

4. TermExpr, BinaryLogicalOp y CmpOp (en campos diferentes)

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

5. BinaryLogicalOp y CmpOp

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

6. CmpOp y UnaryArithOp o 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)

  Si la expresión JSON de una sentencia JSON_CONTAINS (el segundo argumento) es una lista, el identificador (el primer argumento) debe ser list of list. En caso contrario, la sentencia siempre se evalúa 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)

  La expresión JSON de una sentencia JSON_CONTAINS_ALL debe ser siempre una 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)

  La expresión JSON de una sentencia JSON_CONTAINS_ANY debe ser siempre una lista. De lo contrario, actúa igual 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)

  Si la expresión array de una sentencia ARRAY_CONTAINS (el segundo argumento) es una lista, el identificador (el primer argumento) debe ser list of list. En caso contrario, la sentencia siempre se evalúa como False.

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

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  La expresión de matriz de una sentencia ARRAY_CONTAINS_ALL debe ser siempre una 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)

  La expresión de matriz de una sentencia ARRAY_CONTAINS_ANY debe ser siempre una lista. En caso contrario, actúa igual 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)

  Comprueba el número de elementos de un array.

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

Lo que sigue

Ahora que ya sabe cómo funcionan los conjuntos de bits en Milvus, puede que también quiera

• Aprender a realizar una búsqueda híbrida.
• Aprender a utilizar cadenas para filtrar los resultados de la búsqueda.
• Aprender a utilizar campos dinámicos en la construcción de expresiones booleanas.