기본 연산자

Milvus는 엔티티 필터링을 위해 비교 연산자, 범위 연산자, 산술 연산자, 논리 연산자 및 NULL 연산자를 제공합니다. 각 연산자는 특정 필드 유형을 지원합니다.

비교 연산자

비교 연산자는 등가, 부등가 또는 크기를 기준으로 데이터를 필터링하는 데 사용됩니다. 이 연산자는 숫자 및 텍스트 필드에 적용할 수 있습니다.

지원되는 비교 연산자

• == (같음)

• != (불등호)

• > (보다 큼)

• < (보다 작음)

• >= (보다 크거나 같음)

• <= (작거나 같음)

예 1: '같음' 조건으로 필터링하기 (==)

status 라는 필드가 있고, status 가 "active"인 모든 엔티티를 찾고자 한다고 가정해 보겠습니다. 등호 연산자 == 를 사용할 수 있습니다:

filter = 'status == "active"'

String filter = "status == \"active\"";

filter := "status == \"active\""

let filter = "status == \"active\"";

std::string filter = "status == \"active\"";

const filter = 'status == "active"';

string filter = "status == \"active\"";

filter='status == "active"'

예제 2: '!='과 다른 값으로 필터링하기

status 가 "inactive"가 아닌 엔티티를 찾으려면:

filter = 'status != "inactive"'

String filter = "status != \"inactive\"";

filter := "status != \"inactive\""

let filter = "status != \"inactive\"";

std::string filter = "status != \"inactive\"";

const filter = 'status != "inactive"';

string filter = "status != \"inactive\"";

filter='status != "inactive"'

예제 3: '보다 큼' 조건으로 필터링하기 (>)

age 값이 30보다 큰 모든 엔티티를 찾으려면:

filter = 'age > 30'

String filter = "age > 30";

filter := "age > 30"

let filter = "age > 30";

std::string filter = "age > 30";

const filter = 'age > 30';

string filter = "age > 30";

filter='age > 30'

예제 4: '보다 작음' 조건으로 필터링하기

price 가 100보다 작은 엔티티를 찾으려면:

filter = 'price < 100'

String filter = "price < 100";

filter := "price < 100"

let filter = "price < 100";

std::string filter = "price < 100";

const filter = 'price < 100';

string filter = "price < 100";

filter='price < 100'

예제 5: '보다 크거나 같음' (>=)을 사용한 필터링

rating 가 4 이상인 모든 엔티티를 찾으려면:

filter = 'rating >= 4'

String filter = "rating >= 4";

filter := "rating >= 4"

let filter = "rating >= 4";

std::string filter = "rating >= 4";

const filter = 'rating >= 4';

string filter = "rating >= 4";

filter='rating >= 4'

예제 6: 이하 조건으로 필터링하기

discount 가 10% 이하인 엔티티를 찾으려면:

filter = 'discount <= 10'

String filter = "discount <= 10";

filter := "discount <= 10"

let filter = "discount <= 10";

std::string filter = "discount <= 10";

const filter = 'discount <= 10';

string filter = "discount <= 10";

filter='discount <= 10'

범위 연산자

범위 연산자는 특정 값 집합을 기준으로 데이터를 필터링하는 데 도움이 됩니다. Milvus는 집합 소속 여부 확인을 위해 IN 를 지원합니다.

color 가 "red", "green" 또는 "blue"인 모든 엔티티를 찾으려면:

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

String filter = "color in [\"red\", \"green\", \"blue\"]";

filter := "color in [\"red\", \"green\", \"blue\"]"

let filter = "color in [\"red\", \"green\", \"blue\"]";

std::string filter = "color in [\"red\", \"green\", \"blue\"]";

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

string filter = "color in [\"red\", \"green\", \"blue\"]";

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

이는 값 목록에 속하는지 여부를 확인할 때 유용합니다.

패턴 매칭 연산자

패턴 매칭 연산자는 와일드카드 패턴이나 정규식을 기반으로 문자열 값을 필터링하는 데 도움이 됩니다.

• LIKE: 문자열 값에 대한 간단한 와일드카드 패턴과 일치시키는 데 사용됩니다. 예를 들어, ` name LIKE "Prod%" `는 ` Prod`로 시작하는 값과 일치합니다.

• =~: RE2 정규 표현식과 문자열 값을 일치시키는 데 사용됩니다. 예를 들어, ` code =~ "E[0-9]{4}" `는 ` E1001`와 같은 오류 코드가 포함된 값과 일치합니다.

• !~: RE2 정규 표현식과 일치하는 문자열 값을 제외하는 데 사용됩니다. 이는 NOT (field =~ "pattern") 과 동일합니다.

