Règles de filtrage scalaire

Vue d'ensemble

Une expression de prédicat produit une valeur booléenne. Milvus effectue un filtrage scalaire en effectuant des recherches à l'aide de prédicats. Une expression de prédicat, lorsqu'elle est évaluée, renvoie soit VRAI, soit FAUX. Consultez la référence API du SDK Python pour obtenir des instructions sur l'utilisation des expressions de prédicat.

Les règles de grammaireEBNF décrivent les règles des expressions booléennes :

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 } "]";

Le tableau suivant présente la description de chaque symbole mentionné dans les règles d'expression booléenne ci-dessus.

Notation	Description
=	Définition.
,	Concaténation.
;	Terminaison.
|	Alternance.
{...}	Répétition.
(...)	Groupement.
NUL	Vide. L'expression peut être une chaîne vide.
INTEGER	Entiers tels que 1, 2, 3.
FLOAT	Nombres flottants tels que 1.0, 2.0.
CONST	Entiers ou nombres flottants.
IDENTIFIER	Identifiant. Dans Milvus, l'IDENTIFIER représente le nom du champ.
LogicalOp	Un LogicalOp est un opérateur logique qui permet de combiner plusieurs opérations relationnelles en une seule comparaison. La valeur renvoyée par un LogicalOp est soit VRAI (1), soit FAUX (0). Il existe deux types de LogicalOps : les BinaryLogicalOps et les UnaryLogicalOps.
Op logique unaire	UnaryLogicalOp fait référence à l'opérateur logique unaire "not".
BinaryLogicalOp	Opérateurs logiques binaires qui effectuent des actions sur deux opérandes. Dans une expression complexe comportant deux opérandes ou plus, l'ordre d'évaluation dépend des règles de préséance.
ArithmeticOp	Un ArithmeticOp, c'est-à-dire un opérateur arithmétique, effectue des opérations mathématiques telles que l'addition et la soustraction sur les opérandes.
UnaryArithOp	Un UnaryArithOp est un opérateur arithmétique qui effectue une opération sur un seul opérande. L'UnaryArithOp négatif transforme une expression positive en une expression négative, ou l'inverse.
BinaryArithOp	Un BinaryArithOp, c'est-à-dire un opérateur binaire, effectue des opérations sur deux opérandes. Dans une expression complexe comportant deux opérandes ou plus, l'ordre d'évaluation dépend des règles de préséance.
CmpOp	CmpOp est un opérateur relationnel qui effectue des actions sur deux opérandes.
CmpOpRestricted	CmpOpRestricted est limité à "Inférieur à" et "Egal à".
ConstantExpr	ConstantExpr peut être une constante ou un BinaryArithOp sur deux ConstExpr ou un UnaryArithOp sur un seul ConstantExpr. Elle est définie de manière récursive.
Tableau constant	ConstantArray est entouré de crochets, et ConstantExpr peut être répété dans les crochets. ConstArray doit inclure au moins une ConstantExpr.
TermExpr	TermExpr est utilisé pour vérifier si la valeur d'un IDENTIFIER apparaît dans un tableau constant. TermExpr est représenté par "in".
CompareExpr	Une CompareExpr, c'est-à-dire une expression de comparaison, peut être une opération relationnelle sur deux IDENTIFIER, ou une opération relationnelle sur un IDENTIFIER et un ConstantExpr, ou une opération ternaire sur deux ConstantExpr et un IDENTIFIER.
SingleExpr	SingleExpr, c'est-à-dire une seule expression, peut être soit un TermExpr, soit un CompareExpr.
LogicalExpr	Une LogicalExpr peut être une BinaryLogicalOp sur deux LogicalExprs, ou une UnaryLogicalOp sur une seule LogicalExpr, ou une LogicalExpr groupée entre parenthèses, ou une SingleExpr. Le LogicalExpr est défini de manière récursive.
Expr	Expr, une abréviation signifiant expression, peut être LogicalExpr ou NIL.
MatchOp	Un MatchOp, à savoir un opérateur de correspondance, compare une chaîne de caractères à une constante de chaîne de caractères ou à une constante de préfixe, d'infixe ou de suffixe de chaîne de caractères.
JsonArrayOp	Un JsonOp, c'est-à-dire un opérateur JSON, vérifie si l'identifiant spécifié contient les éléments spécifiés.
ArrayOp	Un ArrayOp, c'est-à-dire un opérateur de tableau, vérifie si l'identifiant spécifié contient les éléments spécifiés.

Opérateurs

Opérateurs logiques

Les opérateurs logiques effectuent une comparaison entre deux expressions.

Symbole	Opération	Exemple	Description
'et' &&	et	expr1 && expr2	Vrai si expr1 et expr2 sont tous deux vrais.
'ou' ||	ou	expr1 || expr2	Vrai si expr1 ou expr2 est vrai.

Opérateurs arithmétiques binaires

