Regole di espressioni booleane

Questo capitolo introduce come scrivere espressioni di condizioni di query.

Panoramica

Un'espressione predicatoria restituisce un valore booleano. Milvus filtra gli scalari utilizzando predicatori. Quando si valuta un'espressione predicatoria, restituirà TRUE o FALSE. Si prega di fare riferimento al riferimento dell'API del SDK di Python per la guida sull'uso delle espressioni predicatorie.

Operatori

Operatori Logici

Gli operatori logici confrontano due espressioni.

Simbolo Operazione Esempio Descrizione
'and' && AND expr1 && expr2 Restituisce True quando sia expr1 che expr2 sono veri.
'or' || OR expr1 || expr2 Restituisce True quando sia expr1 che expr2 sono veri.

Operatori Aritmetici Binari

Gli operatori aritmetici binari prendono due operandi e eseguono operazioni aritmetiche di base, restituendo il risultato corrispondente.

Simbolo Operazione Esempio Descrizione
+ Addizione a + b Aggiunge i due operandi insieme.
- Sottrazione a - b Sottrae il secondo operando dal primo.
* Moltiplicazione a * b Moltiplica i due operandi.
/ Divisione a / b Divide il primo operando per il secondo.
** Elevazione a potenza a ** b Alza il primo operando alla potenza del secondo.
% Modulo a % b Divide il primo operando per il secondo e restituisce il resto.

Operatori Relazionali

Gli operatori relazionali usano simboli per verificare l'uguaglianza, l'ineguaglianza o l'ordine relativo tra due espressioni.

Simbolo Operazione Esempio Descrizione
< Minore di a < b Restituisce True se a è minore di b.
> Maggiore di a > b Restituisce True se a è maggiore di b.
== Uguale a a == b Restituisce True se a è uguale a b.
!= Diverso da a != b Restituisce True se a non è uguale a b.
<= Minore o uguale a a <= b Restituisce True se a è minore o uguale a b.
>= Maggiore o uguale a a >= b Restituisce True se a è maggiore o uguale a b.

Precedenza e Associatività degli Operatori

La seguente tabella elenca la precedenza e l'associatività degli operatori. Gli operatori sono elencati in ordine di precedenza dall'alto verso il basso.

Precedenza Operatore Descrizione Associatività
1 + - Operatori aritmetici unari Da sinistra a destra
2 not Operatore logico unario Da destra a sinistra
3 ** Operatore aritmetico binario Da sinistra a destra
4 * / % Operatore aritmetico binario Da sinistra a destra
5 + - Operatore aritmetico binario Da sinistra a destra
6 < <= > >= Operatori di confronto Da sinistra a destra
7 == != Operatori di confronto Da sinistra a destra
8 like LIKE Operatore di corrispondenza Da sinistra a destra
9 json_contains JSON_CONTAINS Operatore JsonArray Da sinistra a destra
10 json_contains_all JSON_CONTAINS_ALL Operatore JsonArray Da sinistra a destra
11 json_contains_any JSON_CONTAINS_ANY Operatore JsonArray Da sinistra a destra
12 && and Operatore logico binario Da sinistra a destra
13 || or Operatore logico binario Da sinistra a destra

Le espressioni vengono tipicamente 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, viene valutato prima l'operatore più a sinistra.

Ad esempio, 10 / 2 * 5 verrà valutato come (10 / 2) e il risultato verrà moltiplicato per 5.

Quando è necessario dare priorità a operazioni a minore precedenza, queste dovrebbero essere racchiuse tra parentesi.

Ad esempio, 30 / 2 + 8. Di solito viene calcolato come 30 diviso per 2, e quindi 8 viene aggiunto al risultato. Se si desidera dividere per 2 + 8, dovrebbe essere scritto come 30 / (2 + 8).

Le parentesi possono essere annidate all'interno di un'espressione. Le parentesi più interne vengono valutate per prime.

Esempi di condizioni

Ecco alcuni esempi di tutte le espressioni booleane disponibili in Milvus (int64 rappresenta un campo scalare contenente dati di tipo INT64, float rappresenta un campo scalare contenente dati di tipo floating-point, e VARCHAR rappresenta un campo scalare contenente dati di tipo VARCHAR):

  1. Espressione di confronto
"int64 > 0"

"0 < int64 < 400"

"500 < int64"

VARCHAR > "str1"
  1. Operazioni logiche e parentesi
"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"
  1. Espressione in

Milvus supporta solo l'eliminazione di entità con chiavi primarie esplicitamente definite, che può essere realizzata solo attraverso l'espressione terminale in.

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

VARCHAR not in ["str1", "str2"]
  1. TermExpr, BinaryLogicalOp e CmpOp (su campi diversi)
"int64 in [1, 2, 3] and float != 2"
  1. BinaryLogicalOp e CmpOp
"int64 == 0 || int64 == 1 || int64 == 2"
  1. CmpOp e UnaryArithOp o BinaryArithOp
"200+300 < int64"
  1. MatchOp (corrispondenza prefisso)
VARCHAR like "prefix%"
  1. JsonArrayOp

  • JSON_CONTAINS(identifier, JsonExpr)

    Se l'espressione JSON nella dichiarazione JSON_CONTAINS (secondo parametro) è una lista, l'identificatore (primo parametro) dovrebbe essere una lista di liste. In caso contrario, la dichiarazione viene sempre valutata come Falsa.

json_contains(x, 1) # ==> true
json_contains(x, "a") # ==> false

json_contains(x, [1,2,3]) # ==> true
json_contains(x, [3,2,1]) # ==> false

  • JSON_CONTAINS_ALL(identifier, JsonExpr)

    L'espressione JSON nella dichiarazione JSON_CONTAINS_ALL dovrebbe sempre essere una lista.

json_contains_all(x, [1,2,8]) # ==> true
json_contains_all(x, [4,5,6]) # ==> false (6 non esiste)

  • JSON_CONTAINS_ANY(identifier, JsonExpr)

    L'espressione JSON nella dichiarazione JSON_CONTAINS_ANY dovrebbe sempre essere una lista. Altrimenti, il comportamento è lo stesso di JSON_CONTAINS.

json_contains_any(x, [1,2,8]) # ==> true
json_contains_any(x, [4,5,6]) # ==> true
json_contains_any(x, [6,9]) # ==> false