Operadores básicos

Milvus fornece um conjunto rico de operadores básicos para o ajudar a filtrar e consultar dados de forma eficiente. Estes operadores permitem-lhe refinar as suas condições de pesquisa com base em campos escalares, cálculos numéricos, condições lógicas, e muito mais. Compreender como usar estes operadores é crucial para construir consultas precisas e maximizar a eficiência das suas pesquisas.

Operadores de comparação

Os operadores de comparação são utilizados para filtrar dados com base na igualdade, desigualdade ou tamanho. Eles são aplicáveis a campos numéricos e de texto.

Operadores de comparação suportados:

• == (Igual a)

• != (Não igual a)

• > (Maior que)

• < (Menor que)

• >= (Maior que ou igual a)

• <= (Menor ou igual a)

Exemplo 1: Filtragem com Equal To (==)

Suponha que tem um campo chamado status e quer encontrar todas as entidades em que status está "ativo". Você pode usar o operador de igualdade ==:

filter = 'status == "active"'

Exemplo 2: Filtragem com Not Equal To (!=)

Para encontrar entidades onde status não é "inativo":

filter = 'status != "inactive"'

Exemplo 3: Filtragem com Greater Than (>)

Se você quiser encontrar todas as entidades com um age maior que 30:

filter = 'age > 30'

Exemplo 4: Filtragem com menos que

Para encontrar entidades onde price é menor que 100:

filter = 'price < 100'

Exemplo 5: Filtrando com Maior que ou Igual a (>=)

Se você quiser encontrar todas as entidades com rating maior ou igual a 4:

filter = 'rating >= 4'

Exemplo 6: Filtragem com Menor que ou Igual a

Para encontrar entidades com discount menor ou igual a 10%:

filter = 'discount <= 10'

Operadores de intervalo

Os operadores de intervalo ajudam a filtrar dados com base em conjuntos específicos ou intervalos de valores.

Operadores de intervalo suportados:

• IN: Utilizados para fazer corresponder valores dentro de um conjunto ou intervalo específico.

• LIKE: Usado para corresponder a um padrão (principalmente para campos de texto). Milvus permite-lhe construir um índice NGRAM em campos VARCHAR ou JSON para acelerar as consultas de texto. Para obter detalhes, consulte NGRAM.

Exemplo 1: Usando IN para combinar vários valores

Se você quiser encontrar todas as entidades onde o color é "vermelho", "verde" ou "azul":

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

Isso é útil quando você deseja verificar a associação em uma lista de valores.

Exemplo 2: Usando LIKE para correspondência de padrão

O operador LIKE é utilizado para correspondência de padrões em campos de cadeia de caracteres. Ele pode corresponder substrings em diferentes posições dentro do texto: como um prefixo, infixo ou sufixo. O operador LIKE utiliza o símbolo % como um wildcard, que pode corresponder a qualquer número de caracteres (incluindo zero).

Correspondência de prefixo (começa com)

Para efetuar uma correspondência de prefixo, em que a cadeia de caracteres começa com um determinado padrão, pode colocar o padrão no início e utilizar % para corresponder a quaisquer caracteres a seguir. Por exemplo, para encontrar todos os produtos cujo name comece por "Prod":

filter = 'name LIKE "Prod%"'

Isto fará corresponder qualquer produto cujo nome comece por "Prod", como "Produto A", "Produto B", etc.

Correspondência de sufixo (termina com)

Para uma correspondência de sufixo, em que a cadeia de caracteres termina com um determinado padrão, coloque o símbolo % no início do padrão. Por exemplo, para encontrar todos os produtos cujo name termina com "XYZ":

filter = 'name LIKE "%XYZ"'

Isto corresponderá a qualquer produto cujo nome termine com "XYZ", como "ProductXYZ", "SampleXYZ", etc.

Correspondência de infixos (Contém)

Para efetuar uma correspondência infixa, em que o padrão pode aparecer em qualquer parte da cadeia de caracteres, pode colocar o símbolo % no início e no fim do padrão. Por exemplo, para encontrar todos os produtos cujo name contenha a palavra "Pro":

filter = 'name LIKE "%Pro%"'

Isso corresponderá a qualquer produto cujo nome contenha a substring "Pro", como "Product", "ProLine" ou "SuperPro".

Operadores aritméticos

Os operadores aritméticos permitem-lhe criar condições com base em cálculos que envolvem campos numéricos.

Operadores aritméticos suportados:

• + (Adição)

• - (Subtração)

• * (Multiplicação)

• / (Divisão)

• % (Módulo)

• ** (Exponenciação)

Exemplo 1: Utilizar o módulo (%)

Para encontrar entidades onde o id é um número par (i.e., divisível por 2):

filter = 'id % 2 == 0'

Exemplo 2: Usando Exponenciação (**)

Para encontrar entidades onde price elevado à potência de 2 é maior que 1000:

