Milvus
Zilliz
별표46.3K데모 예약하기시작하기
홈페이지

쿼리

ANN 검색 외에도 Milvus는 쿼리를 통한 메타데이터 필터링을 지원합니다. 이 페이지에서는 쿼리(Query), 가져오기(Get), 쿼리 이터레이터(QueryIterators)를 사용하여 엔티티를 검색하고, 메타데이터를 필터링하며, 쿼리 결과를 정렬하고, 스칼라 값을 집계하는 방법을 소개합니다.

컬렉션 생성 후 새로운 필드를 추가하면, 해당 필드를 포함하는 쿼리는 값이 명시적으로 설정되지 않은 엔티티에 대해 정의된 기본값 또는 ` NULL `을 반환합니다. 자세한 내용은 ‘컬렉션 스키마 변경(Alter Collection Schema)’을 참조하십시오.

개요

컬렉션은 다양한 유형의 스칼라 필드를 저장할 수 있습니다. Milvus를 사용하여 하나 이상의 스칼라 필드를 기준으로 엔티티를 필터링할 수 있습니다. Milvus는 Query, Get, QueryIterator의 세 가지 쿼리 유형을 제공합니다. 아래 표는 이 세 가지 쿼리 유형을 비교한 것입니다.

Get

쿼리

QueryIterator

적용 가능한 시나리오

지정된 기본 키를 가진 엔티티를 찾기 위한 경우.

사용자 정의 필터링 조건을 충족하는 모든 엔티티 또는 지정된 수의 엔티티를 찾기 위함

페이지 단위로 분할된 쿼리에서 사용자 정의 필터링 조건을 충족하는 모든 엔티티를 찾기 위함.

필터링 방법

주키를 기준으로

필터링 표현식을 기준으로.

필터링 표현식을 사용하여.

필수 매개변수

  • 컬렉션 이름

  • 기본 키

  • 컬렉션 이름

  • 필터링 표현식

  • 컬렉션 이름

  • 필터링 표현식

  • 쿼리당 반환할 엔티티 수

선택적 매개변수

  • 파티션 이름

  • 출력 필드

  • 파티션 이름

  • 반환할 엔티티 수

  • 출력 필드

  • 파티션 이름

  • 총 반환 엔티티 수

  • 출력 필드

반환

지정된 컬렉션 또는 파티션에서 지정된 기본 키를 가진 엔티티를 반환합니다.

지정된 컬렉션 또는 파티션에서 사용자 정의 필터링 조건을 충족하는 모든 엔티티 또는 지정된 수의 엔티티를 반환합니다.

지정된 컬렉션 또는 파티션에서 사용자 정의 필터링 조건을 충족하는 모든 엔터티를 페이지 단위 쿼리를 통해 반환합니다.

메타데이터 필터링에 대한 자세한 내용은 부울 표현식 규칙을 참조하십시오.

Get 사용

기본 키를 기준으로 엔티티를 찾아야 할 때는 Get 메서드를 사용할 수 있습니다. 다음 코드 예제는 컬렉션에 id, vector, color 라는 세 개의 필드가 있다고 가정합니다.

[
        {"id": 0, "vector": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], "color": "pink_8682"},
        {"id": 1, "vector": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104], "color": "red_7025"},
        {"id": 2, "vector": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592], "color": "orange_6781"},
        {"id": 3, "vector": [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345], "color": "pink_9298"},
        {"id": 4, "vector": [0.4452349528804562, -0.8757026943054742, 0.8220779437047674, 0.46406290649483184, 0.30337481143159106], "color": "red_4794"},
        {"id": 5, "vector": [0.985825131989184, -0.8144651566660419, 0.6299267002202009, 0.1206906911183383, -0.1446277761879955], "color": "yellow_4222"},
        {"id": 6, "vector": [0.8371977790571115, -0.015764369584852833, -0.31062937026679327, -0.562666951622192, -0.8984947637863987], "color": "red_9392"},
        {"id": 7, "vector": [-0.33445148015177995, -0.2567135004164067, 0.8987539745369246, 0.9402995886420709, 0.5378064918413052], "color": "grey_8510"},
        {"id": 8, "vector": [0.39524717779832685, 0.4000257286739164, -0.5890507376891594, -0.8650502298996872, -0.6140360785406336], "color": "white_9381"},
        {"id": 9, "vector": [0.5718280481994695, 0.24070317428066512, -0.3737913482606834, -0.06726932177492717, -0.6980531615588608], "color": "purple_4976"},
]