name 에서 Prod 로 시작하는 엔티티를 찾으려면:

filter = 'name LIKE "Prod%"'

String filter = "name LIKE \"Prod%\"";

filter := "name LIKE \"Prod%\""

let filter = "name LIKE \"Prod%\"";

std::string filter = "name LIKE \"Prod%\"";

const filter = 'name LIKE "Prod%"';

string filter = "name LIKE \"Prod%\"";

filter='name LIKE "Prod%"'

code 에 E1001 와 같은 오류 코드가 포함된 엔티티를 찾으려면:

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

String filter = "code =~ \"E[0-9]{4}\"";

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

let filter = "code =~ \"E[0-9]{4}\"";

std::string filter = "code =~ \"E[0-9]{4}\"";

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

string filter = "code =~ \"E[0-9]{4}\"";

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

message 가 DEBUG 로 시작하는 엔티티를 제외하려면:

filter = 'message !~ "^DEBUG"'

String filter = "message !~ \"^DEBUG\"";

filter := "message !~ \"^DEBUG\""

let filter = "message !~ \"^DEBUG\"";

std::string filter = "message !~ \"^DEBUG\"";

const filter = 'message !~ "^DEBUG"';

string filter = "message !~ \"^DEBUG\"";

filter='message !~ "^DEBUG"'

LIKE 과 정규 표현식(regex) 중 선택 방법, 지원되는 필드 유형, 정규 표현식 구문, 이스케이프 규칙 및 성능에 대한 자세한 내용은 패턴 매칭을 참조하십시오. 또한 Milvus에서는 VARCHAR 필드나 JSON 문자열 경로에 NGRAM 인덱스를 구축하여 해당 패턴 매칭 필터의 성능을 향상시킬 수 있습니다. 자세한 내용은 NGRAM을 참조하십시오.

산술 연산자

산술 연산자를 사용하면 숫자 필드를 포함한 계산을 기반으로 조건을 생성할 수 있습니다.

지원되는 산술 연산자

• + (덧셈)

• - (뺄셈)

• * (곱셈)

• / (나눗셈)

• % (모듈로 연산)

• ** (제곱)

예제 1: 나머지 연산 사용 (%)

id 가 짝수(즉, 2로 나누어 떨어지는 수)인 개체를 찾으려면:

filter = 'id % 2 == 0'

String filter = "id % 2 == 0";

filter := "id % 2 == 0"

let filter = "id % 2 == 0";

std::string filter = "id % 2 == 0";

const filter = 'id % 2 == 0';

string filter = "id % 2 == 0";

filter='id % 2 == 0'

예제 2: 지수 연산 사용 (**)

price 의 2제곱이 1000보다 큰 엔티티를 찾으려면:

filter = 'price ** 2 > 1000'

String filter = "price ** 2 > 1000";

filter := "price ** 2 > 1000"

let filter = "price ** 2 > 1000";

std::string filter = "price ** 2 > 1000";

const filter = 'price ** 2 > 1000';

string filter = "price ** 2 > 1000";

filter='price ** 2 > 1000'

비트 연산자Compatible with Milvus 3.0.0+

비트 연산자는 권한, 기능 플래그 또는 상태 비트와 같이 정수 필드가 여러 플래그를 인코딩하는 경우에 유용합니다. 필터 표현식에서 이러한 연산자를 사용하여 정수 값의 개별 비트를 확인, 결합 또는 비교할 수 있습니다.

스칼라 필드의 경우, 비트 연산자는 INT8, INT16, INT32, INT64 와 같은 정수 필드 유형에 적용됩니다.

지원되는 비트 단위 연산자

연산자	이름	일반적인 용도
&	비트별 AND	특정 비트가 설정되어 있는지 확인합니다.
|	비트별 OR	비트를 결합한 후 비교합니다.
^	비트별 XOR	두 값 간의 비트 차이를 비교합니다.

예: 권한 비트를 이용한 필터링

permissions 라는 정수 필드가 있다고 가정하고, 이 정수의 각 비트가 권한 플래그를 나타낸다고 합시다:

권한 플래그	비트 값
READ	1
WRITE	2
SHARE	4
ADMIN	8

예를 들어, ` permissions = 5 `는 ` READ ` 및 ` SHARE ` 비트가 설정되어 있음을 의미합니다. 이는 ` 5 = 1 + 4`이기 때문입니다.

SHARE 비트가 설정된 엔티티를 찾으려면 비트별 AND 연산(&)을 사용합니다:

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

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

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

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

std::string filter = "(permissions & 4) == 4";

