エンティティ数のカウント

この記事では、コレクション内のエンティティ数をカウントする方法を説明し、エンティティ数が実際の数と異なることがある理由を解説します。

概要

Zilliz Cloud では、コレクション内のエンティティ数をカウントする 2つの方法を提供しています。

• 出力フィールドに count(*) を指定したクエリ

  コレクション内の正確なエンティティ数を取得するには、この方法を使用し、次の点を確認してください。

  • 対象のコレクションをロードしていること。

  • クエリリクエストで consistency_level を Strong に設定していること。

  • output_field を ['count(*)'] に設定していること。

  このようなクエリを受け取ると、Zilliz Cloud はクエリノードにリクエストを送信し、すでにメモリにロードされているエンティティをカウントします。

  クエリで複数のパーティション名を指定すると、これらのパーティション内の対応するエンティティ数を取得できます。詳細については、Query with count(*) as the output field を参照してください。

• get_collection_stats() を使用する

  上記の方法を使用するとコレクションの正確な数を取得できますが、どこでも使用することはお勧めしません。この処理は基本的にクエリであり、頻繁に呼び出すとネットワークのジッターが発生したり、ビジネスに関連する検索やクエリに影響を与えたりする可能性があります。

  精度が主な関心事でない場合は、代わりに get_collection_stats() と get_partition_stats() を使用してください。この呼び出しはエンティティ数の推定値を返しますが、実行するために対象のコレクションをロードする必要はなく、内部トラッカーが記録した内容のみを報告するため、コストは無視できるほど小さくなります。

  参考として、すべてのデータ操作は非同期で実行されるため、内部トラッカーはエンティティ数をリアルタイムに反映できません。詳細については、Use get_collection_stats() を参照してください。

Notes

上記の両方の方法では、同じプライマリキーを持つエンティティを別々のエンティティとしてカウントします。

プログラムでエンティティ数を取得する代わりに、Zilliz Cloud コンソールでクラスター、コレクション、またはパーティションの数値を確認することもできます。詳細については、Entity counts on the Zilliz Cloud console を参照してください。

出力フィールドに count(*) を指定したクエリ

正確なエンティティ数を取得するには、コレクションをロードし、count(*) を出力フィールドとしてクエリを実行し、クエリの整合性レベルを Strong に設定します。

Python

python

# Count without the entities in growing segments
res = client.query(
    collection_name="test_collection",
    output_fields=['count(*)']
)

# Count with the entities in growing segments
res = client.query(
    collection_name="test_collection",
    output_fields=['count(*)'],
    consistency_level="Strong"
)

# Count the entities in a specific partition
res = client.query(
    collection_name="test_collection",
    output_fields=['count(*)'],
    partition_names=['_default']
)

# Get the entity count
print(res[0]['count(*)'])
# Output
# 20

Java

java

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

// Count without the entities in growing segments
QueryResp count = client.query(QueryReq.builder()
        .collectionName("test_collection")
        .filter("")
        .outputFields(Collections.singletonList("count(*)"))
        .build());

// Count with the entities in growing segments
count = client.query(QueryReq.builder()
        .collectionName("test_collection")
        .filter("")
        .outputFields(Collections.singletonList("count(*)"))
        .consistencyLevel(ConsistencyLevel.STRONG)
        .build());

// Count the entities in a specific partition
QueryResp countR = client.query(QueryReq.builder()
        .collectionName("test_collection")
        .filter("")
        .outputFields(Collections.singletonList("count(*)"))
        .partitionNames(Collections.singletonList("_default"))
        .build());

System.out.print(count.getQueryResults().get(0).getEntity().get("count(*)"));

// Output
// 20

Go

go

