Operadores básicos

O Milvus disponibiliza um conjunto abrangente 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 utilizar estes operadores é fundamental para criar 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. São aplicáveis a campos numéricos e de texto.

Operadores de comparação suportados

• == (Igual a)

• != (Diferente de)

• > (Maior que)

• < (Menor que)

• >= (Maior ou igual a)

• <= (Menor ou igual a)

Exemplo 1: Filtragem com «igual a» (==)

Suponha que tem um campo chamado « status » e que pretende encontrar todas as entidades em que « status » seja «active». Pode utilizar o operador de igualdade « == »:

filter = 'status == "active"'

Exemplo 2: Filtragem com «não é igual a» (!=)

Para encontrar entidades em que status não seja «inactive»:

filter = 'status != "inactive"'

Exemplo 3: Filtragem com «maior que» (>)

Se pretender encontrar todas as entidades com um age superior a 30:

filter = 'age > 30'

Exemplo 4: Filtragem com «menor que»

Para encontrar entidades em que price seja inferior a 100:

filter = 'price < 100'

Exemplo 5: Filtragem com maior ou igual a (>=)

Se pretender encontrar todas as entidades com rating maior ou igual a 4:

filter = 'rating >= 4'

Exemplo 6: Filtragem com «menor ou igual a»

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

filter = 'discount <= 10'

Operadores de intervalo

Os operadores de intervalo ajudam a filtrar dados com base num conjunto específico de valores. O Milvus suporta o IN para verificações de pertença a conjuntos.

Se pretender encontrar todas as entidades em que o « color » seja «red», «green» ou «blue»:

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

Isto é útil quando pretende verificar a pertença a uma lista de valores.

Operadores de correspondência de padrões

Os operadores de correspondência de padrões ajudam a filtrar valores de cadeia de caracteres com base em padrões com caracteres curinga ou expressões regulares.

• LIKE: Utilizado para corresponder padrões simples com caracteres curinga em valores de cadeia de caracteres. Por exemplo, name LIKE "Prod%" corresponde a valores que começam por Prod.

• =~: Utilizado para corresponder um valor de cadeia de caracteres a uma expressão regular RE2. Por exemplo, code =~ "E[0-9]{4}" corresponde a valores que contenham um código de erro como E1001.

• !~: Utilizado para excluir valores de cadeia de caracteres que correspondam a uma expressão regular RE2. Isto é equivalente a NOT (field =~ "pattern").

Para encontrar entidades em que « name » comece por « Prod »:

filter = 'name LIKE "Prod%"'

Para encontrar entidades cujo « code » contenha um código de erro como « E1001 »:

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

Para excluir entidades cujo message comece por DEBUG:

filter = 'message !~ "^DEBUG"'

Para mais detalhes sobre a escolha entre « LIKE » e expressões regulares, tipos de campos suportados, sintaxe de expressões regulares, regras de escape e desempenho, consulte «Correspondência de Padrões». O Milvus também permite criar um índice « NGRAM » em campos « VARCHAR » ou percursos de cadeias JSON para acelerar os filtros de correspondência de padrões elegíveis. Para mais detalhes, consulte «NGRAM».

Operadores aritméticos

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

Operadores aritméticos suportados

• + (Adição)

• - (Subtração)

• * (Multiplicação)

• / (Divisão)

• % (Módulo)

• ** (Elevamento a potência)

Exemplo 1: Utilização do módulo (%)

Para encontrar entidades em que o id é um número par (ou seja, divisível por 2):

filter = 'id % 2 == 0'

Exemplo 2: Utilização da elevação a potência (**)

Para encontrar entidades em que price elevado à potência de 2 seja maior que 1000:

filter = 'price ** 2 > 1000'

Operadores bit a bitCompatible with Milvus 3.0.0+

Os operadores bit a bit são úteis quando um campo inteiro codifica vários indicadores, tais como permissões, indicadores de funcionalidades ou bits de estado. Pode utilizar estes operadores em expressões de filtro para verificar, combinar ou comparar bits individuais num valor inteiro.