const filter = '(permissions & 4) == 4';

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

filter='(permissions & 4) == 4'

WRITE 비트를 설정했을 때 READ + WRITE + SHARE 권한 세트가 생성되는 엔티티를 찾으려면 비트별 OR 연산(|)을 사용하십시오:

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

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

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

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

std::string filter = "(permissions | 2) == 7";

const filter = '(permissions | 2) == 7';

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

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

권한 비트가 READ + WRITE + SHARE 와 WRITE 비트만 다른 엔티티를 찾으려면 비트별 XOR 연산(^)을 사용합니다:

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

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

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

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

std::string filter = "(permissions ^ 7) == 2";

const filter = '(permissions ^ 7) == 2';

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

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

논리 연산자

논리 연산자는 여러 조건을 결합하여 더 복잡한 필터 표현식을 만드는 데 사용됩니다. 여기에는 AND, OR 및 NOT 가 포함됩니다.

지원되는 논리 연산자

• AND: 여러 조건이 모두 참이어야 하는 경우를 결합합니다.

• OR: 조건 중 적어도 하나가 참이어야 하는 조건을 결합합니다.

• NOT: 조건을 부정합니다.

예 1: ` AND `를 사용하여 조건 결합하기

price 가 100보다 크고 stock 가 50보다 큰 모든 상품을 찾으려면:

filter = 'price > 100 AND stock > 50'

String filter = "price > 100 AND stock > 50";

filter := "price > 100 AND stock > 50"

let filter = "price > 100 AND stock > 50";

std::string filter = "price > 100 AND stock > 50";

const filter = 'price > 100 AND stock > 50';

string filter = "price > 100 AND stock > 50";

filter='price > 100 AND stock > 50'

예제 2: ` OR `를 사용하여 조건 결합하기

color 가 “red”이거나 “blue”인 모든 상품을 찾으려면:

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

String filter = "color == \"red\" OR color == \"blue\"";

filter := "color == \"red\" OR color == \"blue\""

let filter = "color == \"red\" OR color == \"blue\"";

std::string filter = "color == \"red\" OR color == \"blue\"";

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

string filter = "color == \"red\" OR color == \"blue\"";

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

예제 3: ` NOT `를 사용하여 조건 제외하기

color 가 “green”이 아닌 모든 상품을 찾으려면:

filter = 'NOT color == "green"'

String filter = "NOT color == \"green\"";

filter := "NOT color == \"green\""

let filter = "NOT color == \"green\"";

std::string filter = "NOT color == \"green\"";

const filter = 'NOT color == "green"';

string filter = "NOT color == \"green\"";

filter='NOT color == "green"'

IS NULL 및 IS NOT NULL 연산자

IS NULL 및 IS NOT NULL 을 사용하여 필드 값이 누락되었거나 사용 가능한 엔티티를 찾을 수 있습니다. 예를 들어, 카테고리가 없는 상품이나 검색 준비가 완료된 임베딩을 가진 엔티티를 찾을 수 있습니다. 두 연산자 모두 지원되는 스칼라 및 벡터 필드에서 작동하며, 의미는 동일합니다:

연산자	일치 조건
<field> IS NULL	지정된 필드의 값이 NULL인 엔티티
<field> IS NOT NULL	지정된 필드의 값이 NULL이 아닌 엔티티

지원되는 스칼라 필드에는 부울(Boolean), 숫자(numeric), VARCHAR, JSON 및 ARRAY 필드가 포함됩니다. 이 연산자들은 TEXT 필드를 지원하지 않습니다.

Milvus 3.0.3부터 이 연산자는 일반 벡터 필드도 지원합니다: FLOAT_VECTOR, BINARY_VECTOR, FLOAT16_VECTOR, BFLOAT16_VECTOR, SPARSE_FLOAT_VECTOR 및 INT8_VECTOR.

연산자는 대소문자를 구분하지 않습니다. 즉, IS NULL 과 is null 은 동일하며, IS NOT NULL 과 is not null 도 동일합니다.

예시: 값이 누락되었거나 사용 가능한 엔티티 찾기

products 라는 이름의 컬렉션이 인덱싱되고 로드되었다고 가정합니다. 이 컬렉션에는 id 라는 INT64 기본 키, category 라는 null 허용 VARCHAR 필드, 그리고 embedding 라는 null 허용 3차원 FLOAT_VECTOR 필드가 있습니다. 이 컬렉션에는 이미 다음과 같은 엔티티가 포함되어 있습니다:

id	category	embedding
1	"book"	[0.1, 0.2, 0.3]
2	NULL	[0.4, 0.5, 0.6]
3	"book"	NULL

