Kolom Utama & AutoID

Setiap koleksi di Milvus harus memiliki bidang utama untuk mengidentifikasi setiap entitas secara unik. Bidang ini memastikan bahwa setiap entitas dapat disisipkan, diperbarui, dicari, atau dihapus tanpa ambiguitas.

Tergantung pada kasus penggunaan Anda, Anda dapat membiarkan Milvus secara otomatis menghasilkan ID (AutoID) atau menetapkan ID Anda sendiri secara manual.

Apa itu bidang utama?

Kolom utama berfungsi sebagai kunci unik untuk setiap entitas dalam sebuah koleksi, mirip dengan kunci utama dalam basis data tradisional. Milvus menggunakan kolom utama untuk mengelola entitas selama operasi penyisipan, pembaruan, penghapusan, dan kueri.

Persyaratan utama:

• Setiap koleksi harus memiliki tepat satu bidang utama.

• Nilai bidang utama tidak boleh null.

• Tipe data harus ditentukan saat pembuatan dan tidak dapat diubah kemudian.

Tipe data yang didukung

Kolom utama harus menggunakan tipe data skalar yang didukung yang dapat mengidentifikasi entitas secara unik.

Tipe Data	Deskripsi
INT64	Tipe bilangan bulat 64-bit, umumnya digunakan dengan AutoID. Ini adalah opsi yang direkomendasikan untuk sebagian besar kasus penggunaan.
VARCHAR	Tipe string panjang variabel. Gunakan ini ketika pengidentifikasi entitas berasal dari sistem eksternal (misalnya, kode produk atau ID pengguna). Membutuhkan properti ` max_length ` untuk menentukan jumlah byte maksimum yang diperbolehkan per nilai.

Pilih antara AutoID dan ID Manual

Milvus mendukung dua mode untuk menetapkan nilai kunci utama.

Mode	Deskripsi	Direkomendasikan Untuk
AutoID	Milvus secara otomatis menghasilkan pengenal unik untuk entitas yang disisipkan atau diimpor.	Sebagian besar skenario di mana Anda tidak perlu mengelola ID secara manual.
ID Manual	Anda sendiri yang menentukan ID unik saat menyisipkan atau mengimpor data.	Hal ini berlaku ketika ID harus selaras dengan sistem eksternal atau kumpulan data yang sudah ada sebelumnya.

Panduan Cepat: Gunakan AutoID

Anda dapat membiarkan Milvus menangani pembuatan ID secara otomatis.

Langkah 1: Buat koleksi dengan AutoID

Aktifkan " auto_id=True " pada definisi kolom utama Anda. Milvus akan menangani pembuatan ID secara otomatis.

from pymilvus import MilvusClient, DataType

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

schema = client.create_schema()

# Define primary field with AutoID enabled
schema.add_field(
    field_name="id", # Primary field name
    is_primary=True,
    auto_id=True,  # Milvus generates IDs automatically; Defaults to False
    datatype=DataType.INT64
)

# Define the other fields
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=4) # Vector field
schema.add_field(field_name="category", datatype=DataType.VARCHAR, max_length=1000) # Scalar field of the VARCHAR type

# Create the collection
if client.has_collection("demo_autoid"):
    client.drop_collection("demo_autoid")
client.create_collection(collection_name="demo_autoid", schema=schema)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.DropCollectionReq;

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

CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
        .build();
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(true)
        .build());
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("embedding")
        .dataType(DataType.FloatVector)
        .dimension(4)
        .build());
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("category")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .build());

client.dropCollection(DropCollectionReq.builder()
        .collectionName("demo_autoid")
        .build());

CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("demo_autoid")
        .collectionSchema(collectionSchema)
        .build();
client.createCollection(requestCreate);

import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"
    "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:", err)
}
defer cli.Close(ctx)

schema := &entity.Schema{
        CollectionName: "demo_autoid",
        Fields: []*entity.Field{
                entity.NewField().WithName("id").WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true),
                entity.NewField().WithName("embedding").WithDataType(entity.FieldTypeFloatVector).WithDim(4),
                entity.NewField().WithName("category").WithDataType(entity.FieldTypeVarChar).WithMaxLength(1000),
        },
}

cli.DropCollection(ctx, milvusclient.NewDropCollectionOption("demo_autoid"))