Para campos escalares, os operadores bit a bit aplicam-se a tipos de campo inteiros, tais como INT8, INT16, INT32 e INT64.

Operadores bit a bit suportados

Operador	Nome	Utilização típica
&	AND bit a bit	Verifica se determinados bits estão definidos.
|	OR bit a bit	Combinar bits antes da comparação.
^	XOR bit a bit	Compara as diferenças de bits entre dois valores.

Exemplo: Filtragem por bits de permissão

Suponha que tem um campo inteiro denominado « permissions », e que cada bit desse inteiro representa um sinalizador de permissão:

Sinalizador de permissão	Valor do bit
READ	1
WRITE	2
SHARE	4
ADMIN	8

Por exemplo, « permissions = 5 » significa que os bits « READ » e « SHARE » estão definidos, porque « 5 = 1 + 4 ».

Para encontrar entidades em que o bit « SHARE » esteja definido, utilize o operador AND bit a bit (&):

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

Para encontrar entidades em que a definição do bit « WRITE » resulte no conjunto de permissões « READ + WRITE + SHARE », utilize o operador OR bit a bit (|):

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

Para encontrar entidades cujos bits de permissão diferem de « READ + WRITE + SHARE » apenas no bit « WRITE », utilize a operação XOR bit a bit (^):

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

Operadores lógicos

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

Operadores lógicos suportados

• AND: Combina várias condições que têm de ser todas verdadeiras.

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

• NOT: Nega uma condição.

Exemplo 1: Utilizar « AND » para combinar condições

Para encontrar todos os produtos em que « price » seja superior a 100 e « stock » seja superior a 50:

filter = 'price > 100 AND stock > 50'

Exemplo 2: Utilizar « OR » para combinar condições

Para encontrar todos os produtos em que a cor ( color ) seja «vermelha» ou «azul»:

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

Exemplo 3: Utilizar « NOT » para excluir uma condição

Para encontrar todos os produtos em que « color » não seja «green»:

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 na existência ou não de 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 não está definido.

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

Campos escalares regulares com valores nulos

O Milvus permite filtrar em campos escalares normais, como cadeias de caracteres ou números, com valores nulos.

Para recuperar entidades em que o campo « description » seja nulo:

filter = 'description IS NULL'

Para recuperar entidades em que o campo « description » não seja nulo:

filter = 'description IS NOT NULL'

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

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

Campos JSON com valores nulos

O Milvus permite filtrar 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 como o Milvus lida com campos JSON com valores nulos, considere os seguintes dados de exemplo 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 em que os metadados são nulos

Para encontrar entidades em que o campo metadata esteja 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 em que o campo ` metadata ` não seja 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

O Milvus permite filtrar campos ARRAY que contenham valores nulos. Um campo ARRAY é tratado como nulo nas seguintes situações:

• Todo o campo ARRAY está explicitamente definido como None (nulo), por exemplo, "tags": None.

• O campo ARRAY está completamente ausente da entidade.

Para ilustrar melhor como o Milvus lida com campos ARRAY com valores nulos, considere os seguintes dados de exemplo 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 em que o campo «tags» é nulo

Para recuperar entidades em que o campo « tags » esteja 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 o campo «tags» não seja nulo

Para recuperar entidades em que o campo « tags » não seja 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 a utilização de operadores básicos com campos JSON e ARRAY

Embora os operadores básicos no Milvus sejam versáteis e possam ser aplicados a campos escalares, também podem ser utilizados de forma eficaz com as chaves e os índices nos campos JSON e ARRAY.

Por exemplo, se tiver um campo « product » que contenha várias chaves, como « price », « model » e « tags », refira sempre a chave diretamente:

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

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

filter = 'history_temperatures[0] > 30'

Conclusão

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

Perguntas frequentes

Existe algum limite para o comprimento da lista de valores de correspondência nas condições de filtro (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 à lista de valores de correspondência nas condições de filtro. No entanto, uma lista excessivamente 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 Modelos de Filtro para melhorar o desempenho da consulta.