다음과 같이 ID를 사용하여 엔티티를 가져올 수 있습니다.

Python Java Go NodeJS cURL C++ 
from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

res = client.get(
    collection_name="my_collection",
    ids=[0, 1, 2],
    output_fields=["vector", "color"]
)

print(res)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.GetReq
import io.milvus.v2.service.vector.request.GetResp
import io.milvus.v2.service.vector.response.QueryResp;
import java.util.*;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());
        
GetReq getReq = GetReq.builder()
        .collectionName("my_collection")
        .ids(Arrays.asList(0, 1, 2))
        .outputFields(Arrays.asList("vector", "color"))
        .build();

GetResp getResp = client.get(getReq);

List<QueryResp.QueryResult> results = getResp.getGetResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

// Output
// {color=pink_8682, vector=[0.35803765, -0.6023496, 0.18414013, -0.26286206, 0.90294385], id=0}
// {color=red_7025, vector=[0.19886813, 0.060235605, 0.6976963, 0.26144746, 0.8387295], id=1}
// {color=orange_6781, vector=[0.43742132, -0.55975026, 0.6457888, 0.7894059, 0.20785794], id=2}

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

milvusAddr := "localhost:19530"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

resultSet, err := client.Get(ctx, milvusclient.NewQueryOption("my_collection").
    WithConsistencyLevel(entity.ClStrong).
    WithIDs(column.NewColumnInt64("id", []int64{0, 1, 2})).
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())

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

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

const res = client.get({
    collection_name="my_collection",
    ids=[0,1,2],
    output_fields=["vector", "color"]
})

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/get" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "id": [0, 1, 2],
    "outputFields": ["vector", "color"]
}'

# {"code":0,"cost":0,"data":[{"color":"pink_8682","id":0,"vector":[0.35803765,-0.6023496,0.18414013,-0.26286206,0.90294385]},{"color":"red_7025","id":1,"vector":[0.19886813,0.060235605,0.6976963,0.26144746,0.8387295]},{"color":"orange_6781","id":2,"vector":[0.43742132,-0.55975026,0.6457888,0.7894059,0.20785794]}]}

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

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

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

auto request = milvus::GetRequest()
                   .WithCollectionName("my_collection")
                   .WithIDs({0, 1, 2})
                   .AddOutputField("vector")
                   .AddOutputField("color");

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

쿼리 사용

기본 쿼리

사용자 정의 필터링 조건에 따라 엔티티를 찾아야 할 때는 Query 메서드를 사용합니다. 다음 코드 예제는 id, vector, color 라는 세 개의 필드가 있다고 가정하며, red 로 시작하는 color 값을 가진 지정된 수의 엔티티를 반환합니다.

Python Java Go NodeJS cURL C++ 
from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

res = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit=3
)

import io.milvus.v2.service.vector.request.QueryReq
import io.milvus.v2.service.vector.request.QueryResp

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("color like \"red%\"")
        .outputFields(Arrays.asList("vector", "color"))
        .limit(3)
        .build();

QueryResp queryResp = client.query(queryReq);

List<QueryResp.QueryResult> results = queryResp.getQueryResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

// Output
// {color=red_7025, vector=[0.19886813, 0.060235605, 0.6976963, 0.26144746, 0.8387295], id=1}
// {color=red_4794, vector=[0.44523495, -0.8757027, 0.82207793, 0.4640629, 0.3033748], id=4}
// {color=red_9392, vector=[0.8371978, -0.015764369, -0.31062937, -0.56266695, -0.8984948], id=6}

resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithFilter("color like \"red%\"").
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())


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

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

const res = client.query({
    collection_name="my_collection",
    filter='color like "red%"',
    output_fields=["vector", "color"],
    limit(3)
})

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "filter": "color like \"red%\"",
    "limit": 3,
    "outputFields": ["vector", "color"]
}'
#{"code":0,"cost":0,"data":[{"color":"red_7025","id":1,"vector":[0.19886813,0.060235605,0.6976963,0.26144746,0.8387295]},{"color":"red_4794","id":4,"vector":[0.44523495,-0.8757027,0.82207793,0.4640629,0.3033748]},{"color":"red_9392","id":6,"vector":[0.8371978,-0.015764369,-0.31062937,-0.56266695,-0.8984948]}]}

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

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

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

auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("color like \"red%\"")
                   .WithLimit(3)
                   .AddOutputField("vector")
                   .AddOutputField("color");

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

쿼리 결과 정렬Compatible with Milvus 3.0.x

기본적으로 Query는 결과를 지정되지 않은 순서로 반환합니다. order_by 매개변수를 사용하여 하나 이상의 스칼라 필드 기준으로 결과를 정렬할 수 있습니다. order_by 를 사용할 때는 다음 사항에 유의하십시오:

  • order_by limit 와 함께 사용해야 합니다.

  • 지원되는 필드 유형: INT8, INT16, INT32, INT64, FLOAT, DOUBLE, VARCHAR. 벡터, JSON 또는 ARRAY 필드를 기준으로 정렬하는 것은 지원되지 않습니다.

  • NULL이 허용되는 필드로 정렬할 경우, 오름차순(NULLS LAST)에서는 NULL 값이 맨 뒤에 배치되고, 내림차순(NULLS FIRST)에서는 맨 앞에 배치됩니다.

기본 정렬

order_by 매개변수에 "field_name:direction" 형식의 문자열 목록을 전달합니다. 이때 direction 값은 asc (오름차순) 또는 desc (내림차순) 중 하나여야 합니다. asc 및 desc 는 대소문자를 구분한다는 점에 유의하십시오.

Python Java Go NodeJS cURL C++ 
from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Sort results by id in ascending order
res = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit=3,
    order_by=["id:asc"],
)

// java

// go

// nodejs

# restful

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

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

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

// Sort results by id in ascending order
auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("color like \"red%\"")
                   .WithLimit(3)
                   .WithOrderBy("id:asc")
                   .AddOutputField("vector")
                   .AddOutputField("color");

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

다중 필드 정렬

한 번에 여러 필드 기준으로 정렬할 수 있습니다. 결과는 먼저 목록의 첫 번째 필드 순서대로 정렬됩니다. 두 행이 해당 필드에서 동일한 값을 가질 경우, 두 번째 필드가 순서를 결정하며, 이 과정이 반복됩니다.

Python Java Go NodeJS cURL C++ 
# Sort by rating descending, then by price ascending for ties
res = client.query(
    collection_name="my_collection",
    filter="",
    output_fields=["color", "rating", "price"],
    limit=10,
    order_by=["rating:desc", "price:asc"],
)

// java

// go

// nodejs

# restful

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

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

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

// Sort by rating descending, then by price ascending for ties
auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("")
                   .WithLimit(10)
                   .WithOrderBy("rating:desc")
                   .WithOrderBy("price:asc")
                   .AddOutputField("color")
                   .AddOutputField("rating")
                   .AddOutputField("price");

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

정렬을 포함한 페이지 나누기

order_by 를 limit 및 offset 와 함께 사용하여 정렬된 결과를 페이지 단위로 표시할 수 있습니다. 예를 들어, 가격 순으로 정렬된 상품 목록을 여러 페이지에 걸쳐 표시할 경우, 각 페이지에는 중복이나 누락 없이 정확한 가격 순서대로 다음 배치의 상품이 표시됩니다.

