Opérateurs de base

Milvus propose un ensemble complet d’opérateurs de base pour vous aider à filtrer et à interroger efficacement vos 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 bien comprendre comment utiliser ces opérateurs pour créer des requêtes précises et optimiser 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 l'opérateur « égal à » (==)

Supposons que vous disposiez d'un champ nommé « status » et que vous souhaitiez rechercher toutes les entités pour lesquelles la valeur de « status » est « active ». Vous pouvez utiliser l'opérateur d'égalité « == » :

filter = 'status == "active"'

Exemple 2 : Filtrage avec l'opérateur « différent de » (!=)

Pour rechercher les entités pour lesquelles status n’est pas « inactif » :

filter = 'status != "inactive"'

Exemple 3 : Filtrage avec « supérieur à » (>)

Si vous souhaitez rechercher toutes les entités dont l’ age est supérieur à 30 :

filter = 'age > 30'

Exemple 4 : Filtrage avec « inférieur à »

Pour rechercher les entités dont la valeur de « price » est inférieure à 100 :

filter = 'price < 100'

Exemple 5 : Filtrage avec « supérieur ou égal à » (>=)

Si vous souhaitez rechercher toutes les entités dont l’ rating est supérieur ou égal à 4 :

filter = 'rating >= 4'

Exemple 6 : Filtrage avec « inférieur ou égal à »

Pour rechercher les entités dont l’ discount est inférieure ou égale à 10 % :

filter = 'discount <= 10'

Opérateurs de plage

Les opérateurs de plage permettent de filtrer les données en fonction d’un ensemble spécifique de valeurs. Milvus prend en charge l’ IN pour les vérifications d’appartenance à un ensemble.

Si vous souhaitez trouver toutes les entités dont l’ color est « rouge », « vert » ou « bleu » :

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

Cela s’avère utile lorsque vous souhaitez vérifier l’appartenance à une liste de valeurs.

Opérateurs de correspondance de motifs

Les opérateurs de correspondance de motifs permettent de filtrer des valeurs de type chaîne de caractères en fonction de motifs avec caractères génériques ou d’expressions régulières.

• LIKE: Permet de faire correspondre des motifs simples avec des caractères génériques sur des valeurs de chaîne. Par exemple, « name LIKE "Prod%" » correspond aux valeurs commençant par « Prod ».

• =~: Permet de faire correspondre une valeur de chaîne à une expression régulière RE2. Par exemple, code =~ "E[0-9]{4}" correspond aux valeurs contenant un code d'erreur tel que E1001.

• !~: Permet d’exclure les valeurs de chaîne qui correspondent à une expression régulière RE2. Cela équivaut à « NOT (field =~ "pattern") ».

Pour rechercher les entités dont la valeur « name » commence par « Prod » :

filter = 'name LIKE "Prod%"'

Pour rechercher les entités dont la valeur « code » contient un code d’erreur tel que « E1001 » :

filter = 'code =~ "E[0-9]{4}"'

Pour exclure les entités dont l’ message commence par DEBUG:

filter = 'message !~ "^DEBUG"'

Pour plus de détails sur le choix entre « LIKE » et les expressions régulières, les types de champs pris en charge, la syntaxe des expressions régulières, les règles d’échappement et les performances, consultez la section « Correspondance de motifs ». Milvus vous permet également de créer un index « NGRAM » sur des champs « VARCHAR » ou des chemins de chaînes JSON afin d’accélérer les filtres de correspondance de motifs éligibles. Pour plus de détails, consultez la section « NGRAM ».

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)

• % (Module)

• ** (Élevation à une puissance)

Exemple 1 : Utilisation du modulo (%)

Pour trouver les entités dont l'id est un nombre pair (c'est-à-dire divisible par 2) :

filter = 'id % 2 == 0'

Exemple 2 : Utilisation de l'élévation à une puissance (**)

Pour trouver les entités pour lesquelles l'price e élevé à la puissance 2 est supérieur à 1 000 :

filter = 'price ** 2 > 1000'

Opérateurs bit à bitCompatible with Milvus 3.0.0+

Les opérateurs bit à bit sont utiles lorsqu’un champ entier code plusieurs indicateurs, tels que des autorisations, des indicateurs de fonctionnalité ou des bits d’état. Vous pouvez utiliser ces opérateurs dans des expressions de filtrage pour vérifier, combiner ou comparer des bits individuels dans une valeur entière.

Pour les champs scalaires, les opérateurs bit à bit s’appliquent aux types de champs entiers, tels que INT8, INT16, INT32 et INT64.

Opérateurs bit à bit pris en charge

Opérateur	Nom	Utilisation typique
&	ET binaire	Vérifie si des bits spécifiques sont activés.
|	OU binaire	Combiner les bits avant la comparaison.
^	XOR binaire	Compare les différences de bits entre deux valeurs.