err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption("demo_autoid", schema))
if err != nil {
        log.Fatal("failed to create collection:", err)
}

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

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

let schema = CollectionSchema::new()
    .add_field(
        FieldSchema::new()
            .name("id")
            .data_type(DataType::Int64)
            .primary_key(true)
            .auto_id(true),
    )
    .add_field(
        FieldSchema::new()
            .name("embedding")
            .data_type(DataType::FloatVector)
            .dimension(4),
    )
    .add_field(
        FieldSchema::new()
            .name("category")
            .data_type(DataType::VarChar)
            .max_length(1000),
    );

if client
    .has_collection(
        HasCollectionRequest::builder()
            .collection_name("demo_autoid")
            .build()?,
    )
    .await?
    .exists()
{
    client
        .drop_collection(
            DropCollectionRequest::builder()
                .collection_name("demo_autoid")
                .build()?,
        )
        .await?;
}

client
    .create_collection(
        CreateCollectionRequest::builder()
            .collection_name("demo_autoid")
            .schema(schema)
            .build()?,
    )
    .await?;

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

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;
}

milvus::CollectionSchemaPtr schema = std::make_shared<milvus::CollectionSchema>();
schema->AddField({"id", milvus::DataType::INT64, "Primary field", true, true});
schema->AddField(milvus::FieldSchema("embedding", milvus::DataType::FLOAT_VECTOR, "Vector field").WithDimension(4));
schema->AddField(milvus::FieldSchema("category", milvus::DataType::VARCHAR, "Scalar field").WithMaxLength(1000));

status = client->DropCollection(milvus::DropCollectionRequest().WithCollectionName("demo_autoid"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

status = client->CreateCollection(milvus::CreateCollectionRequest()
                                    .WithCollectionName("demo_autoid")
                                    .WithCollectionSchema(schema));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

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

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

// Define schema fields
const schema = [
  {
    name: "id",
    description: "Primary field",
    data_type: DataType.Int64,
    is_primary_key: true,
    autoID: true, // Milvus generates IDs automatically
  },
  {
    name: "embedding",
    description: "Vector field",
    data_type: DataType.FloatVector,
    dim: 4,
  },
  {
    name: "category",
    description: "Scalar field",
    data_type: DataType.VarChar,
    max_length: 1000,
  },
];

// Create the collection
await client.createCollection({
  collection_name: "demo_autoid",
  fields: schema,
});

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

var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

var schema = new CollectionSchema
{
    Fields =
    {
        new FieldSchema("id", DataType.Int64, isPrimaryKey: true, autoId: true), // Milvus generates IDs automatically
        FieldSchema.CreateFloatVector("embedding", dimension: 4), // Vector field
        FieldSchema.CreateVarchar("category", maxLength: 1000) // Scalar field of the VARCHAR type
    }
};

if ((await client.HasCollectionAsync(new HasCollectionReq { CollectionName = "demo_autoid" })).Has)
{
    await client.DropCollectionAsync(new DropCollectionReq { CollectionName = "demo_autoid" });
}

await client.CreateCollectionAsync(new CreateCollectionReq
{
    CollectionName = "demo_autoid",
    Schema = schema
});

# restful
export SCHEMA='{
    "autoID": true,
    "fields": [
        {
            "fieldName": "id",
            "dataType": "Int64",
            "isPrimary": true,
            "elementTypeParams": {}
        },
        {
            "fieldName": "embedding",
            "dataType": "FloatVector",
            "isPrimary": false,
            "elementTypeParams": {
                "dim": "4"
            }
        },
        {
            "fieldName": "category",
            "dataType": "VarChar",
            "isPrimary": false,
            "elementTypeParams": {
                "max_length": "1000"
            }
        }
    ]
}'

curl -X POST 'http://localhost:19530/v2/vectordb/collections/create' \
-H 'Content-Type: application/json' \
-H "Request-Timeout: 10" \
-d "{
    \"collectionName\": \"demo_autoid\",
    \"schema\": $SCHEMA
}"

Langkah 2: Masukkan Data

Penting: Jangan sertakan kolom bidang utama dalam data Anda. Milvus akan menghasilkan ID secara otomatis.

data = [
    {"embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"},
    {"embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"},
]