import (
    "context"
    "fmt"

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

// Count without the entities in growing segments
resultSet, err := client.Query(ctx, milvusclient.NewQueryOption("test_collection").
    WithFilter("").
    WithOutputFields("count(*)"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("count: ", resultSet.GetColumn("count(*)").FieldData().GetScalars())

// Count with the entities in growing segments
resultSet, err = client.Query(ctx, milvusclient.NewQueryOption("test_collection").
    WithFilter("").
    WithOutputFields("count(*)").
    WithConsistencyLevel(entity.ClStrong))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("count: ", resultSet.GetColumn("count(*)").FieldData().GetScalars())

// Count the entities in a specific partition
resultSet, err = client.Query(ctx, milvusclient.NewQueryOption("test_collection").
    WithFilter("").
    WithOutputFields("count(*)").
    WithPartitions("_default"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("count: ", resultSet.GetColumn("count(*)").FieldData().GetScalars())

Rust

rust

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

// 1. Connect to Milvus
let client = ClientV2::new(&ConnectConfig::new().uri("YOUR_CLUSTER_ENDPOINT").token("YOUR_CLUSTER_TOKEN")).await?;

// 2. Count without the entities in growing segments
let response = client
    .query(
        QueryRequest::builder()
            .collection_name("test_collection")
            .output_fields(["count(*)"])
            .build()?,
    )
    .await?;
println!("count: {}", response.results().rows()?.next().unwrap().get_i64("count(*)")?);

// 3. Count with the entities in growing segments
let response = client
    .query(
        QueryRequest::builder()
            .collection_name("test_collection")
            .output_fields(["count(*)"])
            .consistency_level(ConsistencyLevel::Strong)
            .build()?,
    )
    .await?;
println!("count: {}", response.results().rows()?.next().unwrap().get_i64("count(*)")?);

// 4. Count the entities in a specific partition
let response = client
    .query(
        QueryRequest::builder()
            .collection_name("test_collection")
            .output_fields(["count(*)"])
            .partition_names(["_default"])
            .build()?,
    )
    .await?;
println!("count: {}", response.results().rows()?.next().unwrap().get_i64("count(*)")?);

C++

c++

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

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

milvus::ConnectParam connect_param{"YOUR_CLUSTER_ENDPOINT", "YOUR_CLUSTER_TOKEN"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

auto request = milvus::QueryRequest()
                       .WithCollectionName("test_collection")
                       .AddOutputField("count(*)");

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

request = milvus::QueryRequest()
                   .WithCollectionName("test_collection")
                   .AddOutputField("count(*)")
                   .WithConsistencyLevel(milvus::ConsistencyLevel::STRONG);

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

request = milvus::QueryRequest()
                   .WithCollectionName("test_collection")
                   .AddOutputField("count(*)")
                   .AddPartitionName("_default");

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

NodeJS

javascript

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

const address = "YOUR_CLUSTER_ENDPOINT";
const token = "YOUR_CLUSTER_TOKEN";
const client = new MilvusClient({address, token});

// Count without the entities in growing segments
let res = await client.query({
    collection_name: "test_collection",
    output_fields: ["count(*)"]
});

// Count with the entities in growing segments
res = await client.query({
    collection_name: "test_collection",
    output_fields: ["count(*)"],
    consistency_level: 'Strong'
});

// Count the entities in a specific partition
res = await client.query({
    collection_name: "test_collection",
    output_fields: ["count(*)"],
    partition_names: ['_default']
});

// Get the entity count
console.log(res.data[0]['count(*)'])
// Output
// 20

CSharp

csharp

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Requests.Index;
using Milvus.Client.V2.Types;

// Count without the entities in growing segments
var count = await client.QueryAsync(new QueryReq
{
    CollectionName = "test_collection",
    Parameters = new QueryParameters { OutputFields = { "count(*)" } }
});

// Count with the entities in growing segments
count = await client.QueryAsync(new QueryReq
{
    CollectionName = "test_collection",
    Parameters = new QueryParameters
    {
        OutputFields = { "count(*)" },
        ConsistencyLevel = ConsistencyLevel.Strong
    }
});

// Count the entities in a specific partition
var countR = await client.QueryAsync(new QueryReq
{
    CollectionName = "test_collection",
    Parameters = new QueryParameters
    {
        OutputFields = { "count(*)" },
        PartitionNames = { "_default" }
    }
});

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

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": "test_collection",
    "filter": "",
    "outputFields": ["count(*)"]
}'
#{"code":0,"cost":0,"data":[{count: 20}]}

Use get_collection_stats()

As described above, the get_collection_stats() returns an estimated number of entities in a コレクション, which may differ from the actual entity count. You can use this as a reference without loading a コレクション.

The following example assumes that a コレクション named test_collection exists.

Python

python

from pymilvus import MilvusClient

# 1. Set up a milvus client
client = MilvusClient(
    uri="YOUR_CLUSTER_ENDPOINT",
    token="YOUR_CLUSTER_TOKEN"
)

# 2. Get the entity count of a collection
client.get_collection_stats(collection_name="test_collection")

# Output
# 
# {
#     'row_count': 1000
# }

# 3. Get the entity count of a partition
client.get_partition_stats(
    collection_name="test_collection",
    partition_name="_default"
)

# Output
# 
# {
#     'row_count': 1000
# }

Java

java

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
import io.milvus.v2.service.partition.request.GetPartitionStatsReq;
import io.milvus.v2.service.partition.response.GetPartitionStatsResp;

// 1. Set up a milvus client
MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("YOUR_CLUSTER_ENDPOINT")
        .token("YOUR_CLUSTER_TOKEN")
        .build());

// 2. Get the entity count of a collection
GetCollectionStatsResp stats = client.getCollectionStats(GetCollectionStatsReq.builder()
        .collectionName("test_collection")
        .build());
System.out.print(stats.getNumOfEntities());

// 3. Get the entity count of a partition
GetPartitionStatsResp partitionStats = client.getPartitionStats(GetPartitionStatsReq.builder()
        .collectionName("test_collection")
        .partitionName("_default")
        .build());
System.out.print(partitionStats.getNumOfEntities());

Go

go

import (
    "context"
    "fmt"

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

// 1. Get the entity count of a collection
stats, err := client.GetCollectionStats(ctx, milvusclient.NewGetCollectionStatsOption("test_collection"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("row_count: ", stats["row_count"])

// 2. Get the entity count of a partition
partitionStats, err := client.GetPartitionStats(ctx, milvusclient.NewGetPartitionStatsOption("test_collection", "_default"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
fmt.Println("row_count: ", partitionStats["row_count"])

Rust

rust

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

// 1. Connect to Milvus
let client = ClientV2::new(&ConnectConfig::new().uri("YOUR_CLUSTER_ENDPOINT").token("YOUR_CLUSTER_TOKEN")).await?;

// 2. Get the entity count of a collection
let stats = client
    .get_collection_stats(
        GetCollectionStatsRequest::builder()
            .collection_name("test_collection")
            .build()?,
    )
    .await?;
println!("row_count: {:?}", stats.row_count());

// 3. Get the entity count of a partition
let partition_stats = client
    .get_partition_stats(
        GetPartitionStatsRequest::builder()
            .collection_name("test_collection")
            .partition_name("_default")
            .build()?,
    )
    .await?;
println!("row_count: {:?}", partition_stats.row_count());

C++

c++

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

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

milvus::ConnectParam connect_param{"YOUR_CLUSTER_ENDPOINT", "YOUR_CLUSTER_TOKEN"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::GetCollectionStatsResponse response;
status = client->GetCollectionStats(milvus::GetCollectionStatsRequest()
                                    .WithCollectionName("test_collection"), response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

milvus::GetPartitionStatsResponse partition_response;
status = client->GetPartitionStatistics(milvus::GetPartitionStatsRequest()
                                        .WithCollectionName("test_collection")
                                        .WithPartitionName("_default"), partition_response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

std::cout << response.Stats().RowCount() << std::endl;
std::cout << partition_response.Stats().RowCount() << std::endl;

NodeJS

javascript

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

// 1. Set up a milvus client
const milvusClient = new MilvusClient({
    address: 'YOUR_CLUSTER_ENDPOINT',
    token: 'YOUR_CLUSTER_TOKEN'
});

// 2. Get the entity count
await milvusClient.getCollectionStats({
 collection_name: 'test_collection'
});

// 3. Get the entity count of a partition
await milvusClient.getPartitionStats({
 collection_name: 'test_collection',
 partition_name: '_default'
});

// Output
//
// {
//      data: {'row_count': 1000 }
// }

CSharp

csharp

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Requests.Index;
using Milvus.Client.V2.Types;

using Milvus.Client.V2.Requests.Partition;

// 1. Set up a Milvus client
var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "YOUR_CLUSTER_ENDPOINT",
    Username = "root",
    Password = "Milvus"
});

// 2. Get the entity count of a collection
var stats = await client.GetCollectionStatsAsync(new GetCollectionStatsReq { CollectionName = "test_collection" });
Console.WriteLine(stats.RowCount);

// 3. Get the entity count of a partition
var partitionStats = await client.GetPartitionStatsAsync(new GetPartitionStatsReq
{
    CollectionName = "test_collection",
    PartitionName = "_default"
});
Console.WriteLine(partitionStats.RowCount);

cURL

bash

export CLUSTER_ENDPOINT="YOUR_CLUSTER_ENDPOINT"
export TOKEN="YOUR_CLUSTER_TOKEN"

# Get the entity count of a collection
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/get_stats" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "test_collection"
}'
#{"code":0,"data":{"rowCount":1000}}

# Get the entity count of a partition
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/partitions/get_stats" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "test_collection",
    "partitionName": "_default"
}'
#{"code":0,"data":{"rowCount":1000}}

Zilliz Cloud コンソールでのエンティティ数

プログラムでエンティティをカウントする代わりに、Zilliz Cloud コンソールにアクセスして、次のページでクラスター、コレクション、またはパーティションのエンティティ数を確認することもできます。

Metrics

クラスターの Entity Count と Loaded Entities (Approx.) は、その Metrics タブで確認できます。どちらの値も推定値です。曲線内の値は、using get_collection_stats() で取得されます。以降にデータの挿入や削除がなければ、Entity Count の曲線は最終的に現在のコレクション内の実際のエンティティ数を反映します。

コレクション Details

コレクションの実際のエンティティ数は、その詳細タブで確認できます。この値は、queries with count(*) as the output field を使用して取得されます。

Partitions

コレクションの Partitions タブを使用して、その子パーティション内のロード済みエンティティの推定数を確認することもできます。この値は、get_partition_stats() を使用して取得されます。

よくある質問

• get_collection_stats() または get_partition_stats() を使用して取得したエンティティ数が、一部のエンティティを挿入した後に対象のコレクションまたはパーティション内の実際のエンティティ数を反映しないのはなぜですか？

  これらの方法は、内部トラッカーが記録した内容のみを報告します。すべてのデータ操作は非同期で実行されるため、これは実際のエンティティ数と異なる場合があります。

• エンティティを挿入または削除した後に、コレクションの Metrics タブにある Entity Count 曲線が変化しないのはなぜですか？

  Entity Count 曲線内の値は、特定の時点で推定されたものです。すべてのデータ操作は非同期で実行されるため、曲線に反映されるまでに遅延が生じることがあります。

• エンティティを挿入または削除した後に、コレクションの Partitions タブにある Entity Count (Approx.) 列に表示される値が変化しないのはなぜですか？

  一覧表示されたパーティションに表示される値は、すべて推定値です。すべてのデータ操作は非同期で実行されるため、曲線に反映されるまでに遅延が生じることがあります。

• コレクションの Overview タブにある Loaded Entities に表示される値が、コレクション内の実際のエンティティ数を反映しないのはなぜですか？

  Loaded Entities に表示される値は正確です。この値と通常のクエリで取得したエンティティ数との間に差がある場合、コレクション内の一部のエンティティが同じプライマリキーを持っている可能性があります。

  count(*) を出力フィールドとして使用するクエリでは、同じプライマリキーを持つエンティティを別々のエンティティとして扱いますが、その他のクエリでは、最終的な結果を返す前に同じプライマリキーを持つエンティティを省略します。