Python Java Go NodeJS cURL C++ 
# Page 1
page1 = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["color", "price"],
    limit=5,
    offset=0,
    order_by=["price:asc"],
)

# Page 2
page2 = client.query(
    collection_name="my_collection",
    filter="color like \"red%\"",
    output_fields=["color", "price"],
    limit=5,
    offset=5,
    order_by=["price:asc"],
)

// java

// go

// nodejs

# restful

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

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

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

// Page 1
auto request1 = milvus::QueryRequest()
                    .WithCollectionName("my_collection")
                    .WithFilter("color like \"red%\"")
                    .WithLimit(5)
                    .WithOffset(0)
                    .WithOrderBy("price:asc")
                    .AddOutputField("color")
                    .AddOutputField("price");

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

// Page 2
auto request2 = milvus::QueryRequest()
                    .WithCollectionName("my_collection")
                    .WithFilter("color like \"red%\"")
                    .WithLimit(5)
                    .WithOffset(5)
                    .WithOrderBy("price:asc")
                    .AddOutputField("color")
                    .AddOutputField("price");

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

쿼리 결과 집계Compatible with Milvus 3.0.x

하나 이상의 스칼라 필드를 기준으로 쿼리 결과를 그룹화하고, 그룹별로 집계 값을 계산할 수 있습니다. 지원되는 집계 연산자는 count, min, max, sum 및 avg 입니다.

group_by_fields 를 사용할 때는 다음 사항에 유의하십시오.

  • group_by_fields 에서 지원하는 필드 유형: INT8, INT16, INT32, INT64, VARCHAR 및 TIMESTAMPTZ. FLOAT, DOUBLE, vector, JSON 또는 ARRAY 필드를 기준으로 그룹화하면 오류가 발생합니다.

  • sum avg 은 숫자형 필드에만 사용할 수 있습니다. 및 를 포함한 숫자형 필드에는 적용할 수 있지만, 필드에 적용하면 오류가 발생합니다. FLOAT DOUBLE VARCHAR

집계를 사용하려면 group_by_fields 를 query() 에 전달하고, 집계 표현식(count(*), count(<field>), min(<field>), max(<field>), sum(<field>), avg(<field>))을 output_fields 에 추가하십시오.

다음 예제는 ‘ color ’ 필드를 기준으로 엔티티를 그룹화하고, 각 색상 그룹에 속한 엔티티의 수를 반환합니다:

Python Java Go NodeJS cURL C++ 
from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

res = client.query(
    collection_name="my_collection",
    filter="",
    group_by_fields=["color"],
    output_fields=["color", "count(*)"],
)

# [{'color': 'red',    'count(*)': 10},
#  {'color': 'orange', 'count(*)': 10},
#  {'color': 'yellow', 'count(*)': 10},
#  {'color': 'green',  'count(*)': 10},
#  {'color': 'blue',   'count(*)': 10}]

// java

// go

// nodejs

# restful

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

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

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

auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("")
                   .WithGroupByFields({"color"})
                   .AddOutputField("color")
                   .AddOutputField("count(*)");

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

단일 호출로 여러 집계 표현식을 요청할 수 있습니다. 다음 예제는 color 을 기준으로 그룹화하고, 각 그룹의 엔티티 수, 평균 가격 및 최고 평점을 반환합니다:

Python Java Go NodeJS cURL C++ 
res = client.query(
    collection_name="my_collection",
    filter="",
    group_by_fields=["color"],
    output_fields=["color", "count(*)", "avg(price)", "max(rating)"],
)

