milvus-logo
LFAI
Home
  • Benutzerhandbuch

Skalare Filterregeln

Übersicht

Ein Prädikatsausdruck gibt einen booleschen Wert aus. Milvus führt eine skalare Filterung durch, indem es mit Prädikaten sucht. Ein Prädikatsausdruck gibt, wenn er ausgewertet wird, entweder TRUE oder FALSE zurück. Eine Anleitung zur Verwendung von Prädikatsausdrücken finden Sie in der Python SDK API-Referenz.

Die Regeln derEBNF-Grammatik beschreiben die Regeln für boolesche Ausdrücke:

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

Die folgende Tabelle enthält die Beschreibung jedes Symbols, das in den obigen Regeln für boolesche Ausdrücke erwähnt wird.

NotationBeschreibung
=Definition.
,Verkettung.
;Beendigung.
|Abwechslung.
{...}Wiederholung.
(...)Gruppierung.
NILLeer. Der Ausdruck kann eine leere Zeichenkette sein.
INTEGERGanzzahlen wie z. B. 1, 2, 3.
FLOATFließkommazahlen wie 1.0, 2.0.
CONSTGanzzahlen oder Gleitkommazahlen.
IDENTIFIERBezeichner. In Milvus stellt der IDENTIFIER den Feldnamen dar.
LogicalOpEin LogicalOp ist ein logischer Operator, der die Kombination von mehr als einer relationalen Operation in einem Vergleich unterstützt. Der Rückgabewert eines LogicalOp ist entweder TRUE (1) oder FALSE (0). Es gibt zwei Arten von LogicalOps, einschließlich BinaryLogicalOps und UnaryLogicalOps.
UnaryLogicalOpUnaryLogicalOp bezieht sich auf den unären logischen Operator "not".
BinaryLogicalOpBinäre logische Operatoren, die Aktionen auf zwei Operanden ausführen. In einem komplexen Ausdruck mit zwei oder mehr Operanden hängt die Reihenfolge der Auswertung von Vorrangregeln ab.
ArithmeticOpEin ArithmeticOp, d. h. ein arithmetischer Operator, führt mathematische Operationen wie Addition und Subtraktion an Operanden durch.
UnaryArithOpEin UnaryArithOp ist ein arithmetischer Operator, der eine Operation mit einem einzigen Operanden durchführt. Der negative UnaryArithOp wandelt einen positiven Ausdruck in einen negativen um oder andersherum.
BinaryArithOpEin BinaryArithOp, also ein binärer Operator, führt Operationen mit zwei Operanden durch. Bei einem komplexen Ausdruck mit zwei oder mehr Operanden hängt die Reihenfolge der Auswertung von den Vorrangregeln ab.
CmpOpCmpOp ist ein relationaler Operator, der Aktionen mit zwei Operanden durchführt.
CmpOpRestrictedCmpOpRestricted ist auf "Kleiner als" und "Gleich" beschränkt.
KonstanteExprConstantExpr kann eine Konstante oder ein BinaryArithOp auf zwei ConstExprs oder ein UnaryArithOp auf einen einzelnen ConstantExpr sein. Er wird rekursiv definiert.
ConstantArrayConstantArray wird von eckigen Klammern umschlossen, und ConstantExpr kann in den eckigen Klammern wiederholt werden. ConstArray muss mindestens einen ConstantExpr enthalten.
TermExprTermExpr wird verwendet, um zu prüfen, ob der Wert eines IDENTIFIER in einem ConstantArray vorkommt. TermExpr wird durch "in" dargestellt.
CompareExprEin CompareExpr, d. h. ein Vergleichsausdruck, kann eine relationale Operation auf zwei IDENTIFIERs, eine relationale Operation auf einen IDENTIFIER und einen ConstantExpr oder eine ternäre Operation auf zwei ConstantExprs und einen IDENTIFIER sein.
EinzelExprSingleExpr, also ein einzelner Ausdruck, kann entweder ein TermExpr oder ein CompareExpr sein.
LogicalExprEin LogicalExpr kann ein BinaryLogicalOp auf zwei LogicalExprs sein, oder ein UnaryLogicalOp auf einen einzelnen LogicalExpr, oder ein LogicalExpr, der in Klammern gruppiert ist, oder ein SingleExpr. Der LogicalExpr wird rekursiv definiert.
ExprExpr, eine Abkürzung für Ausdruck, kann LogicalExpr oder NIL sein.
MatchOpEin MatchOp, d.h. ein Übereinstimmungsoperator, vergleicht eine Zeichenkette mit einer Zeichenkettenkonstante oder einer Präfix-, Infix- oder Suffixkonstante.
JsonArrayOpEin JsonOp, d. h. ein JSON-Operator, prüft, ob der angegebene Bezeichner die angegebenen Elemente enthält.
ArrayOpEin ArrayOp, d. h. ein Array-Operator, prüft, ob der angegebene Bezeichner die angegebenen Elemente enthält.