res = client.insert(collection_name="demo_autoid", data=data)
print("Generated IDs:", res.get("ids"))

# Output example:
# Generated IDs: [461526052788333649, 461526052788333650]

import com.google.gson.*;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;
import java.util.ArrayList;
import java.util.List;

List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
JsonObject row1 = new JsonObject();
row1.add("embedding", gson.toJsonTree(new float[]{0.1f, 0.2f, 0.3f, 0.4f}));
row1.addProperty("category", "book");
rows.add(row1);

JsonObject row2 = new JsonObject();
row2.add("embedding", gson.toJsonTree(new float[]{0.2f, 0.3f, 0.4f, 0.5f}));
row2.addProperty("category", "toy");
rows.add(row2);

InsertResp insertR = client.insert(InsertReq.builder()
        .collectionName("demo_autoid")
        .data(rows)
        .build());
System.out.printf("Generated IDs: %s\n", insertR.getPrimaryKeys());

import (
    "fmt"
    "log"

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

data := []any{
        map[string]any{"embedding": []float32{0.1, 0.2, 0.3, 0.4}, "category": "book"},
        map[string]any{"embedding": []float32{0.2, 0.3, 0.4, 0.5}, "category": "toy"},
}

result, err := cli.Insert(ctx, milvusclient.NewRowBasedInsertOption("demo_autoid", data...))
if err != nil {
        log.Fatal("failed to insert:", err)
}
for i := 0; i < result.IDs.Len(); i++ {
        id, _ := result.IDs.GetAsInt64(i)
        fmt.Println("Generated ID:", id)
}

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

client
    .insert(
        InsertRequest::builder()
            .collection_name("demo_autoid")
            .rows([
                serde_json::json!({"embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"}),
                serde_json::json!({"embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"}),
            ])
            .build()?,
    )
    .await?;

#include <iostream>

milvus::EntityRows data = {{{"embedding", std::vector<float>{0.1, 0.2, 0.3, 0.4}}, {"category", "book"}},
                           {{"embedding", std::vector<float>{0.2, 0.3, 0.4, 0.5}}, {"category", "toy"}}};

milvus::InsertResponse response;
auto status = client->Insert(milvus::InsertRequest()
                                .WithCollectionName("demo_autoid")
                                .WithRowsData(std::move(data))
                                , response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
auto ids = response.Results().IdArray().IntIDArray();

const data = [
    {"embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"},
    {"embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"},
];

const res = await client.insert({
    collection_name: "demo_autoid",
    fields_data: data,
});

console.log(res);

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Responses.Dml;
using Milvus.Client.V2.Types;

var data = new[]
{
    new Dictionary<string, object?>
    {
        ["embedding"] = new[] { 0.1f, 0.2f, 0.3f, 0.4f },
        ["category"] = "book"
    },
    new Dictionary<string, object?>
    {
        ["embedding"] = new[] { 0.2f, 0.3f, 0.4f, 0.5f },
        ["category"] = "toy"
    }
};

MutationResp res = await client.InsertAsync(new InsertReq
{
    CollectionName = "demo_autoid",
    RowsData = data
});
Console.WriteLine("Generated IDs: " + string.Join(", ", res.LongIds ?? []));

# restful
export INSERT_DATA='[
    {
        "embedding": [0.1, 0.2, 0.3, 0.4],
        "category": "book"
    },
    {
        "embedding": [0.2, 0.3, 0.4, 0.5],
        "category": "toy"
    }
]'

curl -X POST 'http://localhost:19530/v2/vectordb/entities/insert' \
-H 'Content-Type: application/json' \
-H "Request-Timeout: 10" \
-d "{
    \"collectionName\": \"demo_autoid\",
    \"data\": $INSERT_DATA
}"

Gunakan ID manual

Jika Anda perlu mengontrol ID secara manual, nonaktifkan AutoID dan masukkan nilai Anda sendiri.

Langkah 1: Buat koleksi tanpa AutoID

from pymilvus import MilvusClient, DataType

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

schema = client.create_schema()

# Define the primary field without AutoID
schema.add_field(
    field_name="product_id",
    is_primary=True,
    auto_id=False,  # You'll provide IDs manually at data ingestion
    datatype=DataType.VARCHAR,
    max_length=100 # Required when datatype is VARCHAR
)

