Operadores básicos

Milvus proporciona un amplio conjunto de operadores básicos para ayudarle a filtrar y consultar datos de forma eficiente. Estos operadores le permiten refinar sus condiciones de búsqueda basándose en campos escalares, cálculos numéricos, condiciones lógicas y mucho más. Entender cómo utilizar estos operadores es crucial para construir consultas precisas y maximizar la eficiencia de sus 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. Son aplicables 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: Filtrado con Igual a (==)

Suponga que tiene un campo llamado status y desea encontrar todas las entidades en las que status es "activo". Puede utilizar el operador de igualdad ==:

filter = 'status == "active"'

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

Para encontrar entidades donde status no sea "inactivo":

filter = 'status != "inactive"'

Ejemplo 3: Filtrado con Mayor que (>)

Si desea encontrar todas las entidades con un age mayor que 30:

filter = 'age > 30'

Ejemplo 4: Filtrar con menor que

Para encontrar las entidades en las que price es inferior a 100:

filter = 'price < 100'

Ejemplo 5: Filtrado con mayor o igual que (>=)

Si desea encontrar todas las entidades con rating mayor o igual a 4:

filter = 'rating >= 4'

Ejemplo 6: Filtrado con menor o igual que

Para encontrar entidades con discount menor o igual a 10%:

filter = 'discount <= 10'

Operadores de rango

Los operadores de rango ayudan a filtrar datos basándose en conjuntos o rangos de valores específicos.

Operadores de rango admitidos:

• IN: Se utilizan para buscar valores dentro de un conjunto o rango específico.

• LIKE: Se utiliza para coincidir con un patrón (principalmente para campos de texto). Milvus le permite construir un índice NGRAM en campos VARCHAR o JSON para acelerar las consultas de texto. Para más detalles, consulte NGRAM.

Ejemplo 1: Uso de IN para buscar múltiples valores

Si desea encontrar todas las entidades en las que color es "rojo", "verde" o "azul":

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

Esto es útil cuando se quiere comprobar la pertenencia a una lista de valores.

Ejemplo 2: Utilización de LIKE para la búsqueda de patrones

El operador LIKE se utiliza para la comparación de patrones en campos de cadena. Puede coincidir con subcadenas en distintas posiciones dentro del texto: como prefijo, infijo o sufijo. El operador LIKE utiliza el símbolo % como comodín, que puede coincidir con cualquier número de caracteres (incluido el cero).

Coincidencia de prefijo (comienza por)

Para realizar una coincidencia de prefijo, en la que la cadena comienza con un patrón dado, puede colocar el patrón al principio y utilizar % para que coincida con los caracteres que le siguen. Por ejemplo, para buscar todos los productos cuyo name empiece por "Prod":

filter = 'name LIKE "Prod%"'

Esto coincidirá con cualquier producto cuyo nombre empiece por "Prod", como "Producto A", "Producto B", etc.

Coincidencia de sufijo (termina con)

Para una coincidencia de sufijo, en la que la cadena termina con un patrón dado, coloque el símbolo % al principio del patrón. Por ejemplo, para buscar todos los productos cuyo name termine en "XYZ":

filter = 'name LIKE "%XYZ"'

Esto coincidirá con cualquier producto cuyo nombre termine en "XYZ", como "ProductXYZ", "SampleXYZ", etc.

Coincidencia infija (contiene)

Para realizar una coincidencia infija, en la que el patrón puede aparecer en cualquier lugar de la cadena, puede colocar el símbolo % tanto al principio como al final del patrón. Por ejemplo, para buscar todos los productos cuyo name contenga la palabra "Pro":

filter = 'name LIKE "%Pro%"'

Esto coincidirá con cualquier producto cuyo nombre contenga la subcadena "Pro", como "Product", "ProLine" o "SuperPro".

Operadores aritméticos

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

Operadores aritméticos admitidos:

• + (Suma)

• - (Resta)

• * (Multiplicación)

• / (División)

• % (Módulo)

• ** (Exponenciación)

Ejemplo 1: Utilización del módulo (%)

Para encontrar entidades donde el id es un número par (es decir, divisible por 2):

filter = 'id % 2 == 0'

Ejemplo 2: Uso de la exponenciación (**)

Para encontrar entidades donde price elevado a la potencia de 2 es mayor que 1000:

filter = 'price ** 2 > 1000'

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 donde al menos una debe ser verdadera.

• NOT: Niega una condición.

Ejemplo 1: Uso de AND para combinar condiciones

Para encontrar todos los productos donde price es mayor que 100 y stock es mayor que 50:

filter = 'price > 100 AND stock > 50'

Ejemplo 2: Uso de OR para combinar condiciones

Para encontrar todos los productos donde color es "rojo" o "azul":

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

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

Para encontrar todos los productos en los que color no es "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 indefinido.

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

Campos escalares regulares con valores nulos

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

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

filter = 'description IS NULL'

Para recuperar entidades en las que el campo description no es nulo:

filter = 'description IS NOT NULL'

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

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

Campos JSON con valores nulos

Milvus permite filtrar campos JSON que contienen valores nulos. Un campo JSON se trata como nulo de las siguientes maneras:

• Todo el objeto JSON se establece explícitamente como None (nulo), por ejemplo, {"metadata": None}.

• El propio campo JSON falta por completo en la entidad.

Para ilustrar mejor cómo trata Milvus los campos JSON con valores nulos, considere 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 cuyos metadatos son nulos

Para encontrar entidades en las que el campo metadata falta o está explícitamente establecido como Ninguno:

filter = 'metadata IS NULL'

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

Ejemplo 2: Recuperar entidades cuyos metadatos no son 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 contienen valores nulos. Un campo ARRAY se trata como nulo de las siguientes maneras:

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

• El campo ARRAY falta por completo en la entidad.

Para ilustrar mejor cómo maneja 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 donde tags es null

Para recuperar entidades donde el campo tags falta o está explícitamente establecido en 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 donde tags no es nulo

Para recuperar entidades en las que el campo tags no es 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 sobre el uso de 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 eficazmente con las claves y los índices de los campos JSON y ARRAY.

Por ejemplo, si tiene un campo product que contiene múltiples claves como price, model, y tags, siempre haga referencia a la clave directamente:

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

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

filter = 'history_temperatures[0] > 30'

Conclusión

Milvus ofrece una serie de operadores básicos que le proporcionan flexibilidad a la hora de filtrar y consultar sus datos. Combinando operadores de comparación, de rango, aritméticos y lógicos, puede crear potentes expresiones de filtrado para acotar los resultados de búsqueda y recuperar los datos que necesita de forma eficaz.

PREGUNTAS FRECUENTES

¿Existe un límite para la longitud de la lista de valores coincidentes en las condiciones de filtrado (por ejemplo, filter='color en ["rojo", "verde", "azul"]')? ¿Qué debo hacer si la lista es demasiado larga?

Zilliz Cloud no impone un límite de longitud a la lista de valores coincidentes en las condiciones de filtrado. Sin embargo, una lista excesivamente larga puede afectar significativamente al rendimiento de la consulta. Si su condición de filtro incluye una lista larga de valores coincidentes o una expresión compleja con muchos elementos, le recomendamos que utilice Filter Templating para mejorar el rendimiento de la consulta.