Operatoren

Logische Operatoren

Logische Operatoren führen einen Vergleich zwischen zwei Ausdrücken durch.

SymbolOperationBeispielBeschreibung
'und' &&undexpr1 && expr2Wahr, wenn sowohl expr1 als auch expr2 wahr sind.
'oder' ||oderexpr1 || expr2Wahr, wenn entweder expr1 oder expr2 wahr sind.

Binäre arithmetische Operatoren

Binäre arithmetische Operatoren enthalten zwei Operanden und können grundlegende arithmetische Operationen durchführen und das entsprechende Ergebnis zurückgeben.

SymbolOperationBeispielBeschreibung
+Additiona + bAddiert die beiden Operanden.
-Subtraktiona - bSubtraktion des zweiten Operanden vom ersten Operanden.
*Multiplikationa * bMultiplikation der beiden Operanden.
/Divisiona / bTeilt den ersten Operanden durch den zweiten Operanden.
**Potenza ** bErhöhen des ersten Operanden mit der Potenz des zweiten Operanden.
%Moduloa % bTeilt den ersten Operanden durch den zweiten Operanden und liefert den Rest.

Relationale Operatoren

Relationale Operatoren verwenden Symbole, um die Gleichheit, Ungleichheit oder relative Reihenfolge zwischen zwei Ausdrücken zu prüfen.

SymbolOperationBeispielBeschreibung
<Kleiner alsa < bWahr, wenn a kleiner als b ist.
>Größer alsa > bWahr, wenn a größer ist als b.
==Gleicha == bWahr, wenn a gleich b ist.
!=Nicht gleicha != bWahr, wenn a nicht gleich b ist.
<=Kleiner als oder gleicha <= bWahr, wenn a kleiner als oder gleich b ist.
>=Größer als oder gleicha >= bWahr, wenn a größer als oder gleich b ist.

Vorrangigkeit und Assoziativität von Operatoren

In der folgenden Tabelle sind die Rangfolge und die Assoziativität der Operatoren aufgeführt. Die Operatoren sind von oben nach unten in absteigender Reihenfolge aufgeführt.

VorrangigkeitOperatorBeschreibungAssoziativität
1+ -UnaryArithOpLinks-nach-Rechts
2nichtUnaryLogicOpRechts-nach-links
3**BinärArithOpLinks-nach-Rechts
4* / %BinärArithOpLinks-nach-Rechts
5+ -BinärArithOpLinks-nach-Rechts
6< <= > >=CmpOpLinks-nach-Rechts
7== !=CmpOpLinks-nach-Rechts
8wie LIKEMatchOpLinks-nach-Rechts
9json_contains JSON_CONTAINSJsonArrayOpLinks-nach-Rechts
9array_beinhaltet ARRAY_CONTAINSArrayOpLinks-nach-Rechts
10json_contains_all JSON_CONTAINS_ALLJsonArrayOpLinks-nach-Rechts
10array_beinhaltet_alle ARRAY_CONTAINS_ALLArrayOpLinks-nach-Rechts
11json_contains_any JSON_CONTAINS_ANYJsonArrayOpLinks-nach-Rechts
11array_beinhaltet_alle ARRAY_CONTAINS_ANYArrayOpLinks-nach-Rechts
12array_Länge ARRAY_LENGTHArrayOpLinks-nach-Rechts
13&& undBinaryLogicOpLinks-nach-Rechts
14|| oderBinaryLogicOpLinks-nach-Rechts