# Define the other fields
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=4) # Vector field
schema.add_field(field_name="category", datatype=DataType.VARCHAR, max_length=1000) # Scalar field of the VARCHAR type

# Create the collection
if client.has_collection("demo_manual_ids"):
    client.drop_collection("demo_manual_ids")
client.create_collection(collection_name="demo_manual_ids", schema=schema)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.collection.request.DropCollectionReq;

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

CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
        .build();
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("product_id")
        .dataType(DataType.VarChar)
        .isPrimaryKey(true)
        .autoID(false)
        .maxLength(100)
        .build());
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("embedding")
        .dataType(DataType.FloatVector)
        .dimension(4)
        .build());
collectionSchema.addField(AddFieldReq.builder()
        .fieldName("category")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .build());

client.dropCollection(DropCollectionReq.builder()
        .collectionName("demo_manual_ids")
        .build());

CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("demo_manual_ids")
        .collectionSchema(collectionSchema)
        .build();
client.createCollection(requestCreate);

import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"
    "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:", err)
}
defer cli.Close(ctx)

schema := &entity.Schema{
        CollectionName: "demo_manual_ids",
        Fields: []*entity.Field{
                entity.NewField().WithName("product_id").WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(100),
                entity.NewField().WithName("embedding").WithDataType(entity.FieldTypeFloatVector).WithDim(4),
                entity.NewField().WithName("category").WithDataType(entity.FieldTypeVarChar).WithMaxLength(1000),
        },
}

cli.DropCollection(ctx, milvusclient.NewDropCollectionOption("demo_manual_ids"))

err = cli.CreateCollection(ctx, milvusclient.NewCreateCollectionOption("demo_manual_ids", schema))
if err != nil {
        log.Fatal("failed to create collection:", err)
}

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

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

let schema = CollectionSchema::new()
    .add_field(
        FieldSchema::new()
            .name("product_id")
            .data_type(DataType::VarChar)
            .primary_key(true)
            .max_length(100),
    )
    .add_field(
        FieldSchema::new()
            .name("embedding")
            .data_type(DataType::FloatVector)
            .dimension(4),
    )
    .add_field(
        FieldSchema::new()
            .name("category")
            .data_type(DataType::VarChar)
            .max_length(1000),
    );

if client
    .has_collection(
        HasCollectionRequest::builder()
            .collection_name("demo_manual_ids")
            .build()?,
    )
    .await?
    .exists()
{
    client
        .drop_collection(
            DropCollectionRequest::builder()
                .collection_name("demo_manual_ids")
                .build()?,
        )
        .await?;
}

client
    .create_collection(
        CreateCollectionRequest::builder()
            .collection_name("demo_manual_ids")
            .schema(schema)
            .build()?,
    )
    .await?;

#include <iostream>
#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;
}

milvus::CollectionSchemaPtr schema = std::make_shared<milvus::CollectionSchema>();
schema->AddField(milvus::FieldSchema("product_id", milvus::DataType::VARCHAR, "", true, false).WithMaxLength(100));
schema->AddField(milvus::FieldSchema("embedding", milvus::DataType::FLOAT_VECTOR).WithDimension(4));
schema->AddField(milvus::FieldSchema("category", milvus::DataType::VARCHAR).WithMaxLength(1000));

