Regole di filtraggio scalari

Panoramica

Un'espressione di predicato produce un valore booleano. Milvus esegue il filtraggio scalare cercando con i predicati. Un'espressione di predicato, quando viene valutata, restituisce VERO o FALSO. Per istruzioni sull'uso delle espressioni di predicato, consultare il Python SDK API Reference.

Le regole della grammaticaEBNF descrivono le regole delle espressioni booleane:

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

La tabella seguente elenca la descrizione di ogni simbolo citato nelle regole delle espressioni booleane.

Notazione	Descrizione
=	Definizione.
,	Concatenazione.
;	Terminazione.
|	Alternanza.
{...}	Ripetizione.
(...)	Raggruppamento.
NULLA	Vuoto. L'espressione può essere una stringa vuota.
INTEGRO	Numeri interi come 1, 2, 3.
PIANO	Numeri a virgola mobile come 1.0, 2.0.
CONST	Numeri interi o numeri float.
IDENTIFICATORE	Identificatore. In Milvus, IDENTIFIER rappresenta il nome del campo.
LogicalOp	LogicalOp è un operatore logico che consente di combinare più operazioni relazionali in un unico confronto. Il valore restituito di un LogicalOp è TRUE (1) o FALSE (0). Esistono due tipi di LogicalOp: BinaryLogicalOp e UnaryLogicalOp.
UnaryLogicalOp	UnaryLogicalOp si riferisce all'operatore logico unario "not".
Operatore logico binario	Operatori logici binari che eseguono azioni su due operandi. In un'espressione complessa con due o più operandi, l'ordine di valutazione dipende dalle regole di precedenza.
ArithmeticOp	Un ArithmeticOp, ossia un operatore aritmetico, esegue operazioni matematiche come addizione e sottrazione sugli operandi.
UnaryArithOp	Un UnaryArithOp è un operatore aritmetico che esegue un'operazione su un singolo operando. L'UnaryArithOp negativo trasforma un'espressione positiva in una negativa o viceversa.
ArithOp binario	Un BinaryArithOp, ossia un operatore binario, esegue operazioni su due operandi. In un'espressione complessa con due o più operandi, l'ordine di valutazione dipende dalle regole di precedenza.
CmpOp	CmpOp è un operatore relazionale che esegue azioni su due operandi.
CmpOpRestricted	CmpOpRestricted è limitato a "Meno di" e "Uguale".
CostanteExpr	ConstantExpr può essere una costante o una BinaryArithOp su due ConstExpr o una UnaryArithOp su una singola ConstantExpr. È definita in modo ricorsivo.
Array di costanti	ConstantArray è racchiuso tra parentesi quadre e ConstantExpr può essere ripetuto tra le parentesi quadre. ConstArray deve includere almeno una ConstantExpr.
TermExpr	TermExpr viene utilizzato per verificare se il valore di un IDENTIFIER è presente in un ConstantArray. TermExpr è rappresentato da "in".
ConfrontaExpr	Una CompareExpr, ovvero un'espressione di confronto, può essere costituita da operazioni relazionali su due IDENTIFIER, oppure da operazioni relazionali su un IDENTIFIER e una ConstantExpr, oppure da operazioni ternarie su due ConstantExpr e un IDENTIFIER.
Espressione singola	SingleExpr, cioè un'espressione singola, può essere una TermExpr o una CompareExpr.
Espressioni logiche	Una LogicalExpr può essere una BinaryLogicalOp su due LogicalExpr, o una UnaryLogicalOp su una singola LogicalExpr, o una LogicalExpr raggruppata tra parentesi, o una SingleExpr. La LogicalExpr è definita in modo ricorsivo.
Expr	Expr, un'abbreviazione che significa espressione, può essere LogicalExpr o NIL.
MatchOp	Un MatchOp, ossia un operatore di corrispondenza, confronta una stringa con una costante di stringa o una costante di prefisso, infisso o suffisso di stringa.
JsonArrayOp	Un JsonOp, cioè un operatore JSON, verifica se l'identificatore specificato contiene gli elementi specificati.
ArrayOp	Un ArrayOp, cioè un operatore di array, verifica se l'identificatore specificato contiene gli elementi specificati.

Operatori

Operatori logici

Gli operatori logici eseguono un confronto tra due espressioni.

Simbolo	Operazione	Esempio	Descrizione
'e' &&	e	expr1 && expr2	È vero se sono vere sia expr1 che expr2.
'o' ||	o	expr1 || expr2	È vero se sono vere sia expr1 che expr2.

Operatori aritmetici binari

Gli operatori aritmetici binari contengono due operandi e possono eseguire operazioni aritmetiche di base e restituire il risultato corrispondente.

