Operatori di base

Milvus offre una ricca serie di operatori di base che aiutano a filtrare e interrogare i dati in modo efficiente. Questi operatori consentono di affinare le condizioni di ricerca in base a campi scalari, calcoli numerici, condizioni logiche e altro ancora. Capire come usare questi operatori è fondamentale per creare query precise e massimizzare l'efficienza delle ricerche.

Operatori di confronto

Gli operatori di confronto sono utilizzati per filtrare i dati in base all'uguaglianza, alla disuguaglianza o alla dimensione. Sono applicabili a campi numerici e di testo.

Operatori di confronto supportati:

• == (uguale a)

• != (Non uguale a)

• > (Maggiore di)

• < (minore di)

• >= (Maggiore o uguale a)

• <= (Minore o uguale a)

Esempio 1: Filtrare con Equal To (==)

Si supponga di avere un campo chiamato status e di voler trovare tutte le entità in cui status è "attivo". Si può usare l'operatore di uguaglianza ==:

filter = 'status == "active"'

Esempio 2: Filtro con Not Equal To (!=)

Per trovare le entità in cui status non è "inattivo":

filter = 'status != "inactive"'

Esempio 3: Filtro con Maggiore di (>)

Se si vogliono trovare tutte le entità con un age superiore a 30:

filter = 'age > 30'

Esempio 4: Filtro con meno di

Per trovare le entità in cui price è inferiore a 100:

filter = 'price < 100'

Esempio 5: Filtro con Maggiore o uguale a (>=)

Se si vogliono trovare tutte le entità con rating maggiore o uguale a 4:

filter = 'rating >= 4'

Esempio 6: Filtraggio con meno o uguale a

Per trovare le entità con discount minore o uguale a 10%:

filter = 'discount <= 10'

Operatori di intervallo

Gli operatori di intervallo aiutano a filtrare i dati in base a specifici set o intervalli di valori.

Operatori di intervallo supportati:

• IN: Utilizzati per trovare valori all'interno di un insieme o di un intervallo specifico.

• LIKE: Utilizzati per corrispondere a un modello (soprattutto per i campi di testo). Milvus consente di costruire un indice NGRAM su campi VARCHAR o JSON per accelerare le query di testo. Per maggiori dettagli, consultare NGRAM.

Esempio 1: Utilizzo di IN per la corrispondenza di più valori

Se si desidera trovare tutte le entità in cui color è "rosso", "verde" o "blu":

filter = 'color in ["red", "green", "blue"]'

Questo è utile quando si vuole verificare l'appartenenza a un elenco di valori.

Esempio 2: Uso di LIKE per la corrispondenza dei modelli

L'operatore LIKE è utilizzato per la corrispondenza di modelli nei campi stringa. Può corrispondere a sottostringhe in diverse posizioni all'interno del testo: come prefisso, infisso o suffisso. L'operatore LIKE utilizza il simbolo % come carattere jolly, che può corrispondere a qualsiasi numero di caratteri (compreso lo zero).

Corrispondenza per prefisso (inizia con)

Per eseguire una corrispondenza per prefisso, in cui la stringa inizia con un determinato modello, è possibile posizionare il modello all'inizio e utilizzare % per abbinare tutti i caratteri che lo seguono. Ad esempio, per trovare tutti i prodotti il cui name inizia con "Prod":

filter = 'name LIKE "Prod%"'

Questo corrisponderà a tutti i prodotti il cui nome inizia con "Prod", come "Product A", "Product B", ecc.

Corrispondenza per suffisso (finisce con)

Per una corrispondenza di suffisso, in cui la stringa termina con un determinato modello, inserire il simbolo % all'inizio del modello. Ad esempio, per trovare tutti i prodotti il cui name termina con "XYZ":

filter = 'name LIKE "%XYZ"'

Questo corrisponderà a tutti i prodotti il cui nome termina con "XYZ", come "ProductXYZ", "SampleXYZ", ecc.

Corrispondenza infissa (contiene)

Per eseguire una corrispondenza infissa, in cui il modello può apparire in qualsiasi punto della stringa, è possibile inserire il simbolo % sia all'inizio che alla fine del modello. Ad esempio, per trovare tutti i prodotti il cui name contiene la parola "Pro":