컬렉션 생성 및 데이터 삽입 과정은 생략되었습니다. 해당 단계에 대해서는 ‘Nullable Fields’를 참조하십시오.

아직 임베딩이 필요한 엔티티를 찾으려면 ` embedding IS NULL`을 쿼리하십시오. 서버에 맞게 연결 설정을 조정하십시오.

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

results = client.query(
    collection_name="products",
    filter="embedding IS NULL",
    output_fields=["id"],
    limit=10,
)
print(sorted(entity["id"] for entity in results))
# Expected: [3]

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.QueryReq;
import io.milvus.v2.service.vector.response.QueryResp;
import java.util.Collections;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build());

QueryReq queryReq = QueryReq.builder()
        .collectionName("products")
        .filter("embedding IS NULL")
        .outputFields(Collections.singletonList("id"))
        .limit(10)
        .build();
QueryResp queryResp = client.query(queryReq);
System.out.println(queryResp.getQueryResults());

import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()
cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    log.Fatal("failed to connect to milvus server: ", err.Error())
}
defer cli.Close(ctx)

rs, err := cli.Query(ctx, milvusclient.NewQueryOption("products").
    WithFilter("embedding IS NULL").
    WithOutputFields("id").
    WithLimit(10))
if err != nil {
    log.Fatal("failed to query: ", err.Error())
}
ids := rs.GetColumn("id")
var result []int64
for i := 0; i < ids.Len(); i++ {
    v, _ := ids.GetAsInt64(i)
    result = append(result, v)
}
fmt.Println(result)
// Expected: [3]

use milvus::v2::prelude::*;

let client = ClientV2::new(
    &ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus"),
)
.await?;

let request = QueryRequest::builder()
    .collection_name("products")
    .filter("embedding IS NULL")
    .output_fields(["id"])
    .limit(10)
    .build()?;
let response = client.query(request).await?;
for row in response.results().rows()? {
    println!("{:?}", row.get_i64("id")?);
}

#include <iostream>
#include <string>
#include "milvus/MilvusClientV2.h"

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

auto request = milvus::QueryRequest()
                   .WithCollectionName("products")
                   .WithFilter("embedding IS NULL")
                   .AddOutputField("id")
                   .WithLimit(10);