status = client->DropCollection(milvus::DropCollectionRequest().WithCollectionName("demo_manual_ids"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

status = client->CreateCollection(milvus::CreateCollectionRequest()
                                    .WithCollectionName("demo_manual_ids")
                                    .WithCollectionSchema(schema));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

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

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

const schema = [
  {
    name: "product_id",
    data_type: DataType.VarChar,
    is_primary_key: true,
    autoID: false,
    max_length: 100,
  },
  {
    name: "embedding",
    data_type: DataType.FloatVector,
    dim: 4,
  },
  {
    name: "category",
    data_type: DataType.VarChar,
    max_length: 1000,
  },
];

await client.createCollection({
  collection_name: "demo_manual_ids",
  fields: schema,
});

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

var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

var schema = new CollectionSchema
{
    Fields =
    {
        FieldSchema.CreateVarchar("product_id", maxLength: 100, isPrimaryKey: true, autoId: false), // You provide IDs manually
        FieldSchema.CreateFloatVector("embedding", dimension: 4), // Vector field
        FieldSchema.CreateVarchar("category", maxLength: 1000) // Scalar field of the VARCHAR type
    }
};

if ((await client.HasCollectionAsync(new HasCollectionReq { CollectionName = "demo_manual_ids" })).Has)
{
    await client.DropCollectionAsync(new DropCollectionReq { CollectionName = "demo_manual_ids" });
}

await client.CreateCollectionAsync(new CreateCollectionReq
{
    CollectionName = "demo_manual_ids",
    Schema = schema
});

# restful
export SCHEMA='{
    "autoID": false,
    "fields": [
        {
            "fieldName": "product_id",
            "dataType": "VarChar",
            "isPrimary": true,
            "elementTypeParams": {
                "max_length": "100"
            }
        },
        {
            "fieldName": "embedding",
            "dataType": "FloatVector",
            "isPrimary": false,
            "elementTypeParams": {
                "dim": "4"
            }
        },
        {
            "fieldName": "category",
            "dataType": "VarChar",
            "isPrimary": false,
            "elementTypeParams": {
                "max_length": "1000"
            }
        }
    ]
}'

curl -X POST 'http://localhost:19530/v2/vectordb/collections/create' \
-H 'Content-Type: application/json' \
-H "Request-Timeout: 10" \
-d "{
    \"collectionName\": \"demo_manual_ids\",
    \"schema\": $SCHEMA
}"

Langkah 2: Sisipkan data dengan ID Anda

Anda harus menyertakan kolom bidang utama dalam setiap operasi penyisipan.

# Each entity must contain the primary field `product_id`
data = [
    {"product_id": "PROD-001", "embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"},
    {"product_id": "PROD-002", "embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"},
]

res = client.insert(collection_name="demo_manual_ids", data=data)
print("Generated IDs:", res.get("ids"))

# Output example:
# Generated IDs: ['PROD-001', 'PROD-002']

import com.google.gson.*;
import io.milvus.v2.service.vector.request.InsertReq;
import io.milvus.v2.service.vector.response.InsertResp;
import java.util.ArrayList;
import java.util.List;

List<JsonObject> rows = new ArrayList<>();
Gson gson = new Gson();
JsonObject row1 = new JsonObject();
row1.addProperty("product_id", "PROD-001");
row1.add("embedding", gson.toJsonTree(new float[]{0.1f, 0.2f, 0.3f, 0.4f}));
row1.addProperty("category", "book");
rows.add(row1);

JsonObject row2 = new JsonObject();
row2.addProperty("product_id", "PROD-002");
row2.add("embedding", gson.toJsonTree(new float[]{0.2f, 0.3f, 0.4f, 0.5f}));
row2.addProperty("category", "toy");
rows.add(row2);

InsertResp insertR = client.insert(InsertReq.builder()
        .collectionName("demo_manual_ids")
        .data(rows)
        .build());
System.out.printf("Generated IDs: %s\n", insertR.getPrimaryKeys());