Exemple : filtrage par bits d'autorisation

Supposons que vous disposiez d'un champ entier nommé « permissions », et que chaque bit de cet entier représente un indicateur d'autorisation :

Indicateur de permission	Valeur binaire
READ	1
WRITE	2
SHARE	4
ADMIN	8

Par exemple, permissions = 5 signifie que les bits READ et SHARE sont activés, car 5 = 1 + 4.

Pour trouver les entités pour lesquelles le bit « SHARE » est activé, utilisez l’opération bit à bit ET (&) :

filter = "(permissions & 4) == 4"

Pour trouver les entités pour lesquelles l’activation du bit « WRITE » produit l’ensemble de permissions « READ + WRITE + SHARE », utilisez l’opération bit à bit OR (|) :

filter = "(permissions | 2) == 7"

Pour rechercher les entités dont les bits d’autorisation ne diffèrent de « READ + WRITE + SHARE » que par le bit « WRITE », utilisez l’opération XOR bit à bit (^) :

filter = "(permissions ^ 7) == 2"

Opérateurs logiques

Les opérateurs logiques permettent de combiner plusieurs conditions pour former une expression de filtrage plus complexe. Il s'agit notamment de 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: Nie une condition.

Exemple 1 : Utilisation de « AND » pour combiner des conditions

Pour rechercher tous les produits dont la valeur « price » est supérieure à 100 et dont la valeur « stock » est supérieure à 50 :

filter = 'price > 100 AND stock > 50'

Exemple 2 : Utilisation de « OR » pour combiner des conditions

Pour rechercher tous les produits dont la couleur ( color ) est soit « rouge », soit « bleu » :

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

Exemple 3 : Utilisation de « NOT » pour exclure une condition

Pour rechercher tous les produits dont l’ 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 » permettent de filtrer les champs en fonction de la présence ou non d’une valeur nulle (absence de données).

• IS NULL: Identifie les entités pour lesquelles un champ spécifique contient une valeur nulle, c'est-à-dire que la valeur est absente ou non dé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 possède une valeur valide et définie.

Champs scalaires classiques avec des valeurs null

Milvus permet d’effectuer des filtrages sur des champs scalaires classiques, tels que des chaînes de caractères ou des nombres, comportant des valeurs nulles.

Pour récupérer les entités pour lesquelles le champ « description » est nul :

filter = 'description IS NULL'

Pour récupérer les entités pour lesquelles le champ « description » n’est pas nul :

filter = 'description IS NOT NULL'

Pour récupérer les entités pour lesquelles le champ « description » n’est pas nul et le champ « price » est supérieur à 10 :

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

Champs JSON avec des valeurs nulles

Milvus permet de filtrer les champs JSON contenant des valeurs nulles. Un champ JSON est considéré comme nul dans les cas suivants :

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

• Le champ JSON lui-même est totalement absent de l’entité.

Pour illustrer plus en détail la manière dont Milvus gère les champs JSON contenant des valeurs nulles, prenons l’exemple 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 rechercher 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 : récupérer les entités dont les métadonnées ne sont pas nulles

Pour rechercher 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 contenant des valeurs nulles

Milvus permet de filtrer les champs de type ARRAY contenant des valeurs nulles. Un champ de type ARRAY est considéré comme nul dans les cas suivants :

• Le champ ARRAY entier est explicitement défini sur None (null), par exemple : ` "tags": None`.

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

Pour illustrer plus en détail la manière dont Milvus gère les champs de type ARRAY contenant des valeurs nulles, considérons l’exemple de données suivant avec un champ de type 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 pour lesquelles le champ « tags » est nul

Pour récupérer les entités pour lesquelles le champ « tags » est soit manquant, 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 pour lesquelles « 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 d’utilisation des opérateurs de base avec les champs JSON et ARRAY

Bien que les opérateurs de base de Milvus soient polyvalents et puissent être appliqués à des 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 disposez d’un champ « product » contenant plusieurs clés telles que « price », « model » et « tags », référencez toujours la clé directement :

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

Pour rechercher 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 flexibilité pour filtrer et interroger vos données. En combinant des opérateurs de comparaison, de plage, arithmétiques et logiques, vous pouvez créer de puissantes expressions de filtrage pour affiner vos résultats de recherche et récupérer efficacement les données dont vous avez besoin.

FAQ

Y a-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 dois-je faire si la liste est trop longue ?

Zilliz Cloud n’impose aucune limite de longueur à la liste des valeurs de correspondance dans les conditions de filtrage. Cependant, une liste trop longue peut avoir un impact significatif sur les performances des requêtes. Si votre condition de filtrage comprend une longue liste de valeurs de correspondance ou une expression complexe comportant de nombreux éléments, nous vous recommandons d’utiliser les modèles de filtrage afin d’améliorer les performances des requêtes.