Reglas de expresiones booleanas

En este capítulo se introduce cómo escribir expresiones de condiciones de consulta.

Visión general

Una expresión de predicado produce un valor booleano. Milvus filtra escalares usando predicados. Al evaluar una expresión de predicado, devolverá VERDADERO o FALSO. Por favor, consulta la referencia de la API del SDK de Python para obtener orientación sobre el uso de expresiones de predicado.

Operadores

Operadores lógicos

Los operadores lógicos comparan dos expresiones.

Símbolo	Operación	Ejemplo	Descripción
'and' &&	Y	expr1 && expr2	Devuelve Verdadero cuando tanto expr1 como expr2 son verdaderos.
'or' \|\|	O	expr1 \|\| expr2	Devuelve Verdadero cuando ya sea expr1 o expr2 son verdaderos.

Operadores aritméticos binarios

Los operadores aritméticos binarios toman dos operandos y realizan operaciones aritméticas básicas, devolviendo el resultado correspondiente.

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

Operadores relacionales

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

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

Precedencia de operadores y asociatividad

La siguiente tabla enumera la precedencia y asociatividad de los operadores. Los operadores se enumeran en orden de precedencia de arriba abajo.

Precedencia	Operador	Descripción	Asociatividad
1	+ -	Operadores aritméticos unarios	De izquierda a derecha
2	not	Operador lógico unario	De derecha a izquierda
3	**	Operador aritmético binario	De izquierda a derecha
4	* / %	Operador aritmético binario	De izquierda a derecha
5	+ -	Operador aritmético binario	De izquierda a derecha
6	< <= > >=	Operadores de comparación	De izquierda a derecha
7	== !=	Operadores de comparación	De izquierda a derecha
8	like LIKE	Operador de coincidencia	De izquierda a derecha
9	json_contains JSON_CONTAINS	Operador JsonArray	De izquierda a derecha
10	json_contains_all JSON_CONTAINS_ALL	Operador JsonArray	De izquierda a derecha
11	json_contains_any JSON_CONTAINS_ANY	Operador JsonArray	De izquierda a derecha
12	&& and	Operador lógico binario	De izquierda a derecha
13	\|\| or	Operador lógico binario	De izquierda a derecha

Las expresiones se suelen evaluar de izquierda a derecha. Las expresiones complejas se evalúan una a la vez. El orden de evaluación de las expresiones se determina por la precedencia de los operadores utilizados.

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

Por ejemplo, 10 / 2 * 5 se evaluará como (10 / 2) y el resultado se multiplicará por 5.

Cuando sea necesario dar prioridad a operaciones de menor precedencia, deben ser encerradas entre paréntesis.

Por ejemplo, 30 / 2 + 8. Generalmente se calcula como 30 dividido por 2, y luego se agrega 8 al resultado. Si quieres dividir por 2 + 8, debe escribirse como 30 / (2 + 8).

Los paréntesis pueden anidarse dentro de una expresión. Los paréntesis más internos se evalúan primero. Aquí tienes algunos ejemplos de todas las expresiones booleanas disponibles en Milvus (int64 representa un campo escalar que contiene datos de tipo INT64, float representa un campo escalar que contiene datos de tipo de punto flotante y VARCHAR representa un campo escalar que contiene datos de tipo VARCHAR):

Expresión de comparación

"int64 > 0"

"0 < int64 < 400"

"500 < int64"

VARCHAR > "str1"

Operaciones lógicas y paréntesis

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

Expresión "in"

Milvus solo admite la eliminación de entidades con claves primarias explícitamente definidas, lo cual solo se puede lograr mediante la expresión "in".

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

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

TermExpr, BinaryLogicalOp y CmpOp (en diferentes campos)

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

BinaryLogicalOp y CmpOp

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

CmpOp y UnaryArithOp o BinaryArithOp

"200+300 < int64"

MatchOp (coincidencia de prefijo)

VARCHAR like "prefix%"

JsonArrayOp

JSON_CONTAINS(identifier, JsonExpr)

Si la expresión JSON en el enunciado JSON_CONTAINS (segundo parámetro) es una lista, el identificador (primer parámetro) debería ser una lista de listas. De lo contrario, el enunciado siempre se evalúa como falso.

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

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

JSON_CONTAINS_ALL(identifier, JsonExpr)

La expresión JSON en el enunciado JSON_CONTAINS_ALL siempre debería ser una lista.

json_contains_all(x, [1,2,8]) # ==> verdadero
json_contains_all(x, [4,5,6]) # ==> falso (6 no existe)

JSON_CONTAINS_ANY(identifier, JsonExpr)

La expresión JSON en el enunciado JSON_CONTAINS_ANY siempre debería ser una lista. De lo contrario, su comportamiento es el mismo que el de JSON_CONTAINS.

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

Reglas de expresión booleana de condición de consulta de Milvus