# [{'color': 'red',    'count(*)': 10, 'avg(price)': 65.22, 'max(rating)': 5},
#  {'color': 'orange', 'count(*)': 10, 'avg(price)': 48.67, 'max(rating)': 5},
#  {'color': 'yellow', 'count(*)': 10, 'avg(price)': 64.15, 'max(rating)': 3},
#  {'color': 'green',  'count(*)': 10, 'avg(price)': 58.28, 'max(rating)': 5},
#  {'color': 'blue',   'count(*)': 10, 'avg(price)': 50.20, 'max(rating)': 5}]

// java

// go

// nodejs

# restful

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

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

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

auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("")
                   .WithGroupByFields({"color"})
                   .AddOutputField("color")
                   .AddOutputField("count(*)")
                   .AddOutputField("avg(price)")
                   .AddOutputField("max(rating)");

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

group_by_fields (color, rating) 에 두 개 이상의 필드를 전달하여 복합 그룹을 계산할 수 있습니다. 다음 예제는 로 그룹화하여 각 그룹의 가격 범위를 계산합니다:

Python Java Go NodeJS cURL C++ 
res = client.query(
    collection_name="my_collection",
    filter="",
    group_by_fields=["color", "rating"],
    output_fields=["color", "rating", "min(price)", "max(price)"],
)

# [{'color': 'red',    'rating': 5, 'min(price)': 34.51, 'max(price)': 70.90},
#  {'color': 'orange', 'rating': 2, 'min(price)': 12.39, 'max(price)': 81.99},
#  {'color': 'yellow', 'rating': 2, 'min(price)': 22.62, 'max(price)': 88.24},
#  {'color': 'green',  'rating': 1, 'min(price)': 18.35, 'max(price)': 59.53},
#  {'color': 'blue',   'rating': 4, 'min(price)': 21.23, 'max(price)': 82.45},
#  ...]

// java

// go

// nodejs

# restful

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

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

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

auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("")
                   .WithGroupByFields({"color", "rating"})
                   .AddOutputField("color")
                   .AddOutputField("rating")
                   .AddOutputField("min(price)")
                   .AddOutputField("max(price)");

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

또한 ` group_by_fields `를 ` limit `와 결합하여 반환되는 그룹의 수를 제한할 수 있습니다. 이는 필드의 카디널리티가 높고 그룹의 표본만 필요한 경우에 유용합니다:

Python Java Go NodeJS cURL C++ 
res = client.query(
    collection_name="my_collection",
    filter="",
    group_by_fields=["color"],
    output_fields=["color", "avg(price)", "count(*)"],
    limit=5,
)

# [{'color': 'red',    'avg(price)': 65.22, 'count(*)': 10},
#  {'color': 'orange', 'avg(price)': 48.67, 'count(*)': 10},
#  {'color': 'yellow', 'avg(price)': 64.15, 'count(*)': 10},
#  {'color': 'green',  'avg(price)': 58.28, 'count(*)': 10},
#  {'color': 'blue',   'avg(price)': 50.20, 'count(*)': 10}]

// java

// go

// nodejs

# restful

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

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

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

auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("")
                   .WithGroupByFields({"color"})
                   .AddOutputField("color")
                   .AddOutputField("avg(price)")
                   .AddOutputField("count(*)")
                   .WithLimit(5);

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

QueryIterator 사용

페이지 단위 쿼리를 통해 사용자 정의 필터링 조건에 따라 엔티티를 찾아야 하는 경우, QueryIterator를 생성하고 next() 메서드를 사용하여 모든 엔티티를 순회하며 필터링 조건을 충족하는 엔티티를 찾으십시오. 다음 코드 예제는 id, vector, color 라는 세 개의 필드가 있다고 가정하며, red 로 시작하는 color 값을 가진 모든 엔티티를 반환합니다.

Python Java Go NodeJS cURL C++ 
iterator = client.query_iterator(
    "my_collection",
    batch_size=10,
    filter="color like \"red%\"",
    output_fields=["color"]
)

results = []

while True:
    result = iterator.next()
    if not result:
        iterator.close()
        break

    print(result)
    results += result

