Primärfeld und AutoID

Jede Sammlung in Milvus muss ein Primärfeld haben, um jede Entität eindeutig zu identifizieren. Dieses Feld stellt sicher, dass jede Entität eingefügt, aktualisiert, abgefragt oder gelöscht werden kann, ohne dass es zu Mehrdeutigkeiten kommt.

Je nach Anwendungsfall können Sie entweder Milvus automatisch IDs generieren lassen (AutoID) oder Ihre eigenen IDs manuell zuweisen.

Was ist ein Primärfeld?

Ein Primärfeld fungiert als eindeutiger Schlüssel für jede Entität in einer Sammlung, ähnlich wie ein Primärschlüssel in einer herkömmlichen Datenbank. Milvus verwendet das Primärfeld, um Entitäten während Einfüge-, Upsert-, Lösch- und Abfrageoperationen zu verwalten.

Schlüssel-Anforderungen:

• Jede Sammlung muss genau ein Primärfeld haben.

• Primärfeldwerte können nicht null sein.

• Der Datentyp muss bei der Erstellung angegeben werden und kann später nicht mehr geändert werden.

Unterstützte Datentypen

Für das Primärfeld muss ein unterstützter skalarer Datentyp verwendet werden, der Entitäten eindeutig identifizieren kann.

Datentyp	Beschreibung
INT64	64-Bit-Integer-Typ, der üblicherweise mit AutoID verwendet wird. Dies ist die empfohlene Option für die meisten Anwendungsfälle.
VARCHAR	String-Typ mit variabler Länge. Verwenden Sie diesen Typ, wenn Entitätskennungen von externen Systemen stammen (z. B. Produktcodes oder Benutzer-IDs). Erfordert die Eigenschaft max_length, um die maximal zulässige Anzahl von Bytes pro Wert zu definieren.

Wählen Sie zwischen AutoID und manuellen IDs

Milvus unterstützt zwei Modi für die Zuweisung von Primärschlüsselwerten.

Modus	Beschreibung	Empfohlen für
AutoID	Milvus erzeugt automatisch eindeutige Bezeichner für eingefügte oder importierte Entitäten.	Die meisten Szenarien, in denen Sie die IDs nicht manuell verwalten müssen.
Manuelle ID	Sie stellen selbst eindeutige IDs bereit, wenn Sie Daten einfügen oder importieren.	Wenn IDs mit externen Systemen oder bereits existierenden Datensätzen übereinstimmen müssen.

Schnellstart: AutoID verwenden

Sie können die ID-Generierung automatisch von Milvus durchführen lassen.

Schritt 1: Erstellen Sie eine Sammlung mit AutoID

Aktivieren Sie auto_id=True in Ihrer Primärfelddefinition. Milvus wird die ID-Generierung automatisch durchführen.

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.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 { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({
  address: "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,
});

// go

# 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' \
-d "{
    \"collectionName\": \"demo_autoid\",
    \"schema\": $SCHEMA
}"

Schritt 2: Daten einfügen

Wichtig! Fügen Sie die Primärfeldspalte nicht in Ihre Daten ein. Milvus generiert IDs automatisch.

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;

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());

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

// go

# 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' \
-d "{
    \"collectionName\": \"demo_autoid\",
    \"data\": $INSERT_DATA
}"

Manuelle IDs verwenden

Wenn Sie IDs manuell steuern müssen, deaktivieren Sie AutoID und geben Sie Ihre eigenen Werte ein.

Schritt 1: Erstellen Sie eine Sammlung ohne 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.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 { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({
  address: "localhost:19530",
  username: "username",
  password: "Aa12345!!",
});

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

const res = await client.createCollection({
  collection_name: "demo_autoid",
  schema: schema,
});

// go

# 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' \
-d "{
    \"collectionName\": \"demo_manual_ids\",
    \"schema\": $SCHEMA
}"

Schritt 2: Fügen Sie Daten mit Ihren IDs ein

Bei jedem Einfügevorgang müssen Sie die Primärfeldspalte mit einbeziehen.

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

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());

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_autoid",
    fields_data: data,
});

console.log(insert);

// go

# 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' \
-d "{
    \"collectionName\": \"demo_manual_ids\",
    \"data\": $INSERT_DATA
}"

Ihre Verantwortlichkeiten:

• Sicherstellen, dass alle IDs über alle Entitäten hinweg eindeutig sind

• Einbindung des Primärfelds in jeden Einfüge-/Importvorgang

• Behandeln Sie ID-Konflikte und die Erkennung von Duplikaten selbst

Erweiterte Nutzung

Migrieren Sie Daten mit vorhandenen AutoIDs

Um bestehende IDs während der Datenmigration zu erhalten, aktivieren Sie die Eigenschaft allow_insert_auto_id durch den Aufruf von alter_collection_properties. Wenn sie auf true gesetzt ist, akzeptiert Milvus vom Benutzer bereitgestellte IDs, auch wenn AutoID aktiviert ist.

Einzelheiten zur Konfiguration finden Sie unter Sammlung ändern.

Globale AutoID Eindeutigkeit über Cluster hinweg sicherstellen

Wenn Sie mehrere Milvus-Cluster betreiben, konfigurieren Sie eine eindeutige Cluster-ID für jeden Cluster, um sicherzustellen, dass sich AutoIDs nicht überschneiden.

Konfiguration: Bearbeiten Sie vor der Initialisierung Ihres Clusters die Konfiguration common.clusterID in milvus.yaml:

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

In dieser Konfiguration gibt clusterID den eindeutigen Bezeichner an, der bei der AutoID-Generierung verwendet wird und von 0 bis 7 reicht (unterstützt bis zu acht Cluster).

Referenz: Wie AutoID funktioniert

Wenn Sie verstehen, wie AutoID intern eindeutige Bezeichner generiert, können Sie Cluster-IDs korrekt konfigurieren und ID-bezogene Probleme beheben.

AutoID verwendet ein strukturiertes 64-Bit-Format, um die Einzigartigkeit zu gewährleisten:

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

Segment	Beschreibung
sign_bit	Reserviert für den internen Gebrauch
cluster_id	Identifiziert, welcher Cluster die ID generiert hat (Wertebereich: 0-7)
physical_ts	Zeitstempel in Millisekunden, wann die ID erzeugt wurde
logical_ts	Zähler zur Unterscheidung von IDs, die in der gleichen Millisekunde erstellt wurden