import (
    "fmt"
    "log"

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

data = []any{
        map[string]any{"product_id": "PROD-001", "embedding": []float32{0.1, 0.2, 0.3, 0.4}, "category": "book"},
        map[string]any{"product_id": "PROD-002", "embedding": []float32{0.2, 0.3, 0.4, 0.5}, "category": "toy"},
}

result, err = cli.Insert(ctx, milvusclient.NewRowBasedInsertOption("demo_manual_ids", data...))
if err != nil {
        log.Fatal("failed to insert:", err)
}
for i := 0; i < result.IDs.Len(); i++ {
        id, _ := result.IDs.GetAsString(i)
        fmt.Println("Inserted ID:", id)
}

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

client
    .insert(
        InsertRequest::builder()
            .collection_name("demo_manual_ids")
            .rows([
                serde_json::json!({"product_id": "PROD-001", "embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"}),
                serde_json::json!({"product_id": "PROD-002", "embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"}),
            ])
            .build()?,
    )
    .await?;

#include <iostream>

milvus::EntityRows data = {{{"product_id", "PROD-001"}, {"embedding", std::vector<float>{0.1, 0.2, 0.3, 0.4}}, {"category", "book"}},
                           {{"product_id", "PROD-002"}, {"embedding", std::vector<float>{0.2, 0.3, 0.4, 0.5}}, {"category", "toy"}}};

milvus::InsertResponse response;
auto status = client->Insert(milvus::InsertRequest()
                                .WithCollectionName("demo_manual_ids")
                                .WithRowsData(std::move(data))
                                , response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}
auto string_ids = response.Results().IdArray().StrIDArray();

const data = [
    {"product_id": "PROD-001", "embedding": [0.1, 0.2, 0.3, 0.4], "category": "book"},
    {"product_id": "PROD-002", "embedding": [0.2, 0.3, 0.4, 0.5], "category": "toy"},
];

const insert = await client.insert({
    collection_name: "demo_manual_ids",
    fields_data: data,
});

console.log(insert);

using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dml;
using Milvus.Client.V2.Responses.Dml;
using Milvus.Client.V2.Types;

// Each entity must contain the primary field `product_id`
var data = new[]
{
    new Dictionary<string, object?>
    {
        ["product_id"] = "PROD-001",
        ["embedding"] = new[] { 0.1f, 0.2f, 0.3f, 0.4f },
        ["category"] = "book"
    },
    new Dictionary<string, object?>
    {
        ["product_id"] = "PROD-002",
        ["embedding"] = new[] { 0.2f, 0.3f, 0.4f, 0.5f },
        ["category"] = "toy"
    }
};

MutationResp res = await client.InsertAsync(new InsertReq
{
    CollectionName = "demo_manual_ids",
    RowsData = data
});
Console.WriteLine("Generated IDs: " + string.Join(", ", res.StringIds ?? []));

# restful
export INSERT_DATA='[
    {
        "product_id": "PROD-001",
        "embedding": [0.1, 0.2, 0.3, 0.4],
        "category": "book"
    },
    {
        "product_id": "PROD-002",
        "embedding": [0.2, 0.3, 0.4, 0.5],
        "category": "toy"
    }
]'

# 插入数据
curl -X POST 'http://localhost:19530/v2/vectordb/entities/insert' \
-H 'Content-Type: application/json' \
-H "Request-Timeout: 10" \
-d "{
    \"collectionName\": \"demo_manual_ids\",
    \"data\": $INSERT_DATA
}"

Tanggung jawab Anda:

• Pastikan semua ID unik di seluruh entitas

• Sertakan kolom kunci utama dalam setiap operasi penyisipan/impor

• Tangani sendiri konflik ID dan deteksi duplikat

Penggunaan lanjutan

Migrasi data dengan AutoID yang sudah ada

Untuk mempertahankan ID yang sudah ada selama migrasi data, aktifkan properti ` allow_insert_auto_id ` dengan memanggil metode ` alter_collection_properties `. Jika disetel ke `true`, Milvus akan menerima ID yang disediakan pengguna meskipun AutoID diaktifkan.

Untuk detail konfigurasi, lihat Modify Collection.

Pastikan keunikan AutoID secara global di seluruh kluster

Saat menjalankan beberapa kluster Milvus, konfigurasikan ID kluster yang unik untuk masing-masing kluster guna memastikan AutoID tidak pernah tumpang tindih.

Konfigurasi: Edit konfigurasi ` common.clusterID ` di ` milvus.yaml ` sebelum menginisialisasi kluster Anda:

common:
  clusterID: 3   # Must be unique across all clusters (Range: 0-7)

Dalam konfigurasi ini, ` clusterID ` menentukan pengenal unik yang digunakan dalam pembangkitan AutoID, berkisar dari 0 hingga 7 (mendukung hingga delapan kluster).

Referensi: Cara Kerja AutoID

Memahami cara AutoID menghasilkan pengenal unik secara internal dapat membantu Anda mengonfigurasi ID kluster dengan benar dan memecahkan masalah terkait ID.

AutoID menggunakan format 64-bit terstruktur untuk menjamin keunikan:

[sign_bit][cluster_id][physical_ts][logical_ts]

Segmen	Deskripsi
sign_bit	Disediakan untuk penggunaan internal
cluster_id	Mengidentifikasi kluster mana yang menghasilkan ID tersebut (rentang nilai: 0–7)
physical_ts	Cap waktu dalam milidetik saat ID dihasilkan
logical_ts	Penghitung untuk membedakan ID yang dibuat dalam milidetik yang sama