Les opérateurs arithmétiques binaires contiennent deux opérandes et peuvent effectuer des opérations arithmétiques de base et renvoyer le résultat correspondant.

Symbole	Opération	Exemple	Description
+	Addition	a + b	Additionne les deux opérandes.
-	Soustraction	a - b	Soustraire le deuxième opérande du premier opérande.
*	Multiplication	a * b	Multiplier les deux opérandes.
/	Division	a / b	Diviser le premier opérande par le second opérande.
**	Puissance	a ** b	Élever le premier opérande à la puissance du second opérande.
%	Modulo	a % b	Divise le premier opérande par le second opérande et donne la partie restante.

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 du symbole
<	Inférieur à	a < b	Vrai si a est inférieur à b.
>	Supérieur à	a > b	Vrai si a est supérieur à b.
==	Égal	a == b	Vrai si a est égal à b.
!=	Non égal	a != b	Vrai si a n'est pas égal à b.
<=	Inférieur ou égal	a <= b	Vrai si a est inférieur ou égal à b.
>=	Supérieur ou égal	a >= b	Vrai si a est supérieur ou égal à b.

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

Le tableau suivant indique la priorité et l'associativité des opérateurs. Les opérateurs sont énumérés de haut en bas, par ordre de préséance décroissante.

Précédence	Opérateur	Description de l'opérateur	Associativité
1	+ -	UnaireArithOp	De gauche à droite
2	non	UnaryLogicOp	De droite à gauche
3	**	BinaryArithOp	De gauche à droite
4	* / %	BinaryArithOp	Gauche à droite
5	+ -	BinaryArithOp	Gauche à droite
6	< <= > >=	CmpOp	De gauche à droite
7	== !=	CmpOp	Gauche-droite
8	comme LIKE	MatchOp	De gauche à droite
9	json_contains JSON_CONTAINS	JsonArrayOp	De gauche à droite
9	array_contains ARRAY_CONTAINS	ArrayOp	De gauche à droite
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	De gauche à droite
10	array_contains_all ARRAY_CONTAINS_ALL	ArrayOp	De gauche à droite
11	json_contains_any JSON_CONTAINS_ANY	JsonArrayOp	De gauche à droite
11	array_contains_any ARRAY_CONTAINS_ANY	ArrayOp	De gauche à droite
12	array_length ARRAY_LENGTH	ArrayOp	De gauche à droite
13	&& et	BinaryLogicOp	De gauche à droite
14	|| ou	BinaryLogicOp	De gauche à droite

Les expressions sont normalement évaluées de gauche à droite. Les expressions complexes sont évaluées une par une. L'ordre dans lequel les expressions sont évaluées est déterminé par la priorité des opérateurs utilisés.

Si une expression contient deux opérateurs ou plus ayant la même priorité, l'opérateur de gauche est évalué en premier.

Lorsqu'une opération de moindre priorité doit être traitée en premier, elle doit être placée entre parenthèses.

Les parenthèses peuvent être imbriquées dans des expressions. Les expressions parenthétiques les plus proches sont évaluées en premier.

Utilisation

Les exemples d'utilisation de toutes les expressions booléennes disponibles dans Milvus sont répertoriés comme suit (int64 représente le champ scalaire qui contient des données de type INT64, float représente le champ scalaire qui contient des données de type virgule flottante, et VARCHAR représente le champ scalaire qui contient des données de type VARCHAR) :

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp et parenthèses

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

3. TermExpr et UnaryLogicOp

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

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

4. TermExpr, BinaryLogicalOp et CmpOp (sur des champs différents)

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

5. BinaryLogicalOp et CmpOp

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

6. CmpOp et 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)

  Si l'expression JSON d'une instruction JSON_CONTAINS (deuxième argument) est une liste, l'identifiant (premier argument) doit être une liste de listes. Sinon, l'instruction est toujours évaluée à 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)

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

  # {"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)

  L'expression JSON dans une déclaration JSON_CONTAINS_ANY doit toujours être une liste. Sinon, elle agit de la même manière 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 l'expression de tableau d'une instruction ARRAY_CONTAINS (deuxième argument) est une liste, l'identificateur (premier argument) doit être une liste de listes. Sinon, l'instruction est toujours évaluée à False.

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

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  L'expression de tableau d'une instruction ARRAY_CONTAINS_ALL doit toujours être une liste.

  # "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)

  L'expression de tableau dans une instruction ARRAY_CONTAINS_ANY doit toujours être une liste. Sinon, elle agit de la même manière 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)

  Vérifiez le nombre d'éléments d'un tableau.

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

Prochaines étapes

Maintenant que vous savez comment fonctionnent les ensembles de bits dans Milvus, vous voudrez peut-être.. :

• Apprendre à effectuer une recherche hybride.
• Apprendre à utiliser des chaînes pour filtrer vos résultats de recherche.
• Apprendre à utiliser des champs dynamiques dans la construction d'expressions booléennes.