filter = 'name LIKE "%Pro%"'

Questo corrisponde a tutti i prodotti il cui nome contiene la sottostringa "Pro", come "Product", "ProLine" o "SuperPro".

Operatori aritmetici

Gli operatori aritmetici consentono di creare condizioni basate su calcoli che coinvolgono campi numerici.

Operatori aritmetici supportati:

• + (Addizione)

• - (Sottrazione)

• * (Moltiplicazione)

• / (Divisione)

• % (Modulo)

• ** (Esponenziazione)

Esempio 1: Uso del modulo (%)

Per trovare entità in cui id è un numero pari (cioè divisibile per 2):

filter = 'id % 2 == 0'

Esempio 2: Uso dell'esponenziazione (**)

Per trovare entità in cui price elevato a potenza di 2 è maggiore di 1000:

filter = 'price ** 2 > 1000'

Operatori logici

Gli operatori logici sono utilizzati per combinare più condizioni in un'espressione di filtro più complessa. Questi includono AND, OR e NOT.

Operatori logici supportati:

• AND: Combina più condizioni che devono essere tutte vere.

• OR: Combina condizioni in cui almeno una deve essere vera.

• NOT: Annulla una condizione.

Esempio 1: Uso di AND per combinare le condizioni

Per trovare tutti i prodotti in cui price è superiore a 100 e stock è superiore a 50:

filter = 'price > 100 AND stock > 50'

Esempio 2: Uso di OR per combinare le condizioni

Per trovare tutti i prodotti in cui color è "rosso" o "blu":

filter = 'color == "red" OR color == "blue"'

Esempio 3: Utilizzo di NOT per escludere una condizione

Per trovare tutti i prodotti in cui color non è "verde":

filter = 'NOT color == "green"'

Operatori IS NULL e IS NOT NULL

Gli operatori IS NULL e IS NOT NULL sono utilizzati per filtrare i campi in base al fatto che contengano o meno un valore nullo (assenza di dati).

• IS NULL: Identifica le entità in cui un campo specifico contiene un valore nullo, cioè il valore è assente o indefinito.

• IS NOT NULL: Identifica le entità in cui un campo specifico contiene un valore diverso da null, ovvero il campo ha un valore valido e definito.

Campi scalari regolari con valori nulli

Milvus consente di filtrare i campi scalari regolari, come stringhe o numeri, con valori nulli.

Per recuperare le entità in cui il campo description è nullo:

filter = 'description IS NULL'

Per recuperare le entità in cui il campo description non è nullo:

filter = 'description IS NOT NULL'

Per recuperare le entità in cui il campo description non è nullo e il campo price è superiore a 10:

filter = 'description IS NOT NULL AND price > 10'

Campi JSON con valori nulli

Milvus consente di filtrare i campi JSON che contengono valori nulli. Un campo JSON viene trattato come nullo nei seguenti modi:

• L'intero oggetto JSON è esplicitamente impostato su None (null), ad esempio {"metadata": None}.

• Il campo JSON stesso è completamente assente dall'entità.

Per illustrare ulteriormente come Milvus gestisce i campi JSON con valori nulli, si consideri il seguente esempio di dati con un campo JSON metadata:

data = [
  {
      "metadata": {"category": "electronics", "price": 99.99, "brand": "BrandA"},
      "pk": 1,
      "embedding": [0.12, 0.34, 0.56]
  },
  {
      "metadata": None, # Entire JSON object is null
      "pk": 2,
      "embedding": [0.56, 0.78, 0.90]
  },
  {  # JSON field `metadata` is completely missing
      "pk": 3,
      "embedding": [0.91, 0.18, 0.23]
  },
  {
      "metadata": {"category": None, "price": 99.99, "brand": "BrandA"}, # Individual key value is null
      "pk": 4,
      "embedding": [0.56, 0.38, 0.21]
  }
]

Esempio 1: Recuperare le entità i cui metadati sono nulli

Per trovare le entità in cui il campo metadata manca o è esplicitamente impostato su None:

filter = 'metadata IS NULL'