filter = 'price ** 2 > 1000'

Operadores lógicos

Os operadores lógicos são usados para combinar várias condições em uma expressão de filtro mais complexa. Estes incluem AND, OR, e NOT.

Operadores lógicos suportados:

• AND: Combina várias condições que devem ser todas verdadeiras.

• OR: Combina condições em que pelo menos uma deve ser verdadeira.

• NOT: Nega uma condição.

Exemplo 1: Usando AND para combinar condições

Para encontrar todos os produtos em que price é maior que 100 e stock é maior que 50:

filter = 'price > 100 AND stock > 50'

Exemplo 2: Usando OR para combinar condições

Para encontrar todos os produtos em que color é "red" (vermelho) ou "blue" (azul):

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

Exemplo 3: Usando NOT para excluir uma condição

Para encontrar todos os produtos em que color não é "verde":

filter = 'NOT color == "green"'

Operadores IS NULL e IS NOT NULL

Os operadores IS NULL e IS NOT NULL são utilizados para filtrar campos com base no facto de conterem ou não um valor nulo (ausência de dados).

• IS NULL: Identifica entidades em que um campo específico contém um valor nulo, ou seja, o valor está ausente ou indefinido.

• IS NOT NULL: Identifica entidades em que um campo específico contém qualquer valor diferente de nulo, o que significa que o campo tem um valor válido e definido.

Campos escalares regulares com valores nulos

O Milvus permite a filtragem de campos escalares regulares, como cadeias de caracteres ou números, com valores nulos.

Para recuperar entidades onde o campo description é nulo:

filter = 'description IS NULL'

Para recuperar entidades onde o campo description não é nulo:

filter = 'description IS NOT NULL'

Para recuperar entidades em que o campo description não é nulo e o campo price é superior a 10:

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

Campos JSON com valores nulos

Milvus permite a filtragem de campos JSON que contenham valores nulos. Um campo JSON é tratado como nulo das seguintes formas:

• Todo o objeto JSON é explicitamente definido como None (nulo), por exemplo, {"metadata": None}.

• O próprio campo JSON está completamente ausente da entidade.

Para ilustrar melhor a forma como o Milvus trata os campos JSON com valores nulos, considere os seguintes dados de amostra com um 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]
  }
]

Exemplo 1: Recuperar entidades onde os metadados são nulos

Para encontrar entidades em que o campo metadata está em falta ou explicitamente definido como None:

filter = 'metadata IS NULL'

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

Exemplo 2: Recuperar entidades em que os metadados não são nulos

Para encontrar entidades onde o campo metadata não é 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 com valores nulos

Milvus permite filtrar os campos ARRAY que contêm valores nulos. Um campo ARRAY é tratado como nulo das seguintes formas:

• O campo ARRAY inteiro é explicitamente definido como Nenhum (nulo), por exemplo, "tags": None.

• O campo ARRAY está completamente ausente da entidade.

Para ilustrar melhor como Milvus trata os campos ARRAY com valores nulos, considere os seguintes dados de amostra com um 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]
  }
]

Exemplo 1: Recuperar entidades onde as etiquetas são nulas

Para recuperar entidades em que o campo tags está em falta ou explicitamente definido 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}"
# ]

Exemplo 2: Recuperar entidades em que as etiquetas não são nulas

Para recuperar entidades onde o campo tags não é 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}"
# ]

Dicas sobre como usar operadores básicos com campos JSON e ARRAY

Enquanto os operadores básicos em Milvus são versáteis e podem ser aplicados a campos escalares, eles também podem ser efetivamente usados com as chaves e índices nos campos JSON e ARRAY.

Por exemplo, se tiver um campo product que contenha várias chaves como price, model, e tags, faça sempre referência à chave diretamente:

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

Para encontrar registos em que a primeira temperatura de uma matriz de temperaturas registadas excede um determinado valor, utilize:

filter = 'history_temperatures[0] > 30'

Conclusão

O Milvus oferece uma gama de operadores básicos que lhe dão flexibilidade na filtragem e consulta dos seus dados. Ao combinar operadores de comparação, de intervalo, aritméticos e lógicos, pode criar expressões de filtragem poderosas para restringir os resultados da pesquisa e obter os dados de que necessita de forma eficiente.

PERGUNTAS FREQUENTES

Existe um limite para o comprimento da lista de valores de correspondência nas condições de filtragem (por exemplo, filter='color in ["red", "green", "blue"]')? O que devo fazer se a lista for demasiado longa?

O Zilliz Cloud não impõe um limite de comprimento para a lista de valores de correspondência nas condições de filtragem. No entanto, uma lista demasiado longa pode afetar significativamente o desempenho da consulta. Se a sua condição de filtro incluir uma longa lista de valores de correspondência ou uma expressão complexa com muitos elementos, recomendamos a utilização de Filter Templating para melhorar o desempenho da consulta.