import io.milvus.orm.iterator.QueryIterator;
import io.milvus.response.QueryResultsWrapper;
import io.milvus.v2.common.ConsistencyLevel;
import io.milvus.v2.service.vector.request.QueryIteratorReq;

QueryIteratorReq req = QueryIteratorReq.builder()
        .collectionName("my_collection")
        .expr("color like \"red%\"")
        .batchSize(10L)
        .outputFields(Collections.singletonList("color"))
        .build();
QueryIterator queryIterator = client.queryIterator(req);

while (true) {
    List<QueryResultsWrapper.RowRecord> res = queryIterator.next();
    if (res.isEmpty()) {
        queryIterator.close();
        break;
    }

    for (QueryResultsWrapper.RowRecord record : res) {
        System.out.println(record);
    }
}

// Output
// [color:red_7025, id:1]
// [color:red_4794, id:4]
// [color:red_9392, id:6]

// go

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

const iterator = await milvusClient.queryIterator({
  collection_name: 'my_collection',
  batchSize: 10,
  expr: 'color like "red%"',
  output_fields: ['color'],
});

const results = [];
for await (const value of iterator) {
  results.push(...value);
  page += 1;
}

# Not available

// C++ QueryIterator is not supported in the current SDK.

파티션 내 쿼리

Get, Query 또는 QueryIterator 요청에 파티션 이름을 포함시켜 하나 또는 여러 파티션 내에서 쿼리를 수행할 수도 있습니다. 다음 코드 예제는 컬렉션에 PartitionA라는 이름의 파티션이 있다고 가정합니다.

Python Java Go NodeJS cURL C++ 
res = client.get(
    collection_name="my_collection",
    partitionNames=["partitionA"],
    ids=[10, 11, 12],
    output_fields=["vector", "color"]
)

res = client.query(
    collection_name="my_collection",
    partitionNames=["partitionA"],
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit=3
)

# Use QueryIterator
iterator = client.query_iterator(
    "my_collection",
    partition_names=["partitionA"],
    batch_size=10,
    filter="color like \"red%\"",
    output_fields=["color"]
)

results = []
while True:
    result = iterator.next()
    if not result:
        iterator.close()
        break

    print(result)
    results += result


GetReq getReq = GetReq.builder()
        .collectionName("my_collection")
        .partitionName("partitionA")
        .ids(Arrays.asList(10, 11, 12))
        .outputFields(Collections.singletonList("color"))
        .build();

GetResp getResp = client.get(getReq);

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .filter("color like \"red%\"")
        .outputFields(Collections.singletonList("color"))
        .limit(3)
        .build();

QueryResp getResp = client.query(queryReq);

QueryIteratorReq req = QueryIteratorReq.builder()
        .collectionName("my_collection")
        .partitionNames(Collections.singletonList("partitionA"))
        .expr("color like \"red%\"")
        .batchSize(50L)
        .outputFields(Collections.singletonList("color"))
        .consistencyLevel(ConsistencyLevel.BOUNDED)
        .build();
QueryIterator queryIterator = client.queryIterator(req);

resultSet, err := client.Get(ctx, milvusclient.NewQueryOption("my_collection").
    WithPartitions("partitionA").
    WithIDs(column.NewColumnInt64("id", []int64{10, 11, 12})).
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())

resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithPartitions("partitionA").
    WithFilter("color like \"red%\"").
    WithOutputFields("vector", "color"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("vector: ", resultSet.GetColumn("vector").FieldData().GetVectors())
fmt.Println("color: ", resultSet.GetColumn("color").FieldData().GetScalars())

// Use get
var res = client.get({
    collection_name="my_collection",
    partition_names=["partitionA"],
    ids=[10,11,12],
    output_fields=["vector", "color"]
})

// Use query
res = client.query({
    collection_name="my_collection",
    partition_names=["partitionA"],
    filter="color like \"red%\"",
    output_fields=["vector", "color"],
    limit(3)
})

// Use queryiterator
const iterator = await milvusClient.queryIterator({
  collection_name: 'my_collection',
  partition_names: ['partitionA'],
  batchSize: 10,
  expr: 'color like "red%"',
  output_fields: ['vector', 'color'],
});

const results = [];
for await (const value of iterator) {
  results.push(...value);
  page += 1;
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

# Use get
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/get" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"],
    "id": [10, 11, 12],
    "outputFields": ["vector", "color"]
}'