milvus::QueryResponse response;
status = client->Query(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({ address: "http://localhost:19530", token: "root:Milvus" });

const results = await client.query({
  collection_name: "products",
  filter: "embedding IS NULL",
  output_fields: ["id"],
  limit: 10,
});
console.log(results);

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Types;

var config = new ConnectConfig
{
    Uri = "http://localhost:19530"
};
using var client = new MilvusClientV2(config);
await client.ConnectAsync();

QueryResp results = await client.QueryAsync(new QueryReq
{
    CollectionName = "products",
    Expression = "embedding IS NULL",
    Parameters = new QueryParameters
    {
        OutputFields = { "id" },
        Limit = 10
    }
});

for (int i = 0; i < results.RowCount; i++)
{
    Console.WriteLine(results.GetRow(i)["id"]);
}
// Output
// 3

curl -X 'POST' \
  'http://localhost:19530/v2/vectordb/entities/query' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer root:Milvus' \
  -H 'Content-Type: application/json' \
  -d '{
    "collectionName": "products",
    "filter": "embedding IS NULL",
    "outputFields": ["id"],
    "limit": 10
  }'

동일한 쿼리에서 ` filter `을 대체하여 특정 필드를 확인하거나 조건을 결합할 수 있습니다:

필터 표현식	일치하는 ID	목적
category IS NULL	2	카테고리가 없는 엔티티 찾기
category IS NOT NULL	1, 3	카테고리가 있는 엔티티 찾기
embedding IS NULL	3	임베딩이 없는 엔티티 찾기
embedding IS NOT NULL	1, 2	임베딩이 있는 엔티티 찾기
category IS NOT NULL AND embedding IS NOT NULL	1	두 값을 모두 가진 엔티티 찾기

필드 값 처리 방식

연산자는 저장된 필드 값을 확인합니다. 기본값이 없는 null 허용 필드의 경우, 삽입 시 해당 필드를 생략하거나 명시적으로 NULL로 설정하면 NULL이 저장됩니다. 구성된 기본값에 따라 저장되는 값이 달라질 수 있습니다. 자세한 내용은 'null 허용 필드 및 기본값'을 참조하십시오.

필드 유형	NULL 처리 방식
VARCHAR	빈 문자열 "" 은 NULL이 아닌 값입니다.
JSON	전체 필드의 NULL 값은 IS NULL 과 일치합니다. {"category": null} 와 같은 JSON 객체는 내부 값이 NULL이라 하더라도 NULL이 아닙니다.
ARRAY	전체 필드의 NULL 값은 IS NULL 과 일치합니다. 개별 요소는 NULL일 수 없으며, IS NULL / IS NOT NULL 은 tags[0] 와 같은 배열 요소 액세스를 지원하지 않습니다. 배열 필드를 참조하십시오.
일반 벡터 유형	NULL은 벡터 값이 존재하지 않음을 의미합니다. 성분이 모두 0인 벡터는 NULL이 아닙니다.

nullable=False 로 정의된 지원되는 필드의 경우, IS NULL 는 어떤 엔티티와도 일치하지 않으며, IS NOT NULL 는 표시되는 모든 엔티티와 일치합니다. 필터의 다른 조건들은 여전히 적용됩니다.

벡터 검색에서 NULL 필터 사용

검색 필터에서도 동일한 연산자를 사용할 수 있지만, 유사도 검색에 참여하려면 엔티티가 검색 대상 필드에 벡터를 가지고 있어야 합니다.

위의 예제 데이터를 바탕으로, anns_field="embedding" 을 사용한 검색을 고려해 보겠습니다:

필터 표현식	유사도 검색 대상 엔티티	이유
category IS NULL	2	엔티티 2 에는 카테고리가 없지만, embedding 벡터가 있습니다.
embedding IS NULL	없음	엔티티 3 는 필터 조건에 부합하지만, 쿼리 벡터와 비교할 embedding 벡터가 없습니다.
embedding IS NOT NULL	1, 2	두 엔티티 모두 embedding 벡터를 가지고 있습니다.

세 필터 모두 유효합니다. embedding IS NULL 를 사용하여 embedding 를 검색하면, 두 조건을 모두 충족하는 엔티티가 없으므로 검색 결과가 반환되지 않습니다. 임베딩이 누락된 엔티티를 검색하려면 위에서 보여준 것처럼 query() 를 사용하십시오.

벡터 검색은 이미 검색 대상 벡터 필드가 NULL인 엔티티를 건너뛰므로, embedding IS NOT NULL 는 embedding 에 대한 검색 후보를 추가로 좁히지 않습니다. 순위, 기타 필터 및 검색 제한에 따라 반환될 후보가 결정됩니다.

JSON 및 ARRAY 필드에서 기본 연산자 사용 팁

Milvus의 기본 연산자는 다용도로 사용 가능하며 스칼라 필드에 적용할 수 있을 뿐만 아니라, JSON 및 ARRAY 필드의 키와 인덱스와 함께 효과적으로 사용할 수도 있습니다.

예를 들어, price, model, tags 과 같은 여러 키를 포함하는 product 필드가 있는 경우, 항상 키를 직접 참조해야 합니다:

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

String filter = "product[\"price\"] > 1000";

filter := "product[\"price\"] > 1000"

let filter = "product[\"price\"] > 1000";

std::string filter = "product[\"price\"] > 1000";

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

string filter = "product[\"price\"] > 1000";

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

기록된 온도 배열에서 첫 번째 온도가 특정 값을 초과하는 레코드를 찾으려면 다음을 사용하십시오:

filter = 'history_temperatures[0] > 30'

String filter = "history_temperatures[0] > 30";

filter := "history_temperatures[0] > 30"

let filter = "history_temperatures[0] > 30";

std::string filter = "history_temperatures[0] > 30";

const filter = 'history_temperatures[0] > 30';

string filter = "history_temperatures[0] > 30";

filter='history_temperatures[0] > 30'

결론

Milvus는 데이터 필터링 및 쿼리 시 유연성을 제공하는 다양한 기본 연산자를 제공합니다. 비교, 범위, 산술 및 논리 연산자를 조합하여 강력한 필터 표현식을 생성하면 검색 결과를 좁혀 필요한 데이터를 효율적으로 가져올 수 있습니다.

자주 묻는 질문

필터 조건에서 일치 값 목록의 길이에 제한이 있습니까(예: filter='color in ["red", "green", “blue”]')? 목록이 너무 길면 어떻게 해야 합니까?

Milvus는 필터 조건의 일치 값 목록에 길이 제한을 두지 않습니다. 그러나 목록이 지나치게 길면 쿼리 성능에 상당한 영향을 미칠 수 있습니다. 필터 조건에 긴 일치 값 목록이나 요소가 많은 복잡한 표현식이 포함된 경우, 쿼리 성능을 향상시키기 위해 필터 템플릿을 사용하는 것을 권장합니다.