Opérateurs de base

Milvus fournit un ensemble riche d'opérateurs de base pour vous aider à filtrer et à interroger efficacement les données. Ces opérateurs vous permettent d'affiner vos conditions de recherche en fonction de champs scalaires, de calculs numériques, de conditions logiques, etc. Il est essentiel de comprendre comment utiliser ces opérateurs pour élaborer des requêtes précises et maximiser l'efficacité de vos recherches.

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour filtrer les données en fonction de l'égalité, de l'inégalité ou de la taille. Ils s'appliquent aux champs numériques et textuels.

Opérateurs de comparaison pris en charge :

• == (égal à)

• != (différent de)

• > (Supérieur à)

• < (inférieur à)

• >= (supérieur ou égal)

• <= (Inférieur ou égal)

Exemple 1 : Filtrage avec Equal To (==)

Supposons que vous disposiez d'un champ nommé status et que vous souhaitiez trouver toutes les entités pour lesquelles status est "actif". Vous pouvez utiliser l'opérateur d'égalité ==:

filter = 'status == "active"'

Exemple 2 : Filtrage avec Not Equal To (!=)

Pour trouver les entités où status n'est pas "inactif" :

filter = 'status != "inactive"'

Exemple 3 : Filtrage avec Greater Than (>)

Pour trouver toutes les entités dont l'adresse age est supérieure à 30 :

filter = 'age > 30'

Exemple 4 : Filtrage avec Less Than

Pour trouver les entités dont le price est inférieur à 100 :

filter = 'price < 100'

Exemple 5 : Filtrage avec une valeur supérieure ou égale à (>=)

Pour trouver toutes les entités dont le site rating est supérieur ou égal à 4 :

filter = 'rating >= 4'

Exemple 6 : Filtrage avec une valeur inférieure ou égale à

Pour trouver les entités dont le site discount est inférieur ou égal à 10 % :

filter = 'discount <= 10'

Opérateurs de plage

Les opérateurs de plage permettent de filtrer les données en fonction d'ensembles ou de plages de valeurs spécifiques.

Opérateurs de plage pris en charge :

• IN: Utilisés pour faire correspondre des valeurs à l'intérieur d'un ensemble ou d'une plage spécifique.

• LIKE: Utilisé pour faire correspondre un modèle (principalement pour les champs de texte). Milvus vous permet de construire un index NGRAM sur les champs VARCHAR ou JSON pour accélérer les requêtes de texte. Pour plus de détails, reportez-vous à NGRAM.

Exemple 1 : Utilisation de IN pour faire correspondre plusieurs valeurs

Si vous souhaitez trouver toutes les entités pour lesquelles color est soit "rouge", soit "vert", soit "bleu" :

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

Cette méthode est utile lorsque vous souhaitez vérifier l'appartenance à une liste de valeurs.

Exemple 2 : utilisation de LIKE pour la recherche de motifs

L'opérateur LIKE est utilisé pour la recherche de motifs dans les champs de type chaîne de caractères. Il peut faire correspondre des sous-chaînes à différentes positions dans le texte : en tant que préfixe, infixe ou suffixe. L'opérateur LIKE utilise le symbole % comme caractère de remplacement, qui peut correspondre à n'importe quel nombre de caractères (y compris zéro).

Correspondance de préfixes (commence par)

Pour effectuer une recherche par préfixe, où la chaîne commence par un motif donné, vous pouvez placer le motif au début et utiliser % pour rechercher tous les caractères qui le suivent. Par exemple, pour trouver tous les produits dont le site name commence par "Prod" :

filter = 'name LIKE "Prod%"'

Cela correspondra à tous les produits dont le nom commence par "Prod", tels que "Produit A", "Produit B", etc.

Correspondance par suffixe (se termine par)

Pour une correspondance par suffixe, lorsque la chaîne se termine par un motif donné, placez le symbole % au début du motif. Par exemple, pour trouver tous les produits dont le site name se termine par "XYZ" :

filter = 'name LIKE "%XYZ"'

Cette recherche portera sur tous les produits dont le nom se termine par "XYZ", tels que "ProductXYZ", "SampleXYZ", etc.

Correspondance infixe (contient)

Pour effectuer une correspondance infixe, où le motif peut apparaître n'importe où dans la chaîne, vous pouvez placer le symbole % au début et à la fin du motif. Par exemple, pour trouver tous les produits dont le site name contient le mot "Pro" :

filter = 'name LIKE "%Pro%"'

Cela correspondra à tous les produits dont le nom contient la sous-chaîne "Pro", comme "Product", "ProLine" ou "SuperPro".

Opérateurs arithmétiques

Les opérateurs arithmétiques vous permettent de créer des conditions basées sur des calculs impliquant des champs numériques.

Opérateurs arithmétiques pris en charge :

• + (Addition)

• - (Soustraction)

• * (Multiplication)

• / (division)

• % (Modulus)

• ** (exponentiation)

Exemple 1 : Utilisation du module (%)

