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.

Wenn eine Operation mit niedrigerem Vorrang zuerst verarbeitet werden soll, muss sie in Klammern gesetzt 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"

2. BinaryLogicalOp und Klammern

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

3. TermExpr und UnaryLogicOp

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

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

4. TermExpr, BinaryLogicalOp und CmpOp (für verschiedene Felder)

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

5. BinaryLogicalOp und CmpOp

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

6. CmpOp und UnaryArithOp oder 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)

  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
  

9. 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:

• 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.