Ausdrücke werden normalerweise von links nach rechts ausgewertet. Komplexe Ausdrücke werden der Reihe nach ausgewertet. Die Reihenfolge, in der die Ausdrücke ausgewertet werden, wird durch den Vorrang der verwendeten Operatoren bestimmt.

Enthält ein Ausdruck zwei oder mehr Operatoren mit demselben Vorrang, wird der Operator auf der linken Seite zuerst ausgewertet.

Zum Beispiel wird 10 / 2 * 5 als (10 / 2) ausgewertet und das Ergebnis mit 5 multipliziert.

Wenn eine Operation mit niedrigerem Vorrang zuerst verarbeitet werden soll, muss sie in Klammern gesetzt werden.

Zum Beispiel: 30 / 2 + 8. Dies wird normalerweise als 30 geteilt durch 2 ausgewertet und dann 8 zum Ergebnis addiert. Wenn Sie durch 2 + 8 dividieren wollen, sollte es als 30 / (2 + 8) geschrieben werden.

Klammern können innerhalb von Ausdrücken verschachtelt werden. Die innersten Klammerausdrücke werden zuerst ausgewertet.

Verwendung

Beispiele für die Verwendung aller verfügbaren booleschen Ausdrücke in Milvus sind im Folgenden aufgeführt (int64 steht für das Skalarfeld, das Daten vom Typ INT64 enthält, float steht für das Skalarfeld, das Daten vom Typ Fließkomma enthält, und VARCHAR steht für das Skalarfeld, das Daten vom Typ VARCHAR enthält):

  1. CmpOp
"int64 > 0"
"0 < int64 < 400"
"500 <= int64 < 1000"
VARCHAR > "str1"
  1. BinaryLogicalOp und Klammern
"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"
  1. TermExpr und UnaryLogicOp
"int64 not in [1, 2, 3]"
VARCHAR not in ["str1", "str2"]
  1. TermExpr, BinaryLogicalOp und CmpOp (für verschiedene Felder)
"int64 in [1, 2, 3] and float != 2"
  1. BinaryLogicalOp und CmpOp
"int64 == 0 || int64 == 1 || int64 == 2"
  1. CmpOp und UnaryArithOp oder 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)

    Wenn der JSON-Ausdruck einer JSON_CONTAINS -Anweisung (das zweite Argument) eine Liste ist, sollte der Bezeichner (das erste Argument) list of list sein. Andernfalls wird die Anweisung immer zu False ausgewertet.

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

    Der JSON-Ausdruck in einer JSON_CONTAINS_ALL -Anweisung sollte immer eine Liste sein.

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

    Der JSON-Ausdruck in einer JSON_CONTAINS_ANY -Anweisung sollte immer eine Liste sein. Andernfalls verhält sich die Anweisung genauso wie 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)

    Wenn der Array-Ausdruck einer ARRAY_CONTAINS -Anweisung (das zweite Argument) eine Liste ist, sollte der Bezeichner (das erste Argument) list of list sein. Andernfalls wird die Anweisung immer zu False ausgewertet.

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

    Der Array-Ausdruck in einer ARRAY_CONTAINS_ALL -Anweisung sollte immer eine Liste sein.

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

    Der Array-Ausdruck in einer ARRAY_CONTAINS_ANY -Anweisung sollte immer eine Liste sein. Andernfalls verhält sich die Anweisung genauso wie 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)

    Überprüfen Sie die Anzahl der Elemente in einem Array.

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

Was kommt als Nächstes?

Jetzt, wo Sie wissen, wie Bitsets in Milvus funktionieren, möchten Sie vielleicht auch:

Übersetzt vonDeepL

Try Managed Milvus for Free

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

Get Started
Feedback

War diese Seite hilfreich?