Pour trouver des entités où le id est un nombre pair (c'est-à-dire divisible par 2) :

filter = 'id % 2 == 0'

Exemple 2 : Utilisation de l'exponentiation (**)

Pour trouver les entités où price élevé à la puissance 2 est supérieur à 1000 :

filter = 'price ** 2 > 1000'

Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner plusieurs conditions dans une expression de filtre plus complexe. Ils comprennent AND, OR, et NOT.

Opérateurs logiques pris en charge :

• AND: Combine plusieurs conditions qui doivent toutes être vraies.

• OR: Combine des conditions dont au moins une doit être vraie.

• NOT: Négation d'une condition.

Exemple 1 : Utilisation de AND pour combiner des conditions

Trouver tous les produits pour lesquels price est supérieur à 100 et stock est supérieur à 50 :

filter = 'price > 100 AND stock > 50'

Exemple 2 : Utilisation de OR pour combiner des conditions

Pour trouver tous les produits pour lesquels color est soit "rouge", soit "bleu" :

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

Exemple 3 : Utilisation de NOT pour exclure une condition

Pour trouver tous les produits pour lesquels color n'est pas "vert" :

filter = 'NOT color == "green"'

Opérateurs IS NULL et IS NOT NULL

Les opérateurs IS NULL et IS NOT NULL sont utilisés pour filtrer les champs selon qu'ils contiennent ou non une valeur nulle (absence de données).

• IS NULL: Identifie les entités dont un champ spécifique contient une valeur nulle, c'est-à-dire que la valeur est absente ou indéfinie.

• IS NOT NULL: Identifie les entités dont un champ spécifique contient une valeur autre que null, ce qui signifie que le champ a une valeur valide et définie.

Champs scalaires réguliers avec valeurs nulles

Milvus permet de filtrer les champs scalaires réguliers, tels que les chaînes ou les nombres, avec des valeurs nulles.

Pour extraire les entités dont le champ description est nul :

filter = 'description IS NULL'

Pour récupérer les entités dont le champ description n'est pas nul :

filter = 'description IS NOT NULL'

Pour récupérer les entités dont le champ description n'est pas nul et dont le champ price est supérieur à 10 :

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

Champs JSON avec valeurs nulles

Milvus permet de filtrer les champs JSON qui contiennent des valeurs nulles. Un champ JSON est traité comme nul dans les cas suivants :

• L'objet JSON entier est explicitement défini sur None (nul), par exemple, {"metadata": None}.

• Le champ JSON lui-même est complètement absent de l'entité.

Pour illustrer davantage la manière dont Milvus traite les champs JSON avec des valeurs nulles, examinons l'exemple de données suivant avec un champ 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]
  }
]

Exemple 1 : Récupérer les entités dont les métadonnées sont nulles

Pour trouver les entités dont le champ metadata est soit manquant, soit explicitement défini sur None :

filter = 'metadata IS NULL'

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

Exemple 2 : Recherche des entités dont les métadonnées ne sont pas nulles

Pour trouver les entités dont le champ metadata n'est pas nul :

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

Champs ARRAY avec valeurs nulles

Milvus permet de filtrer les champs ARRAY qui contiennent des valeurs nulles. Un champ ARRAY est traité comme nul dans les cas suivants :

• L'ensemble du champ ARRAY est explicitement défini sur None (nul), par exemple, "tags": None.

• Le champ ARRAY est totalement absent de l'entité.

Pour illustrer davantage la manière dont Milvus traite les champs ARRAY avec des valeurs nulles, examinons l'exemple de données suivant avec un champ 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]
  }
]

Exemple 1 : Récupérer les entités dont les balises sont nulles

Pour extraire les entités dont le champ tags est soit absent, soit explicitement défini sur 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}"
# ]

Exemple 2 : Récupérer les entités dont le champ tags n'est pas nul

Pour récupérer les entités dont le champ tags n'est pas nul :

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

Conseils sur l'utilisation des opérateurs de base avec les champs JSON et ARRAY

Si les opérateurs de base de Milvus sont polyvalents et peuvent être appliqués aux champs scalaires, ils peuvent également être utilisés efficacement avec les clés et les index des champs JSON et ARRAY.

Par exemple, si vous avez un champ product qui contient plusieurs clés comme price, model, et tags, faites toujours référence à la clé directement :

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

Pour trouver les enregistrements dont la première température d'un tableau de températures enregistrées dépasse une certaine valeur, utilisez :

filter = 'history_temperatures[0] > 30'

Conclusion

Milvus propose une gamme d'opérateurs de base qui vous offrent une grande souplesse dans le filtrage et l'interrogation de vos données. En combinant des opérateurs de comparaison, de plage, arithmétiques et logiques, vous pouvez créer des expressions de filtrage puissantes pour réduire les résultats de vos recherches et récupérer efficacement les données dont vous avez besoin.

FAQ

Existe-t-il une limite à la longueur de la liste des valeurs de correspondance dans les conditions de filtrage (par exemple, filter='color in ["red", "green", "blue"]') ? Que faire si la liste est trop longue ?

Zilliz Cloud n'impose pas de limite de longueur à la liste des valeurs de correspondance dans les conditions de filtrage. Si votre condition de filtrage comprend une longue liste de valeurs de correspondance ou une expression complexe avec de nombreux éléments, nous recommandons d'utiliser Filter Templating pour améliorer les performances de la requête.