Operadores básicos

Milvus ofrece un amplio conjunto de operadores básicos que te ayudan a filtrar y consultar datos de forma eficiente. Estos operadores te permiten refinar tus condiciones de búsqueda basándote en campos escalares, cálculos numéricos, condiciones lógicas y mucho más. Comprender cómo utilizar estos operadores es fundamental para crear consultas precisas y maximizar la eficiencia de tus búsquedas.

Operadores de comparación

Los operadores de comparación se utilizan para filtrar datos en función de la igualdad, la desigualdad o el tamaño. Se pueden aplicar a campos numéricos y de texto.

Operadores de comparación admitidos

• == (Igual a)

• != (No igual a)

• > (Mayor que)

• < (Menor que)

• >= (Mayor o igual que)

• <= (Menor o igual que)

Ejemplo 1: Filtrar con «igual a» (==)

Supongamos que tienes un campo llamado « status » y quieres encontrar todas las entidades en las que « status » sea «active». Puedes utilizar el operador de igualdad « == »:

filter = 'status == "active"'

Ejemplo 2: Filtrado con «no igual a» (!=)

Para encontrar entidades en las que status no sea «inactive»:

filter = 'status != "inactive"'

Ejemplo 3: Filtrar con «mayor que» (>)

Si quieres buscar todas las entidades con un age mayor que 30:

filter = 'age > 30'

Ejemplo 4: Filtrar con «menor que»

Para encontrar entidades en las que price sea menor que 100:

filter = 'price < 100'

Ejemplo 5: Filtrar con «mayor o igual que» (>=)

Si quieres buscar todas las entidades con un « rating » mayor o igual a 4:

filter = 'rating >= 4'

Ejemplo 6: Filtrar con «menor o igual que»

Para encontrar entidades con un « discount » menor o igual al 10 %:

filter = 'discount <= 10'

Operadores de rango

Los operadores de rango ayudan a filtrar datos en función de un conjunto específico de valores. Milvus admite el operador « IN » para comprobar la pertenencia a un conjunto.

Si quieres encontrar todas las entidades en las que el « color » sea «rojo», «verde» o «azul»:

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

Esto resulta útil cuando se desea comprobar la pertenencia a una lista de valores.

Operadores de coincidencia de patrones

Los operadores de coincidencia de patrones ayudan a filtrar valores de cadena basándose en patrones con comodines o expresiones regulares.

• LIKE: Se utiliza para buscar coincidencias con patrones de comodines sencillos en valores de cadena. Por ejemplo, « name LIKE "Prod%" » encuentra valores que empiezan por « Prod ».

• =~: Se utiliza para buscar coincidencias entre un valor de cadena y una expresión regular RE2. Por ejemplo, « code =~ "E[0-9]{4}" » coincide con valores que contienen un código de error como « E1001 ».

• !~: Se utiliza para excluir valores de cadena que coincidan con una expresión regular RE2. Esto equivale a « NOT (field =~ "pattern") ».

Para buscar entidades en las que « name » comience por « Prod »:

filter = 'name LIKE "Prod%"'

Para buscar entidades cuyo « code » contenga un código de error como « E1001 »:

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

Para excluir entidades cuyo « message » comience por « DEBUG »:

filter = 'message !~ "^DEBUG"'

Para obtener más detalles sobre cómo elegir entre « LIKE » y expresiones regulares, los tipos de campo compatibles, la sintaxis de las expresiones regulares, las reglas de escape y el rendimiento, consulta «Coincidencia de patrones». Milvus también te permite crear un índice « NGRAM » en campos « VARCHAR » o rutas de cadenas JSON para acelerar los filtros de coincidencia de patrones elegibles. Para más detalles, consulta «NGRAM».

Operadores aritméticos

Los operadores aritméticos le permiten crear condiciones basadas en cálculos que involucran campos numéricos.

Operadores aritméticos admitidos

• + (Suma)

• - (Resta)

• * (Multiplicación)

• / (División)

• % (Módulo)

• ** (Elevado a una potencia)

Ejemplo 1: Uso del módulo (%)

Para hallar los elementos en los que el id es un número par (es decir, divisible por 2):

filter = 'id % 2 == 0'

Ejemplo 2: Uso de la elevación a una potencia (**)

Para encontrar entidades en las que price elevado a la potencia de 2 sea mayor que 1000:

filter = 'price ** 2 > 1000'

Operadores bit a bitCompatible with Milvus 3.0.0+

Los operadores bit a bit resultan útiles cuando un campo entero codifica múltiples indicadores, como permisos, indicadores de características o bits de estado. Puedes utilizar estos operadores en expresiones de filtro para comprobar, combinar o comparar bits individuales de un valor entero.

En el caso de los campos escalares, los operadores bit a bit se aplican a tipos de campo enteros, como INT8, INT16, INT32 y INT64.

Operadores bit a bit admitidos

Operador	Nombre	Uso típico
&	Y bit a bit	Comprueba si están activados determinados bits.
|	OR bit a bit	Combina los bits antes de la comparación.
^	XOR bit a bit	Compara las diferencias de bits entre dos valores.

Ejemplo: Filtrado por bits de permiso

Supongamos que tienes un campo entero llamado « permissions », y que cada bit del entero representa un indicador de permiso:

Indicador de permiso	Valor del bit
READ	1
WRITE	2
SHARE	4
ADMIN	8

Por ejemplo, « permissions = 5 » significa que los bits « READ » y « SHARE » están activados, ya que « 5 = 1 + 4 ».