# Use query
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/get" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "partitionNames": ["partitionA"],
    "filter": "color like \"red%\"",
    "limit": 3,
    "outputFields": ["vector", "color"],
    "id": [0, 1, 2]
}'

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

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

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

// Get entities from a partition
auto getRequest = milvus::GetRequest()
                      .WithCollectionName("my_collection")
                      .WithPartitionNames({"partitionA"})
                      .WithIDs({10, 11, 12})
                      .AddOutputField("vector")
                      .AddOutputField("color");

milvus::GetResponse getResponse;
status = client->Get(getRequest, getResponse);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

// Query a partition
auto queryRequest = milvus::QueryRequest()
                        .WithCollectionName("my_collection")
                        .WithPartitionNames({"partitionA"})
                        .WithFilter("color like \"red%\"")
                        .WithLimit(3)
                        .AddOutputField("vector")
                        .AddOutputField("color");

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

쿼리를 이용한 무작위 표본 추출

데이터 탐색이나 개발 테스트를 위해 컬렉션에서 대표적인 데이터 하위 집합을 추출하려면 ` RANDOM_SAMPLE(sampling_factor) ` 표현식을 사용합니다. 여기서 ` sampling_factor `는 샘플링할 데이터의 비율을 나타내는 0과 1 사이의 부동 소수점 수입니다.

자세한 사용법, 고급 예제 및 모범 사례는 ‘무작위 표본 추출’을 참조하십시오.

Python Java Go NodeJS cURL C++ 
# Sample 1% of the entire collection
res = client.query(
    collection_name="my_collection",
    filter="RANDOM_SAMPLE(0.01)",
    output_fields=["vector", "color"]
)

print(f"Sampled {len(res)} entities from collection")

# Combine with other filters - first filter, then sample
res = client.query(
    collection_name="my_collection", 
    filter="color like \"red%\" AND RANDOM_SAMPLE(0.005)",
    output_fields=["vector", "color"],
    limit=10
)

print(f"Found {len(res)} red items in sample")

import io.milvus.v2.service.vector.request.GetReq
import io.milvus.v2.service.vector.request.GetResp
import io.milvus.v2.service.vector.request.QueryReq
import io.milvus.v2.service.vector.request.QueryResp
import java.util.*;

QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("RANDOM_SAMPLE(0.01)")
        .outputFields(Arrays.asList("vector", "color"))
        .build();

QueryResp getResp = client.query(queryReq);
for (QueryResp.QueryResult result : getResp.getQueryResults()) {
    System.out.println(result.getEntity());
}

queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("color like \"red%\" AND RANDOM_SAMPLE(0.005)")
        .outputFields(Arrays.asList("vector", "color"))
        .limit(10)
        .build();

getResp = client.query(queryReq);
for (QueryResp.QueryResult result : getResp.getQueryResults()) {
    System.out.println(result.getEntity());
}

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithFilter("RANDOM_SAMPLE(0.01)").
    WithOutputFields("vector", "color"))
if err != nil {
    return err
}

resultSet, err = client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithFilter("color like \"red%\" AND RANDOM_SAMPLE(0.005)").
    WithLimit(10).
    WithOutputFields("vector", "color"))
if err != nil {
    return err
}

// node

# restful

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

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

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

// Sample 1% of the entire collection
auto request1 = milvus::QueryRequest()
                    .WithCollectionName("my_collection")
                    .WithFilter("RANDOM_SAMPLE(0.01)")
                    .AddOutputField("vector")
                    .AddOutputField("color");

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