# Example output:
# data: [
#     "{'metadata': None, 'pk': 2}",
#     "{'metadata': None, 'pk': 3}"
# ]

Esempio 2: Recuperare le entità in cui i metadati non sono nulli

Per trovare le entità in cui il campo metadata non è nullo:

filter = 'metadata IS NOT NULL'

# Example output:
# data: [
#     "{'metadata': {'category': 'electronics', 'price': 99.99, 'brand': 'BrandA'}, 'pk': 1}",
#     "{'metadata': {'category': None, 'price': 99.99, 'brand': 'BrandA'}, 'pk': 4}"
# ]

Campi ARRAY con valori nulli

Milvus consente di filtrare i campi ARRAY che contengono valori nulli. Un campo ARRAY viene trattato come nullo nei seguenti modi:

• L'intero campo ARRAY è impostato esplicitamente su Nessuno (null), ad esempio "tags": None.

• Il campo ARRAY è completamente assente dall'entità.

Per illustrare ulteriormente come Milvus gestisce i campi ARRAY con valori nulli, si consideri il seguente esempio di dati con un campo ARRAY tags:

data = [
  {
      "tags": ["pop", "rock", "classic"],
      "ratings": [5, 4, 3],
      "pk": 1,
      "embedding": [0.12, 0.34, 0.56]
  },
  {
      "tags": None,  # Entire ARRAY is null
      "ratings": [4, 5],
      "pk": 2,
      "embedding": [0.78, 0.91, 0.23]
  },
  {  # The tags field is completely missing
      "ratings": [9, 5],
      "pk": 3,
      "embedding": [0.18, 0.11, 0.23]
  }
]

Esempio 1: Recupero delle entità in cui tag è nullo

Per recuperare le entità in cui il campo tags manca o è esplicitamente impostato su None:

filter = 'tags IS NULL'

# Example output:
# data: [
#     "{'tags': None, 'ratings': [4, 5], 'embedding': [0.78, 0.91, 0.23], 'pk': 2}",
#     "{'tags': None, 'ratings': [9, 5], 'embedding': [0.18, 0.11, 0.23], 'pk': 3}"
# ]

Esempio 2: Recuperare le entità in cui tag non è nullo

Per recuperare le entità in cui il campo tags non è nullo:

filter = 'tags IS NOT NULL'

# Example output:
# data: [
#     "{'metadata': {'category': 'electronics', 'price': 99.99, 'brand': 'BrandA'}, 'pk': 1}",
#     "{'metadata': {'category': None, 'price': 99.99, 'brand': 'BrandA'}, 'pk': 4}"
# ]

Suggerimenti sull'uso degli operatori di base con i campi JSON e ARRAY

Gli operatori di base di Milvus sono versatili e possono essere applicati ai campi scalari, ma possono essere utilizzati efficacemente anche con le chiavi e gli indici dei campi JSON e ARRAY.

Ad esempio, se si dispone di un campo product che contiene più chiavi come price, model e tags, fare sempre riferimento direttamente alla chiave:

filter = 'product["price"] > 1000'

Per trovare i record in cui la prima temperatura in un array di temperature registrate supera un determinato valore, utilizzare:

filter = 'history_temperatures[0] > 30'

Conclusione

Milvus offre una serie di operatori di base che consentono di filtrare e interrogare i dati in modo flessibile. Combinando operatori di confronto, di intervallo, aritmetici e logici, è possibile creare potenti espressioni di filtro per restringere i risultati della ricerca e recuperare i dati necessari in modo efficiente.

DOMANDE FREQUENTI

Esiste un limite alla lunghezza dell'elenco di valori corrispondenti nelle condizioni di filtro (ad esempio, filtro='colore in ["rosso", "verde", "blu"]')? Cosa devo fare se l'elenco è troppo lungo?

Zilliz Cloud non impone un limite di lunghezza all'elenco di valori di corrispondenza nelle condizioni di filtro. Tuttavia, un elenco troppo lungo può avere un impatto significativo sulle prestazioni della query. Se la condizione di filtro include un lungo elenco di valori di corrispondenza o un'espressione complessa con molti elementi, si consiglia di utilizzare Filter Templating per migliorare le prestazioni della query.