Simbolo	Operazione	Esempio	Descrizione
+	Addizione	a + b	Aggiunge i due operandi.
-	Sottrazione	a - b	Sottrarre il secondo operando dal primo operando.
*	Moltiplicazione	a * b	Moltiplica i due operandi.
/	Divisione	a / b	Divide il primo operando per il secondo operando.
**	Potenza	a ** b	Eleva il primo operando alla potenza del secondo operando.
%	Modulo	a % b	Divide il primo operando per il secondo operando e restituisce la parte rimanente.

Operatori relazionali

Gli operatori relazionali utilizzano i simboli per verificare l'uguaglianza, la disuguaglianza o l'ordine relativo tra due espressioni.

Simbolo	Operazione	Esempio	Descrizione
<	Meno di	a < b	Vero se a è minore di b.
>	Maggiore di	a > b	Vero se a è maggiore di b.
==	Uguale	a == b	Vero se a è uguale a b.
!=	Non uguale	a = b	Vero se a non è uguale a b.
<=	Meno di o uguale	a <= b	Vero se a è minore o uguale a b.
>=	Maggiore o uguale a	a >= b	Vero se a è maggiore o uguale a b.

Precedenza e associatività degli operatori

La tabella seguente elenca la precedenza e l'associatività degli operatori. Gli operatori sono elencati dall'alto verso il basso, con precedenza decrescente.

Precedenza	Operatore	Descrizione	Associatività
1	+ -	UnarioArithOp	Da sinistra a destra
2	non	UnarioLogicOp	Da destra a sinistra
3	**	BinaryArithOp	Da sinistra a destra
4	* / %	BinaryArithOp	Da sinistra a destra
5	+ -	BinaryArithOp	Da sinistra a destra
6	< <= > >=	CmpOp	Da sinistra a destra
7	== !=	CmpOp	Da sinistra a destra
8	come LIKE	MatchOp	Da sinistra a destra
9	json_contains JSON_CONTAINS	JsonArrayOp	Da sinistra a destra
9	array_contiene ARRAY_CONTAINS	ArrayOp	Da sinistra a destra
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	Da sinistra a destra
10	array_contains_all ARRAY_CONTAINS_ALL	ArrayOp	Da sinistra a destra
11	json_contains_any JSON_CONTAINS_ANY	JsonArrayOp	Da sinistra a destra
11	array_contains_any ARRAY_CONTAINS_ANY	ArrayOp	Da sinistra a destra
12	lunghezza_array ARRAY_LENGTH	ArrayOp	Da sinistra a destra
13	&& e	BinaryLogicOp	Da sinistra a destra
14	|| o	BinaryLogicOp	Da sinistra a destra

Le espressioni vengono normalmente valutate da sinistra a destra. Le espressioni complesse vengono valutate una alla volta. L'ordine di valutazione delle espressioni è determinato dalla precedenza degli operatori utilizzati.

Se un'espressione contiene due o più operatori con la stessa precedenza, l'operatore più a sinistra viene valutato per primo.

Quando un'operazione con precedenza inferiore deve essere elaborata per prima, deve essere racchiusa tra parentesi.

Le parentesi possono essere annidate all'interno delle espressioni. Le espressioni parentetiche più interne vengono valutate per prime.

Utilizzo

Di seguito sono elencati esempi di utilizzo di tutte le espressioni booleane disponibili in Milvus (int64 rappresenta il campo scalare che contiene dati di tipo INT64, float rappresenta il campo scalare che contiene dati di tipo floating-point e VARCHAR rappresenta il campo scalare che contiene dati di tipo VARCHAR):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp e parentesi

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

3. TermExpr e UnaryLogicOp

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

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

4. TermExpr, BinaryLogicalOp e CmpOp (su campi diversi)

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

5. BinaryLogicalOp e CmpOp

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

6. CmpOp e UnaryArithOp o 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)

  Se l'espressione JSON di un'istruzione JSON_CONTAINS (il secondo argomento) è una lista, l'identificatore (il primo argomento) deve essere una lista di liste. Altrimenti, l'istruzione valuta sempre 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'espressione JSON di un'istruzione JSON_CONTAINS_ALL deve sempre essere un elenco.

  # {"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'espressione JSON in un'istruzione JSON_CONTAINS_ANY deve essere sempre un elenco. Altrimenti, si comporta come 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)

  Se l'espressione array di un'istruzione ARRAY_CONTAINS (il secondo argomento) è un elenco, l'identificatore (il primo argomento) deve essere elenco di elenco. Altrimenti, l'istruzione valuta sempre False.

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

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  L'espressione della matrice in un'istruzione ARRAY_CONTAINS_ALL deve sempre essere un elenco.

  # "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'espressione della matrice in un'istruzione ARRAY_CONTAINS_ANY deve essere sempre un elenco. Altrimenti, si comporta come 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)

  Verificare il numero di elementi di una matrice.

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

Cosa succede ora

Ora che sapete come funzionano i bitset in Milvus, potreste anche voler

• Imparare a condurre una ricerca ibrida.
• Imparare a usare le stringhe per filtrare i risultati della ricerca.
• Imparare a utilizzare i campi dinamici nella costruzione di espressioni booleane.