Para encontrar entidades en las que esté activado el bit « SHARE », utiliza el operador AND bit a bit (&):

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

Para encontrar entidades en las que al activar el bit « WRITE » se obtenga el conjunto de permisos « READ + WRITE + SHARE », utiliza el operador OR bit a bit (|):

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

Para buscar entidades cuyos bits de permiso difieran de « READ + WRITE + SHARE » únicamente en el bit « WRITE », utiliza el operador XOR bit a bit (^):

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

Operadores lógicos

Los operadores lógicos se utilizan para combinar varias condiciones en una expresión de filtro más compleja. Entre ellos se incluyen AND, OR y NOT.

Operadores lógicos admitidos

• AND: Combina varias condiciones que deben ser todas verdaderas.

• OR: Combina condiciones de las que al menos una debe ser verdadera.

• NOT: Niega una condición.

Ejemplo 1: Uso de « AND » para combinar condiciones

Para encontrar todos los productos en los que « price » sea mayor que 100 y « stock » sea mayor que 50:

filter = 'price > 100 AND stock > 50'

Ejemplo 2: Uso de « OR » para combinar condiciones

Para buscar todos los productos en los que color sea «rojo» o «azul»:

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

Ejemplo 3: Uso de « NOT » para excluir una condición

Para buscar todos los productos en los que « color » no sea «verde»:

filter = 'NOT color == "green"'

Operadores IS NULL e IS NOT NULL

Los operadores « IS NULL » y « IS NOT NULL » se utilizan para filtrar campos en función de si contienen un valor nulo (ausencia de datos).

• IS NULL: Identifica las entidades en las que un campo específico contiene un valor nulo, es decir, el valor está ausente o no está definido.

• IS NOT NULL: Identifica las entidades en las que un campo específico contiene cualquier valor que no sea nulo, lo que significa que el campo tiene un valor válido y definido.

Campos escalares normales con valores nulos

Milvus permite filtrar en campos escalares normales, como cadenas o números, con valores nulos.

Para recuperar entidades en las que el campo description sea nulo:

filter = 'description IS NULL'

Para recuperar entidades en las que el campo « description » no sea nulo:

filter = 'description IS NOT NULL'

Para recuperar entidades en las que el campo « description » no sea nulo y el campo « price » sea superior a 10:

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

Campos JSON con valores nulos

Milvus permite filtrar por campos JSON que contengan valores nulos. Un campo JSON se considera nulo en los siguientes casos:

• El objeto JSON completo se establece explícitamente en None (nulo), por ejemplo, {"metadata": None}.

• El propio campo JSON no aparece en absoluto en la entidad.

Para ilustrar mejor cómo gestiona Milvus los campos JSON con valores nulos, consideremos los siguientes datos de ejemplo 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]
  }
]

Ejemplo 1: Recuperar entidades en las que los metadatos sean nulos

Para encontrar entidades en las que el campo metadata falte o esté establecido explícitamente en None:

filter = 'metadata IS NULL'

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

Ejemplo 2: Recuperar entidades en las que los metadatos no sean nulos

Para buscar entidades en las que el campo « metadata » no sea nulo:

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

Campos ARRAY con valores nulos

Milvus permite filtrar campos ARRAY que contengan valores nulos. Un campo ARRAY se considera nulo en los siguientes casos:

• Todo el campo ARRAY se establece explícitamente en None (nulo), por ejemplo, "tags": None.

• El campo ARRAY no aparece en absoluto en la entidad.

Para ilustrar mejor cómo gestiona Milvus los campos ARRAY con valores nulos, considere los siguientes datos de ejemplo 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]
  }
]

Ejemplo 1: Recuperar entidades en las que «tags» sea nulo

Para recuperar entidades en las que el campo « tags » no existe o está establecido explícitamente como « 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}"
# ]

Ejemplo 2: Recuperar entidades en las que «tags» no sea nulo

Para recuperar entidades en las que el campo « tags » no sea nulo:

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

Consejos para utilizar operadores básicos con campos JSON y ARRAY

Aunque los operadores básicos de Milvus son versátiles y pueden aplicarse a campos escalares, también pueden utilizarse de forma eficaz con las claves y los índices de los campos JSON y ARRAY.

Por ejemplo, si tienes un campo « product » que contiene varias claves como « price », « model » y « tags », haz siempre referencia directa a la clave:

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

Para buscar registros en los que la primera temperatura de una matriz de temperaturas registradas supere un valor determinado, utiliza:

filter = 'history_temperatures[0] > 30'

Conclusión

Milvus ofrece una serie de operadores básicos que te proporcionan flexibilidad a la hora de filtrar y consultar tus datos. Combinando operadores de comparación, de rango, aritméticos y lógicos, puedes crear potentes expresiones de filtro para acotar los resultados de tu búsqueda y recuperar los datos que necesitas de forma eficiente.

Preguntas frecuentes

¿Existe algún límite en la longitud de la lista de valores de coincidencia en las condiciones de filtro (por ejemplo, filter=’color in ["red", "green", “blue”]')? ¿Qué debo hacer si la lista es demasiado larga?

Zilliz Cloud no impone ningún límite de longitud a la lista de valores de coincidencia en las condiciones de filtro. Sin embargo, una lista excesivamente larga puede afectar significativamente al rendimiento de la consulta. Si tu condición de filtro incluye una lista larga de valores de coincidencia o una expresión compleja con muchos elementos, te recomendamos utilizar las plantillas de filtro para mejorar el rendimiento de la consulta.