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.
Notation | Beschreibung |
---|---|
= | Definition. |
, | Verkettung. |
; | Beendigung. |
| | Abwechslung. |
{...} | Wiederholung. |
(...) | Gruppierung. |
NIL | Leer. Der Ausdruck kann eine leere Zeichenkette sein. |
INTEGER | Ganzzahlen wie z. B. 1, 2, 3. |
FLOAT | Fließkommazahlen wie 1.0, 2.0. |
CONST | Ganzzahlen oder Gleitkommazahlen. |
IDENTIFIER | Bezeichner. In Milvus stellt der IDENTIFIER den Feldnamen dar. |
LogicalOp | Ein 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. |
UnaryLogicalOp | UnaryLogicalOp bezieht sich auf den unären logischen Operator "not". |
BinaryLogicalOp | Binä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. |
ArithmeticOp | Ein ArithmeticOp, d. h. ein arithmetischer Operator, führt mathematische Operationen wie Addition und Subtraktion an Operanden durch. |
UnaryArithOp | Ein 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. |
BinaryArithOp | Ein 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. |
CmpOp | CmpOp ist ein relationaler Operator, der Aktionen mit zwei Operanden durchführt. |
CmpOpRestricted | CmpOpRestricted ist auf "Kleiner als" und "Gleich" beschränkt. |
KonstanteExpr | ConstantExpr kann eine Konstante oder ein BinaryArithOp auf zwei ConstExprs oder ein UnaryArithOp auf einen einzelnen ConstantExpr sein. Er wird rekursiv definiert. |
ConstantArray | ConstantArray wird von eckigen Klammern umschlossen, und ConstantExpr kann in den eckigen Klammern wiederholt werden. ConstArray muss mindestens einen ConstantExpr enthalten. |
TermExpr | TermExpr wird verwendet, um zu prüfen, ob der Wert eines IDENTIFIER in einem ConstantArray vorkommt. TermExpr wird durch "in" dargestellt. |
CompareExpr | Ein 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. |
EinzelExpr | SingleExpr, also ein einzelner Ausdruck, kann entweder ein TermExpr oder ein CompareExpr sein. |
LogicalExpr | Ein 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. |
Expr | Expr, eine Abkürzung für Ausdruck, kann LogicalExpr oder NIL sein. |
MatchOp | Ein MatchOp, d.h. ein Übereinstimmungsoperator, vergleicht eine Zeichenkette mit einer Zeichenkettenkonstante oder einer Präfix-, Infix- oder Suffixkonstante. |
JsonArrayOp | Ein JsonOp, d. h. ein JSON-Operator, prüft, ob der angegebene Bezeichner die angegebenen Elemente enthält. |
ArrayOp | Ein 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.
Symbol | Operation | Beispiel | Beschreibung |
---|---|---|---|
'und' && | und | expr1 && expr2 | Wahr, wenn sowohl expr1 als auch expr2 wahr sind. |
'oder' || | oder | expr1 || expr2 | Wahr, 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.
Symbol | Operation | Beispiel | Beschreibung |
---|---|---|---|
+ | Addition | a + b | Addiert die beiden Operanden. |
- | Subtraktion | a - b | Subtraktion des zweiten Operanden vom ersten Operanden. |
* | Multiplikation | a * b | Multiplikation der beiden Operanden. |
/ | Division | a / b | Teilt den ersten Operanden durch den zweiten Operanden. |
** | Potenz | a ** b | Erhöhen des ersten Operanden mit der Potenz des zweiten Operanden. |
% | Modulo | a % b | Teilt 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.
Symbol | Operation | Beispiel | Beschreibung |
---|---|---|---|
< | Kleiner als | a < b | Wahr, wenn a kleiner als b ist. |
> | Größer als | a > b | Wahr, wenn a größer ist als b. |
== | Gleich | a == b | Wahr, wenn a gleich b ist. |
!= | Nicht gleich | a != b | Wahr, wenn a nicht gleich b ist. |
<= | Kleiner als oder gleich | a <= b | Wahr, wenn a kleiner als oder gleich b ist. |
>= | Größer als oder gleich | a >= b | Wahr, 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.
Vorrangigkeit | Operator | Beschreibung | Assoziativität |
---|---|---|---|
1 | + - | UnaryArithOp | Links-nach-Rechts |
2 | nicht | UnaryLogicOp | Rechts-nach-links |
3 | ** | BinärArithOp | Links-nach-Rechts |
4 | * / % | BinärArithOp | Links-nach-Rechts |
5 | + - | BinärArithOp | Links-nach-Rechts |
6 | < <= > >= | CmpOp | Links-nach-Rechts |
7 | == != | CmpOp | Links-nach-Rechts |
8 | wie LIKE | MatchOp | Links-nach-Rechts |
9 | json_contains JSON_CONTAINS | JsonArrayOp | Links-nach-Rechts |
9 | array_beinhaltet ARRAY_CONTAINS | ArrayOp | Links-nach-Rechts |
10 | json_contains_all JSON_CONTAINS_ALL | JsonArrayOp | Links-nach-Rechts |
10 | array_beinhaltet_alle ARRAY_CONTAINS_ALL | ArrayOp | Links-nach-Rechts |
11 | json_contains_any JSON_CONTAINS_ANY | JsonArrayOp | Links-nach-Rechts |
11 | array_beinhaltet_alle ARRAY_CONTAINS_ANY | ArrayOp | Links-nach-Rechts |
12 | array_Länge ARRAY_LENGTH | ArrayOp | Links-nach-Rechts |
13 | && und | BinaryLogicOp | Links-nach-Rechts |
14 | || oder | BinaryLogicOp | Links-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):
- CmpOp
"int64 > 0"
"0 < int64 < 400"
"500 <= int64 < 1000"
VARCHAR > "str1"
- BinaryLogicalOp und Klammern
"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"
- TermExpr und UnaryLogicOp
"int64 not in [1, 2, 3]"
VARCHAR not in ["str1", "str2"]
- TermExpr, BinaryLogicalOp und CmpOp (für verschiedene Felder)
"int64 in [1, 2, 3] and float != 2"
- BinaryLogicalOp und CmpOp
"int64 == 0 || int64 == 1 || int64 == 2"
- CmpOp und UnaryArithOp oder BinaryArithOp
"200+300 < int64 <= 500+500"
- MatchOp
VARCHAR like "prefix%"
VARCHAR like "%suffix"
VARCHAR like "%middle%"
VARCHAR like "_suffix"
- 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 wieJSON_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
- 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 wieARRAY_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:
- Lernen Sie, wie man eine Hybrid-Suche durchführt.
- Lernen Sie, wie Sie Strings zum Filtern Ihrer Suchergebnisse verwenden können.
- Lernen Sie, wie man dynamische Felder bei der Erstellung boolescher Ausdrücke verwendet.