// Combine with other filters - first filter, then sample
auto request2 = milvus::QueryRequest()
                    .WithCollectionName("my_collection")
                    .WithFilter("color like \"red%\" AND RANDOM_SAMPLE(0.005)")
                    .WithLimit(10)
                    .AddOutputField("vector")
                    .AddOutputField("color");

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

쿼리에 대한 시간대 일시적으로 설정

컬렉션에 TIMESTAMPTZ 필드가 있는 경우, 쿼리 호출 시 timezone 매개변수를 설정하여 단일 작업에 대해 데이터베이스 또는 컬렉션의 기본 시간대를 일시적으로 재정의할 수 있습니다. 이는 작업 중 TIMESTAMPTZ 값이 표시되고 비교되는 방식을 제어합니다.

timezone 의 값은 유효한 IANA 시간대 식별자 (예: Asia/Shanghai, America/Chicago 또는 UTC)여야 합니다. TIMESTAMPTZ 필드 사용 방법에 대한 자세한 내용은 TIMESTAMPTZ 필드를 참조하십시오.

다음 예제는 쿼리 작업에 대해 시간대를 일시적으로 설정하는 방법을 보여줍니다:

Python Java NodeJS Go cURL C++ 
# Query data and display the tsz field converted to "America/Havana"
results = client.query(
    "my_collection",
    filter="id <= 10",
    output_fields=["id", "tsz", "vec"],
    limit=2,
    timezone="America/Havana",
)

import io.milvus.v2.service.vector.request.QueryReq
import io.milvus.v2.service.vector.request.QueryResp
import java.util.*;

// Query data and display the tsz field converted to "America/Havana"
QueryReq queryReq = QueryReq.builder()
        .collectionName("my_collection")
        .filter("id <= 10")
        .outputFields(Arrays.asList("id", "tsz", "vec"))
        .limit(2)
        .timeZone("America/Havana")
        .build();

QueryResp queryResp = client.query(queryReq);

List<QueryResp.QueryResult> results = queryResp.getQueryResults();
for (QueryResp.QueryResult result : results) {
    System.out.println(result.getEntity());
}

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

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

// Query data and display the tsz field converted to "America/Havana"
const res = await client.query({
    collection_name: "my_collection",
    filter: 'id <= 10',
    output_fields: ["id", "tsz", "vec"],
    limit: 2,
    timezone: "America/Havana"
});

import (
    "context"
    "fmt"

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

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

milvusAddr := "localhost:19530"
client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: milvusAddr,
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

// Query data and display the tsz field converted to "America/Havana"
resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("my_collection").
    WithFilter("id <= 10").
    WithLimit(2).
    WithTimeZone("America/Havana").
    WithOutputFields("id", "tsz", "vec"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

fmt.Println("id: ", resultSet.GetColumn("id").FieldData().GetScalars())
fmt.Println("tsz: ", resultSet.GetColumn("tsz").FieldData().GetScalars())
fmt.Println("vec: ", resultSet.GetColumn("vec").FieldData().GetVectors())

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

# Query data and display the tsz field converted to "America/Havana"
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/query" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "collectionName": "my_collection",
    "filter": "id <= 10",
    "limit": 2,
    "outputFields": ["id", "tsz", "vec"],
    "timezone": "America/Havana"
}'

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

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

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

// Query data and display the tsz field converted to "America/Havana"
auto request = milvus::QueryRequest()
                   .WithCollectionName("my_collection")
                   .WithFilter("id <= 10")
                   .WithLimit(2)
                   .WithTimeZone("America/Havana")
                   .AddOutputField("id")
                   .AddOutputField("tsz")
                   .AddOutputField("vec");

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

번역DeepL

목차 목록

관리형 Milvus를 무료로 사용해 보세요

Zilliz Cloud는 번거로움이 없으며, Milvus 기반으로 10배 더 빠릅니다.

시작하기
피드백

이 페이지가 도움이 되었나요?