Règles des expressions booléennes

Ce chapitre présente comment rédiger des expressions de conditions de requête.

Aperçu

Une expression prédicative renvoie une valeur booléenne. Milvus filtre les scalaires en utilisant des prédicats. Lors de l'évaluation d'une expression prédicative, elle renverra VRAI ou FAUX. Veuillez vous référer à la référence de l'API du SDK Python pour des conseils sur l'utilisation des expressions prédicatives.

Opérateurs

Opérateurs logiques

Les opérateurs logiques comparent deux expressions.

Symbole Opération Exemple Description
'et' && ET expr1 && expr2 Renvoie Vrai lorsque à la fois expr1 et expr2 sont vraies.
'ou' || OU expr1 || expr2 Renvoie Vrai lorsque soit expr1 ou expr2 est vraie.

Opérateurs arithmétiques binaires

Les opérateurs arithmétiques binaires prennent deux opérandes et effectuent des opérations arithmétiques de base, renvoyant le résultat correspondant.

Symbole Opération Exemple Description
+ Addition a + b Additionne les deux opérandes ensemble.
- Soustraction a - b Soustrait le second opérande du premier.
* Multiplication a * b Multiplie les deux opérandes.
/ Division a / b Divise le premier opérande par le second.
** Exponentiation a ** b Soulève le premier opérande à la puissance du second.
% Modulo a % b Divise le premier opérande par le second et renvoie le reste.

Opérateurs relationnels

Les opérateurs relationnels utilisent des symboles pour vérifier l'égalité, l'inégalité, ou l'ordre relatif entre deux expressions.

Symbole Opération Exemple Description
< Inférieur à a < b Renvoie Vrai si a est inférieur à b.
> Supérieur à a > b Renvoie Vrai si a est supérieur à b.
== Égal à a == b Renvoie Vrai si a est égal à b.
!= Non égal à a != b Renvoie Vrai si a n'est pas égal à b.
<= Inférieur ou égal à a <= b Renvoie Vrai si a est inférieur ou égal à b.
>= Supérieur ou égal à a >= b Renvoie Vrai si a est supérieur ou égal à b.

Précédence et associativité des opérateurs

Le tableau suivant liste la précédence et l'associativité des opérateurs. Les opérateurs sont listés dans l'ordre de précédence de haut en bas.

Précédence Opérateur Description Associativité
1 + - Opérateurs arithmétiques unaires De gauche à droite
2 non Opérateur logique unaire De droite à gauche
3 ** Opérateur arithmétique binaire De gauche à droite
4 * / % Opérateur arithmétique binaire De gauche à droite
5 + - Opérateur arithmétique binaire De gauche à droite
6 < <= > >= Opérateurs de comparaison De gauche à droite
7 == != Opérateurs de comparaison De gauche à droite
8 like LIKE Opérateur de correspondance De gauche à droite
9 json_contains JSON_CONTAINS Opérateur JsonArray De gauche à droite
10 json_contains_all JSON_CONTAINS_ALL Opérateur JsonArray De gauche à droite
11 json_contains_any JSON_CONTAINS_ANY Opérateur JsonArray De gauche à droite
12 && and Opérateur logique binaire De gauche à droite
13 || or Opérateur logique binaire De gauche à droite

Les expressions sont généralement évaluées de gauche à droite. Les expressions complexes sont évaluées une par une. L'ordre d'évaluation des expressions est déterminé par la précédence des opérateurs utilisés.

Si une expression contient deux opérateurs ou plus avec la même précédence, l'opérateur le plus à gauche est évalué en premier.

Par exemple, 10 / 2 * 5 sera évalué comme (10 / 2) et le résultat sera multiplié par 5.

Lorsqu'il est nécessaire de prioriser les opérations de moindre précédence, elles doivent être placées entre parenthèses.

Par exemple, 30 / 2 + 8. Il est généralement calculé comme 30 divisé par 2, puis 8 est ajouté au résultat. Si vous voulez diviser par 2 + 8, il devrait être écrit comme 30 / (2 + 8).

Les parenthèses peuvent être imbriquées dans une expression. Les parenthèses les plus internes sont évaluées en premier.

Conditions d'exemple

Voici quelques exemples de toutes les expressions booléennes disponibles dans Milvus (int64 représente un champ scalaire contenant des données de type INT64, float représente un champ scalaire contenant des données de type flottant, et VARCHAR représente un champ scalaire contenant des données de type VARCHAR) :

  1. Expression de comparaison
"int64 > 0"

"0 < int64 < 400"

"500 < int64"

VARCHAR > "str1"
  1. Opérations logiques et parenthèses
"(int64 > 0 && int64 < 400) ou (int64 > 500 && int64 < 1000)"
  1. Expression "in"

Milvus prend uniquement en charge la suppression d'entités avec des clés primaires explicitement définies, ce qui ne peut être réalisé qu'à travers l'expression in.

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

VARCHAR not in ["str1", "str2"]
  1. TermExpr, BinaryLogicalOp et CmpOp (sur des champs différents)
"int64 in [1, 2, 3] and float != 2"
  1. BinaryLogicalOp et CmpOp
"int64 == 0 || int64 == 1 || int64 == 2"
  1. CmpOp et UnaryArithOp ou BinaryArithOp
"200+300 < int64"
  1. MatchOp (correspondance préfixe)
VARCHAR like "prefix%"
  1. JsonArrayOp

  • JSON_CONTAINS(identifier, JsonExpr)

    Si l'expression JSON dans l'instruction JSON_CONTAINS (deuxième paramètre) est une liste, l'identifiant (premier paramètre) doit être une liste de listes. Sinon, l'instruction est toujours évaluée à False.

json_contains(x, 1) # ==> vrai
json_contains(x, "a") # ==> faux

json_contains(x, [1,2,3]) # ==> vrai
json_contains(x, [3,2,1]) # ==> faux

  • JSON_CONTAINS_ALL(identifier, JsonExpr)

    L'expression JSON dans l'instruction JSON_CONTAINS_ALL doit toujours être une liste.

json_contains_all(x, [1,2,8]) # ==> vrai
json_contains_all(x, [4,5,6]) # ==> faux (6 n'existe pas)

  • JSON_CONTAINS_ANY(identifier, JsonExpr)

    L'expression JSON dans l'instruction JSON_CONTAINS_ANY doit toujours être une liste. Sinon, son comportement est le même que JSON_CONTAINS.

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