milvus-logo
LFAI
Home
  • Guide de l'utilisateur

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.

NotationDescription
=Définition.
,Concaténation.
;Terminaison.
|Alternance.
{...}Répétition.
(...)Groupement.
NULVide. L'expression peut être une chaîne vide.
INTEGEREntiers tels que 1, 2, 3.
FLOATNombres flottants tels que 1.0, 2.0.
CONSTEntiers ou nombres flottants.
IDENTIFIERIdentifiant. Dans Milvus, l'IDENTIFIER représente le nom du champ.
LogicalOpUn 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 unaireUnaryLogicalOp fait référence à l'opérateur logique unaire "not".
BinaryLogicalOpOpé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.
ArithmeticOpUn 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.
UnaryArithOpUn 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.
BinaryArithOpUn 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.
CmpOpCmpOp est un opérateur relationnel qui effectue des actions sur deux opérandes.
CmpOpRestrictedCmpOpRestricted est limité à "Inférieur à" et "Egal à".
ConstantExprConstantExpr 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 constantConstantArray est entouré de crochets, et ConstantExpr peut être répété dans les crochets. ConstArray doit inclure au moins une ConstantExpr.
TermExprTermExpr est utilisé pour vérifier si la valeur d'un IDENTIFIER apparaît dans un tableau constant. TermExpr est représenté par "in".
CompareExprUne 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.
SingleExprSingleExpr, c'est-à-dire une seule expression, peut être soit un TermExpr, soit un CompareExpr.
LogicalExprUne 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.
ExprExpr, une abréviation signifiant expression, peut être LogicalExpr ou NIL.
MatchOpUn 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.
JsonArrayOpUn JsonOp, c'est-à-dire un opérateur JSON, vérifie si l'identifiant spécifié contient les éléments spécifiés.
ArrayOpUn 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.

SymboleOpérationExempleDescription
'et' &&etexpr1 && expr2Vrai si expr1 et expr2 sont tous deux vrais.
'ou' ||ouexpr1 || expr2Vrai 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.

SymboleOpérationExempleDescription
+Additiona + bAdditionne les deux opérandes.
-Soustractiona - bSoustraire le deuxième opérande du premier opérande.
*Multiplicationa * bMultiplier les deux opérandes.
/Divisiona / bDiviser le premier opérande par le second opérande.
**Puissancea ** bÉlever le premier opérande à la puissance du second opérande.
%Moduloa % bDivise 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.

SymboleOpérationExempleDescription du symbole
<Inférieur àa < bVrai si a est inférieur à b.
>Supérieur àa > bVrai si a est supérieur à b.
==Égala == bVrai si a est égal à b.
!=Non égala != bVrai si a n'est pas égal à b.
<=Inférieur ou égala <= bVrai si a est inférieur ou égal à b.
>=Supérieur ou égala >= bVrai 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édenceOpérateurDescription de l'opérateurAssociativité
1+ -UnaireArithOpDe gauche à droite
2nonUnaryLogicOpDe droite à gauche
3**BinaryArithOpDe gauche à droite
4* / %BinaryArithOpGauche à droite
5+ -BinaryArithOpGauche à droite
6< <= > >=CmpOpDe gauche à droite
7== !=CmpOpGauche-droite
8comme LIKEMatchOpDe gauche à droite
9json_contains JSON_CONTAINSJsonArrayOpDe gauche à droite
9array_contains ARRAY_CONTAINSArrayOpDe gauche à droite
10json_contains_all JSON_CONTAINS_ALLJsonArrayOpDe gauche à droite
10array_contains_all ARRAY_CONTAINS_ALLArrayOpDe gauche à droite
11json_contains_any JSON_CONTAINS_ANYJsonArrayOpDe gauche à droite
11array_contains_any ARRAY_CONTAINS_ANYArrayOpDe gauche à droite
12array_length ARRAY_LENGTHArrayOpDe gauche à droite
13&& etBinaryLogicOpDe gauche à droite
14|| ouBinaryLogicOpDe 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.

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

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

Par exemple, 30 / 2 + 8. Cette opération est normalement évaluée comme 30 divisé par 2, puis 8 ajouté au résultat. Si vous voulez diviser par 2 + 8, il faut écrire 30 / (2 + 8).

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"
  1. BinaryLogicalOp et parenthèses
"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"
  1. TermExpr et UnaryLogicOp
"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 <= 500+500"
  1. MatchOp
VARCHAR like "prefix%"
VARCHAR like "%suffix"
VARCHAR like "%middle%"
VARCHAR like "_suffix"
  1. 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
    
  1. 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.. :

Traduit parDeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

Cette page a-t - elle été utile ?