milvus-logo
LFAI
Home
  • Benutzerhandbuch

Verwalten von Sammlungen

Dieser Leitfaden führt Sie durch die Erstellung und Verwaltung von Sammlungen mit dem SDK Ihrer Wahl.

Bevor Sie beginnen

Überblick

In Milvus speichern Sie Ihre Vektoreinbettungen in Sammlungen. Alle Vektoreinbettungen innerhalb einer Sammlung haben die gleiche Dimensionalität und Distanzmetrik zur Messung der Ähnlichkeit.

Milvus-Sammlungen unterstützen dynamische Felder (d. h. Felder, die nicht im Schema vordefiniert sind) und die automatische Inkrementierung von Primärschlüsseln.

Um verschiedenen Präferenzen gerecht zu werden, bietet Milvus zwei Methoden zur Erstellung einer Sammlung. Die eine bietet eine schnelle Einrichtung, während die andere eine detaillierte Anpassung des Sammlungsschemas und der Indexparameter ermöglicht.

Außerdem können Sie eine Sammlung bei Bedarf anzeigen, laden, freigeben und löschen.

Sammlung erstellen

Sie können eine Sammlung auf eine der beiden folgenden Weisen erstellen:

  • Schnelleinrichtung

    Auf diese Weise können Sie eine Sammlung erstellen, indem Sie ihr einfach einen Namen geben und die Anzahl der Dimensionen der Vektoreinbettungen angeben, die in dieser Sammlung gespeichert werden sollen. Einzelheiten finden Sie unter Schnelleinrichtung.

  • Benutzerdefinierte Einrichtung

    Anstatt In Milvus fast alles für Ihre Sammlung entscheiden zu lassen, können Sie das Schema und die Indexparameter der Sammlung selbst bestimmen. Details dazu finden Sie unter Benutzerdefinierte Einrichtung.

Schnelle Einrichtung

Vor dem Hintergrund des großen Sprungs in der KI-Industrie brauchen die meisten Entwickler nur eine einfache, aber dynamische Sammlung, um damit zu beginnen. Milvus ermöglicht eine schnelle Einrichtung einer solchen Sammlung mit nur drei Argumenten:

  • Name der zu erstellenden Sammlung,

  • Dimension der einzufügenden Vektoreinbettungen und

  • Metrischer Typ, der zur Messung der Ähnlichkeiten zwischen den Vektoreinbettungen verwendet wird.

Für eine schnelle Einrichtung verwenden Sie die create_collection() Methode der MilvusClient Klasse, um eine Sammlung mit dem angegebenen Namen und der Dimension zu erstellen.

Für eine schnelle Einrichtung verwenden Sie die createCollection() Methode der Klasse MilvusClientV2 Klasse, um eine Sammlung mit dem angegebenen Namen und der angegebenen Dimension zu erstellen.

Für eine schnelle Einrichtung verwenden Sie die createCollection() Methode der Klasse MilvusClient Klasse, um eine Sammlung mit dem angegebenen Namen und der angegebenen Dimension zu erstellen.

Für eine schnelle Einrichtung verwenden Sie den POST /v2/vectordb/collections/create API-Endpunkt, um eine Sammlung mit dem angegebenen Namen und der angegebenen Dimension zu erstellen.

from pymilvus import MilvusClient, DataType

# 1. Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# 2. Create a collection in quick setup mode
client.create_collection(
    collection_name="quick_setup",
    dimension=5
)

res = client.get_load_state(
    collection_name="quick_setup"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.collection.request.GetLoadStateReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

String CLUSTER_ENDPOINT = "http://localhost:19530";

// 1. Connect to Milvus server
ConnectConfig connectConfig = ConnectConfig.builder()
    .uri(CLUSTER_ENDPOINT)
    .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

// 2. Create a collection in quick setup mode
CreateCollectionReq quickSetupReq = CreateCollectionReq.builder()
    .collectionName("quick_setup")
    .dimension(5)
    .build();

client.createCollection(quickSetupReq);

// Thread.sleep(5000);

GetLoadStateReq quickSetupLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .build();

Boolean res = client.getLoadState(quickSetupLoadStateReq);

System.out.println(res);

// Output:
// true
address = "http://localhost:19530"

// 1. Set up a Milvus Client
client = new MilvusClient({address});

// 2. Create a collection in quick setup mode
let res = await client.createCollection({
    collection_name: "quick_setup",
    dimension: 5,
});  

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 
$ export MILVUS_URI="localhost:19530"

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "quick_setup",
  "dimension": 5
}'

# Output
#
# {
#     "code": 0,
#     "data": {},
# }

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "quick_setup"
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 100,
#         "loadState": "LoadStateLoaded"
#     }
# }

Die im obigen Code generierte Sammlung enthält nur zwei Felder: id (als Primärschlüssel) und vector (als Vektorfeld), wobei die Einstellungen auto_id und enable_dynamic_field standardmäßig aktiviert sind.

  • auto_id

    Durch die Aktivierung dieser Einstellung wird sichergestellt, dass der Primärschlüssel automatisch inkrementiert wird. Die manuelle Bereitstellung von Primärschlüsseln während der Dateneingabe ist nicht erforderlich.

  • enable_dynamic_field

    Wenn diese Einstellung aktiviert ist, werden alle Felder, außer id und vector in den einzufügenden Daten, als dynamische Felder behandelt. Diese zusätzlichen Felder werden als Schlüssel-Wert-Paare in einem speziellen Feld namens $meta gespeichert. Diese Funktion ermöglicht die Einbeziehung zusätzlicher Felder beim Einfügen von Daten.

Die automatisch indizierte und geladene Sammlung aus dem bereitgestellten Code ist für die sofortige Dateneinfügung bereit.

Benutzerdefinierte Einrichtung

Anstatt Milvus fast alles für Ihre Sammlung entscheiden zu lassen, können Sie das Schema und die Indexparameter der Sammlung selbst bestimmen.

Schritt 1: Schema einrichten

Ein Schema definiert die Struktur einer Sammlung. Innerhalb des Schemas haben Sie die Möglichkeit, enable_dynamic_field zu aktivieren oder zu deaktivieren, vordefinierte Felder hinzuzufügen und Attribute für jedes Feld festzulegen. Eine ausführliche Erläuterung des Konzepts und der verfügbaren Datentypen finden Sie unter Schema erklärt.

Um ein Schema einzurichten, verwenden Sie create_schema() um ein Schemaobjekt zu erstellen und add_field() um dem Schema Felder hinzuzufügen.

Um ein Schema einzurichten, verwenden Sie createSchema() um ein Schemaobjekt zu erstellen und addField() um dem Schema Felder hinzuzufügen.

Um ein Schema einzurichten, verwenden Sie createCollection().

Um ein Schema einzurichten, müssen Sie ein JSON-Objekt definieren, das dem Schemaformat entspricht, das auf der POST /v2/vectordb/collections/create API-Endpunkt-Referenzseite angezeigt wird.

# 3. Create a collection in customized setup mode

# 3.1. Create schema
schema = MilvusClient.create_schema(
    auto_id=False,
    enable_dynamic_field=True,
)

# 3.2. Add fields to schema
schema.add_field(field_name="my_id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="my_vector", datatype=DataType.FLOAT_VECTOR, dim=5)
import io.milvus.v2.common.DataType;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

// 3. Create a collection in customized setup mode

// 3.1 Create schema
CreateCollectionReq.CollectionSchema schema = client.createSchema();

// 3.2 Add fields to schema
schema.addField(AddFieldReq.builder()
    .fieldName("my_id")
    .dataType(DataType.Int64)
    .isPrimaryKey(true)
    .autoID(false)
    .build());

schema.addField(AddFieldReq.builder()
    .fieldName("my_vector")
    .dataType(DataType.FloatVector)
    .dimension(5)
    .build());
// 3. Create a collection in customized setup mode
// 3.1 Define fields
const fields = [
    {
        name: "my_id",
        data_type: DataType.Int64,
        is_primary_key: true,
        auto_id: false
    },
    {
        name: "my_vector",
        data_type: DataType.FloatVector,
        dim: 5
    },
]
export fields='[{ \
    "fieldName": "my_id", \
    "dataType": "Int64", \
    "isPrimary": true \
}, \
{ \
    "fieldName": "my_vector", \
    "dataType": "FloatVector", \
    "elementTypeParams": { \
        "dim": 5 \
    } \
}]'
Parameter Beschreibung
auto_id Legt fest, ob das Primärfeld automatisch inkrementiert wird.
Wenn dieser Wert auf True gesetzt wird, wird das Primärfeld automatisch inkrementiert. In diesem Fall sollte das Primärfeld nicht in den einzufügenden Daten enthalten sein, um Fehler zu vermeiden. Die automatisch generierten IDs haben eine feste Länge und können nicht geändert werden.
enable_dynamic_field Legt fest, ob Milvus die Werte von undefinierten Feldern in einem dynamischen Feld speichert, wenn die in die Zielsammlung eingefügten Daten Felder enthalten, die nicht im Schema der Sammlung definiert sind.
Wenn Sie dies auf True setzen, erstellt Milvus ein Feld namens $meta, um alle undefinierten Felder und deren Werte aus den eingefügten Daten zu speichern.
field_name Der Name des Feldes.
datatype Der Datentyp des Feldes. Eine Liste der verfügbaren Datentypen finden Sie unter DataType.
is_primary Ob das aktuelle Feld das Primärfeld in einer Sammlung ist.
Jede Sammlung hat nur ein Primärfeld. Ein Primärfeld sollte entweder vom Typ DataType.INT64 oder vom Typ DataType.VARCHAR sein.
dim Die Dimension der Vektoreinbettungen.
Dies ist obligatorisch für ein Feld vom Typ DataType.FLOAT_VECTOR, DataType.BINARY_VECTOR, DataType.FLOAT16_VECTOR oder DataType.BFLOAT16_VECTOR. Wenn Sie DataType.SPARSE_FLOAT_VECTOR verwenden, lassen Sie diesen Parameter weg.
Parameter Beschreibung
fieldName Der Name des Feldes.
dataType Der Datentyp des Feldes. Eine Liste der verfügbaren Datentypen finden Sie unter DataType.
isPrimaryKey Ob das aktuelle Feld das Primärfeld in einer Sammlung ist.
Jede Sammlung hat nur ein Primärfeld. Ein Primärfeld sollte entweder vom Typ DataType.Int64 oder vom Typ DataType.VarChar sein.
autoID Ob das Primärfeld automatisch inkrementiert werden kann.
Wenn dieser Wert auf true gesetzt wird, wird das Primärfeld automatisch inkrementiert. In diesem Fall sollte das Primärfeld nicht in den einzufügenden Daten enthalten sein, um Fehler zu vermeiden.
dimension Die Dimension der Vektoreinbettungen.
Dies ist obligatorisch für ein Feld vom Typ DataType.FloatVector, DataType.BinaryVector, DataType.Float16Vector oder DataType.BFloat16Vector.
Parameter Beschreibung
name Der Name des Feldes.
data_type Der Datentyp des Feldes. Eine Aufzählung aller verfügbaren Datentypen finden Sie unter DataType.
is_primary_key Ob das aktuelle Feld das Primärfeld in einer Sammlung ist.
Jede Sammlung hat nur ein Primärfeld. Ein Primärfeld sollte entweder vom Typ DataType.INT64 oder vom Typ DataType.VARCHAR sein.
auto_id Ob das Primärfeld beim Einfügen von Daten in diese Sammlung automatisch inkrementiert wird.
Der Standardwert ist False. Wenn Sie diesen Wert auf True setzen, wird das Primärfeld automatisch inkrementiert. Überspringen Sie diesen Parameter, wenn Sie eine Sammlung mit einem benutzerdefinierten Schema einrichten müssen.
dim Die Dimensionalität des Sammlungsfeldes, das die Vektoreinbettungen enthält.
Der Wert sollte eine ganze Zahl größer als 1 sein und wird in der Regel durch das Modell bestimmt, das Sie zur Erzeugung von Vektoreinbettungen verwenden.
Parameter Beschreibung
fieldName Der Name des zu erstellenden Feldes in der Zielsammlung.
dataType Der Datentyp der Feldwerte.
isPrimary Ob das aktuelle Feld das Primärfeld ist. Die Einstellung True macht das aktuelle Feld zum Primärfeld.
elementTypeParams Zusätzliche Feldparameter.
dim Ein optionaler Parameter für FloatVector- oder BinaryVector-Felder, der die Vektordimension bestimmt.

Schritt 2: Einrichten von Indexparametern

Die Indexparameter bestimmen, wie Milvus Ihre Daten innerhalb einer Sammlung organisiert. Sie können den Indexierungsprozess für bestimmte Felder anpassen, indem Sie deren metric_type und index_type einstellen. Für das Vektorfeld haben Sie die Möglichkeit, COSINE, L2, IP, HAMMING oder JACCARD als metric_type zu wählen, je nach Art der Vektoren, mit denen Sie arbeiten. Weitere Informationen finden Sie unter Ähnlichkeitsmetriken.

Um Indexparameter einzurichten, verwenden Sie prepare_index_params() um Index-Parameter vorzubereiten und add_index() um den Index hinzuzufügen.

Um Index-Parameter einzurichten, verwenden Sie IndexParam.

Um Index-Parameter einzurichten, verwenden Sie createIndex().

Um Index-Parameter einzurichten, müssen Sie ein JSON-Objekt definieren, das dem Format der Index-Parameter entspricht, das auf der POST /v2/vectordb/collections/create API-Endpunkt-Referenzseite angezeigt wird.

# 3.3. Prepare index parameters
index_params = client.prepare_index_params()

# 3.4. Add indexes
index_params.add_index(
    field_name="my_id",
    index_type="STL_SORT"
)

index_params.add_index(
    field_name="my_vector", 
    index_type="IVF_FLAT",
    metric_type="IP",
    params={ "nlist": 128 }
)
import io.milvus.v2.common.IndexParam;

// 3.3 Prepare index parameters
IndexParam indexParamForIdField = IndexParam.builder()
    .fieldName("my_id")
    .indexType(IndexParam.IndexType.STL_SORT)
    .build();

IndexParam indexParamForVectorField = IndexParam.builder()
    .fieldName("my_vector")
    .indexType(IndexParam.IndexType.IVF_FLAT)
    .metricType(IndexParam.MetricType.L2)
    .extraParams(Map.of("nlist", 1024))
    .build();

List<IndexParam> indexParams = new ArrayList<>();
indexParams.add(indexParamForIdField);
indexParams.add(indexParamForVectorField);
// 3.2 Prepare index parameters
const index_params = [{
    field_name: "my_id",
    index_type: "STL_SORT"
},{
    field_name: "my_vector",
    index_type: "IVF_FLAT",
    metric_type: "IP",
    params: { nlist: 1024}
}]
export indexParams='[{ \
    "fieldName": "my_id", \
    "indexName": "my_id", \
    "params": { \
        "index_type": "SLT_SORT" \
  } \
}, { \
    "fieldName": "my_vector", \
    "metricType": "COSINE", \
    "indexName": "my_vector", \
    "params": { \
        "index_type": "IVF_FLAT", \
        "nlist": 1024 \
  } \
}]'
Parameter Beschreibung
field_name Der Name der Zieldatei, für die dieses Objekt gilt.
index_type Der Name des Algorithmus, der für die Anordnung der Daten in dem betreffenden Feld verwendet wird. Anwendbare Algorithmen finden Sie unter In-memory Index und On-disk Index.
metric_type Der Algorithmus, der zur Messung der Ähnlichkeit zwischen Vektoren verwendet wird. Mögliche Werte sind IP, L2, COSINE, JACCARD, HAMMING. Diese Option ist nur verfügbar, wenn das angegebene Feld ein Vektorfeld ist. Weitere Informationen finden Sie unter In Milvus unterstützte Indizes.
params Die Feinabstimmungsparameter für den angegebenen Indextyp. Einzelheiten zu den möglichen Schlüsseln und Wertebereichen finden Sie unter In-Memory-Index.
Parameter Beschreibung
fieldName Der Name des Zielfeldes, auf das dieses IndexParam-Objekt angewendet wird.
indexType Der Name des Algorithmus, der zur Anordnung der Daten in dem bestimmten Feld verwendet wird. Anwendbare Algorithmen finden Sie unter In-memory Index und On-disk Index.
metricType Die für den Index zu verwendende Abstandsmetrik. Mögliche Werte sind IP, L2, COSINE, JACCARD, HAMMING.
extraParams Zusätzliche Index-Parameter. Einzelheiten finden Sie unter In-Memory-Index und On-Disk-Index.
Parameter Beschreibung
field_name Der Name des Zielfeldes, auf dem ein Index erstellt werden soll.
index_type Der Name des Algorithmus, der verwendet wird, um Daten in einem bestimmten Feld anzuordnen. Anwendbare Algorithmen finden Sie unter In-Memory-Index und On-Disk-Index.
metric_type Der Algorithmus, der zur Messung der Ähnlichkeit zwischen Vektoren verwendet wird. Mögliche Werte sind IP, L2, COSINE, JACCARD, HAMMING. Diese Option ist nur verfügbar, wenn das angegebene Feld ein Vektorfeld ist. Weitere Informationen finden Sie unter In Milvus unterstützte Indizes.
params Die Feinabstimmungsparameter für den angegebenen Indextyp. Einzelheiten zu den möglichen Schlüsseln und Wertebereichen finden Sie unter In-Memory-Index.
Parameter Beschreibung
fieldName Der Name des Zielfeldes, für das ein Index erstellt werden soll.
indexName Der Name des zu erstellenden Indexes. Der Wert ist standardmäßig der Name des Zielfelds.
metricType Der Algorithmus, der zur Messung der Ähnlichkeit zwischen Vektoren verwendet wird. Mögliche Werte sind IP, L2, COSINE, JACCARD, HAMMING. Diese Option ist nur verfügbar, wenn das angegebene Feld ein Vektorfeld ist. Weitere Informationen finden Sie unter In Milvus unterstützte Indizes.
params Der Indextyp und die zugehörigen Einstellungen. Weitere Informationen finden Sie unter In-Memory-Index.
params.index_type Der Typ des zu erstellenden Indexes.
params.nlist Die Anzahl der Cluster-Einheiten. Dies gilt für IVF-bezogene Indextypen.

Der obige Codeschnipsel zeigt, wie Indexparameter für ein Vektorfeld bzw. ein Skalarfeld eingerichtet werden. Für das Vektorfeld müssen Sie sowohl den metrischen Typ als auch den Indextyp festlegen. Für ein Skalarfeld legen Sie nur den Indextyp fest. Es wird empfohlen, einen Index für das Vektorfeld und alle Skalarfelder zu erstellen, die häufig für die Filterung verwendet werden.

Schritt 3: Erstellen der Sammlung

Sie haben die Möglichkeit, eine Sammlung und eine Indexdatei separat zu erstellen oder eine Sammlung zu erstellen, bei der der Index gleichzeitig mit der Erstellung geladen wird.

Verwenden Sie create_collection(), um eine Collection mit den angegebenen Schema- und Indexparametern zu erstellen und get_load_state(), um den Ladezustand der Collection zu überprüfen.

Verwenden Sie createCollection(), um eine Sammlung mit den angegebenen Schema- und Indexparametern zu erstellen, und getLoadState(), um den Ladestatus der Sammlung zu überprüfen.

Verwenden Sie createCollection(), um eine Collection mit den angegebenen Schema- und Indexparametern zu erstellen und getLoadState(), um den Ladezustand der Collection zu überprüfen.

  • Erstellen Sie eine Sammlung, bei der der Index gleichzeitig mit der Erstellung geladen wird.

    # 3.5. Create a collection with the index loaded simultaneously
    client.create_collection(
        collection_name="customized_setup_1",
        schema=schema,
        index_params=index_params
    )
    
    time.sleep(5)
    
    res = client.get_load_state(
        collection_name="customized_setup_1"
    )
    
    print(res)
    
    # Output
    #
    # {
    #     "state": "<LoadState: Loaded>"
    # }
    
    import io.milvus.v2.service.collection.request.CreateCollectionReq;
    import io.milvus.v2.service.collection.request.GetLoadStateReq;
    
    // 3.4 Create a collection with schema and index parameters
    CreateCollectionReq customizedSetupReq1 = CreateCollectionReq.builder()
        .collectionName("customized_setup_1")
        .collectionSchema(schema)
        .indexParams(indexParams)
        .build();
    
    client.createCollection(customizedSetupReq1);
    
    // Thread.sleep(5000);
    
    // 3.5 Get load state of the collection
    GetLoadStateReq customSetupLoadStateReq1 = GetLoadStateReq.builder()
        .collectionName("customized_setup_1")
        .build();
    
    res = client.getLoadState(customSetupLoadStateReq1);
    
    System.out.println(res);
    
    // Output:
    // true
    
    // 3.3 Create a collection with fields and index parameters
    res = await client.createCollection({
        collection_name: "customized_setup_1",
        fields: fields,
        index_params: index_params,
    })
    
    console.log(res.error_code)  
    
    // Output
    // 
    // Success
    // 
    
    res = await client.getLoadState({
        collection_name: "customized_setup_1"
    })
    
    console.log(res.state)
    
    // Output
    // 
    // LoadStateLoaded
    //   
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_1",
        "schema": {
            "autoId": false,
            "enabledDynamicField": false,
            "fields": [
                {
                    "fieldName": "my_id",
                    "dataType": "Int64",
                    "isPrimary": true
                },
                {
                    "fieldName": "my_vector",
                    "dataType": "FloatVector",
                    "elementTypeParams": {
                        "dim": "5"
                    }
                }
            ]
        },
        "indexParams": [
            {
                "fieldName": "my_vector",
                "metricType": "COSINE",
                "indexName": "my_vector",
                "params": {
                    "index_type": "IVF_FLAT",
                    "nlist": "1024"
                }
            },
            {
                "fieldName": "my_id",
                "indexName": "my_id",
                "params": {
                    "index_type": "STL_SORT"
                }            
            }
        ]
    }'
    
    # Output
    #
    # {
    #     "code": 0,
    #     "data": {},
    # }
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_1"
    }'
    
    # {
    #     "code": 0,
    #     "data": {
    #         "loadProgress": 100,
    #         "loadState": "LoadStateLoaded"
    #     }
    # }
    

    Die oben erstellte Sammlung wird automatisch geladen. Weitere Informationen zum Laden und Freigeben einer Sammlung finden Sie unter Laden und Freigeben einer Sammlung.

  • Erstellen Sie eine Sammlung und eine Indexdatei separat.

    # 3.6. Create a collection and index it separately
    client.create_collection(
        collection_name="customized_setup_2",
        schema=schema,
    )
    
    res = client.get_load_state(
        collection_name="customized_setup_2"
    )
    
    print(res)
    
    # Output
    #
    # {
    #     "state": "<LoadState: NotLoad>"
    # }
    
    // 3.6 Create a collection and index it separately
    CreateCollectionReq customizedSetupReq2 = CreateCollectionReq.builder()
        .collectionName("customized_setup_2")
        .collectionSchema(schema)
        .build();
    
    client.createCollection(customizedSetupReq2);
    
    // 3.4 Create a collection and index it seperately
    res = await client.createCollection({
        collection_name: "customized_setup_2",
        fields: fields,
    })
    
    console.log(res.error_code)
    
    // Output
    // 
    // Success
    // 
    
    res = await client.getLoadState({
        collection_name: "customized_setup_2"
    })
    
    console.log(res.state)
    
    // Output
    // 
    // LoadStateNotLoad
    // 
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/create" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_2",
        "schema": {
            "autoId": false,
            "enabledDynamicField": false,
            "fields": [
                {
                    "fieldName": "my_id",
                    "dataType": "Int64",
                    "isPrimary": true
                },
                {
                    "fieldName": "my_vector",
                    "dataType": "FloatVector",
                    "elementTypeParams": {
                        "dim": "5"
                    }
                }
            ]
            
        }
    }'
    
    # Output
    #
    # {
    #     "code": 0,
    #     "data": {},
    # }
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_2"
    }'
    
    # {
    #     "code": 0,
    #     "data": {
    #         "loadState": "LoadStateNotLoaded"
    #     }
    # }
    

    Die oben erstellte Sammlung wird nicht automatisch geladen. Sie können wie folgt einen Index für die Sammlung erstellen. Wenn Sie einen Index für die Sammlung auf eine andere Weise erstellen, wird die Sammlung nicht automatisch geladen. Weitere Informationen finden Sie unter Sammlung laden und freigeben.

    Parameter Beschreibung
    collection_name Der Name der Sammlung.
    schema Das Schema dieser Sammlung.
    Die Einstellung None bedeutet, dass diese Sammlung mit den Standardeinstellungen erstellt wird.
    Um eine Sammlung mit einem benutzerdefinierten Schema einzurichten, müssen Sie ein CollectionSchema-Objekt erstellen und es hier referenzieren. In diesem Fall ignoriert Milvus alle anderen schema-bezogenen Einstellungen, die in der Anfrage enthalten sind.
    index_params Die Parameter für die Erstellung des Indexes für das Vektorfeld in dieser Sammlung. Um eine Sammlung mit einem angepassten Schema einzurichten und die Sammlung automatisch in den Speicher zu laden, müssen Sie ein IndexParams-Objekt erstellen und es hier referenzieren.
    Sie sollten zumindest einen Index für das Vektorfeld in dieser Sammlung hinzufügen. Sie können diesen Parameter auch weglassen, wenn Sie die Indexparameter später einrichten möchten.

    Parameter Beschreibung
    collectionName Der Name der Sammlung.
    collectionSchema Das Schema dieser Sammlung.
    Wenn Sie diesen Parameter leer lassen, wird diese Sammlung mit den Standardeinstellungen erstellt. Um eine Sammlung mit einem benutzerdefinierten Schema einzurichten, müssen Sie ein CollectionSchema-Objekt erstellen und es hier referenzieren.
    indexParams Die Parameter für die Erstellung des Indexes für das Vektorfeld in dieser Sammlung. Um eine Sammlung mit einem benutzerdefinierten Schema einzurichten und die Sammlung automatisch in den Speicher zu laden, erstellen Sie ein IndexParams-Objekt mit einer Liste von IndexParam-Objekten und referenzieren Sie es hier.

    Parameter Beschreibung
    collection_name Der Name der Sammlung.
    fields Die Felder in der Auflistung.
    index_params Die Indexparameter für die zu erstellende Sammlung.

    Parameter Beschreibung
    collectionName Der Name der Sammlung.
    schema Das Schema ist für die Organisation der Daten in der Zielsammlung verantwortlich. Ein gültiges Schema sollte mehrere Felder haben, die einen Primärschlüssel, ein Vektorfeld und mehrere Skalarfelder umfassen müssen.
    schema.autoID Ob das Primärfeld automatisch inkrementiert werden kann. Wenn Sie diese Option auf True setzen, wird das Primärfeld automatisch inkrementiert. In diesem Fall sollte das Primärfeld nicht in den einzufügenden Daten enthalten sein, um Fehler zu vermeiden. Setzen Sie diesen Parameter in dem Feld, in dem is_primary auf True gesetzt ist.
    schema.enableDynamicField Erlaubt die Verwendung des reservierten Feldes $meta zur Aufnahme von nicht schema-definierten Feldern in Schlüssel-Wert-Paaren.
    fields Eine Liste von Feldobjekten.
    fields.fieldName Der Name des zu erstellenden Feldes in der Zielsammlung.
    fields.dataType Der Datentyp der Feldwerte.
    fields.isPrimary Ob das aktuelle Feld das Primärfeld ist. Durch die Einstellung auf True wird das aktuelle Feld zum Primärfeld.
    fields.elementTypeParams Zusätzliche Feldparameter.
    fields.elementTypeParams.dim Ein optionaler Parameter für FloatVector- oder BinaryVector-Felder, der die Vektordimension bestimmt.

    Die oben erstellte Sammlung wird nicht automatisch geladen. Sie können einen Index für die Sammlung wie folgt erstellen. Wenn Sie einen Index für die Sammlung auf separate Weise erstellen, wird die Sammlung nicht automatisch geladen. Einzelheiten finden Sie unter Laden und Freigeben der Sammlung.

    # 3.6 Create index
    client.create_index(
        collection_name="customized_setup_2",
        index_params=index_params
    )
    
    res = client.get_load_state(
        collection_name="customized_setup_2"
    )
    
    print(res)
    
    # Output
    #
    # {
    #     "state": "<LoadState: NotLoad>"
    # }
    
    CreateIndexReq  createIndexReq = CreateIndexReq.builder()
        .collectionName("customized_setup_2")
        .indexParams(indexParams)
        .build();
    
    client.createIndex(createIndexReq);
    
    // Thread.sleep(1000);
    
    // 3.7 Get load state of the collection
    GetLoadStateReq customSetupLoadStateReq2 = GetLoadStateReq.builder()
        .collectionName("customized_setup_2")
        .build();
    
    res = client.getLoadState(customSetupLoadStateReq2);
    
    System.out.println(res);
    
    // Output:
    // false
    
    // 3.5 Create index
    res = await client.createIndex({
        collection_name: "customized_setup_2",
        field_name: "my_vector",
        index_type: "IVF_FLAT",
        metric_type: "IP",
        params: { nlist: 1024}
    })
    
    res = await client.getLoadState({
        collection_name: "customized_setup_2"
    })
    
    console.log(res.state)
    
    // Output
    // 
    // LoadStateNotLoad
    //
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/indexes/create" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_2",
        "indexParams": [
            {
                "metricType": "L2",
                "fieldName": "my_vector",
                "indexName": "my_vector",
                "indexConfig": {
                    "index_type": "IVF_FLAT",
                    "nlist": "1024"
                }
            }
        ]
    }'
    
    # Output
    #
    # {
    #     "code": 0,
    #     "data": {},
    # }
    
    $ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
    -H "Content-Type: application/json" \
    -d '{
        "collectionName": "customized_setup_2"
    }'
    
    # {
    #     "code": 0,
    #     "data": {
    #         "loadState": "LoadStateNotLoaded"
    #     }
    # }
    
    Parameter Beschreibung
    collection_name Der Name der Sammlung.
    index_params Ein IndexParams-Objekt, das eine Liste von IndexParam-Objekten enthält.
Parameter Beschreibung
collectionName Der Name der Sammlung.
indexParams Eine Liste von IndexParam-Objekten.
Parameter Beschreibung
collection_name Der Name der Auflistung.
field_name Der Name des Feldes, in dem ein Index erstellt werden soll.
index_type Der Name des Algorithmus, der zur Anordnung der Daten in dem spezifischen Feld verwendet wird. Anwendbare Algorithmen finden Sie unter In-Memory-Index und On-Disk-Index.
metric_type Der Algorithmus, der zur Messung der Ähnlichkeit zwischen Vektoren verwendet wird. Mögliche Werte sind IP, L2, COSINE, JACCARD, HAMMING. Diese Option ist nur verfügbar, wenn das angegebene Feld ein Vektorfeld ist. Weitere Informationen finden Sie unter In Milvus unterstützte Indizes.
params Die Feinabstimmungsparameter für den angegebenen Indextyp. Einzelheiten zu den möglichen Schlüsseln und Wertebereichen finden Sie unter In-Memory-Index.
Parameter Beschreibung
collectionName Der Name der Sammlung.
indexParams Die Indexparameter für die zu erstellende Sammlung.
indexParams.metricType Der Typ der Ähnlichkeitsmetrik, der für den Aufbau des Index verwendet wird. Der Standardwert ist COSINE.
indexParams.fieldName Der Name des Zielfeldes, für das ein Index erstellt werden soll.
indexParams.indexName Der Name des zu erstellenden Index, der Wert ist standardmäßig der Name des Zielfeldes.
indexParams.indexConfig.index_type Der Typ des zu erstellenden Indexes.
indexParams.indexConfig.nlist Die Anzahl der Cluster-Einheiten. Dies gilt für IVF-bezogene Indextypen.

Sammlungen anzeigen

Um die Details einer bestehenden Sammlung zu überprüfen, verwenden Sie describe_collection().

Um die Details einer bestehenden Sammlung zu überprüfen, verwenden Sie describeCollection().

Um die Details einer bestehenden Sammlung zu prüfen, verwenden Sie describeCollection().

Um die Definition einer Sammlung zu sehen, können Sie die POST /v2/vectordb/collections/describe und die POST /v2/vectordb/collections/list API-Endpunkte verwenden.

# 5. View Collections
res = client.describe_collection(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "collection_name": "customized_setup_2",
#     "auto_id": false,
#     "num_shards": 1,
#     "description": "",
#     "fields": [
#         {
#             "field_id": 100,
#             "name": "my_id",
#             "description": "",
#             "type": 5,
#             "params": {},
#             "element_type": 0,
#             "is_primary": true
#         },
#         {
#             "field_id": 101,
#             "name": "my_vector",
#             "description": "",
#             "type": 101,
#             "params": {
#                 "dim": 5
#             },
#             "element_type": 0
#         }
#     ],
#     "aliases": [],
#     "collection_id": 448143479230158446,
#     "consistency_level": 2,
#     "properties": {},
#     "num_partitions": 1,
#     "enable_dynamic_field": true
# }

import io.milvus.v2.service.collection.request.DescribeCollectionReq;
import io.milvus.v2.service.collection.response.DescribeCollectionResp;

// 4. View collections
DescribeCollectionReq describeCollectionReq = DescribeCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

DescribeCollectionResp describeCollectionRes = client.describeCollection(describeCollectionReq);

System.out.println(JSONObject.toJSON(describeCollectionRes));

// Output:
// {
//     "createTime": 449005822816026627,
//     "collectionSchema": {"fieldSchemaList": [
//         {
//             "autoID": false,
//             "dataType": "Int64",
//             "name": "my_id",
//             "description": "",
//             "isPrimaryKey": true,
//             "maxLength": 65535,
//             "isPartitionKey": false
//         },
//         {
//             "autoID": false,
//             "dataType": "FloatVector",
//             "name": "my_vector",
//             "description": "",
//             "isPrimaryKey": false,
//             "dimension": 5,
//             "maxLength": 65535,
//             "isPartitionKey": false
//         }
//     ]},
//     "vectorFieldName": ["my_vector"],
//     "autoID": false,
//     "fieldNames": [
//         "my_id",
//         "my_vector"
//     ],
//     "description": "",
//     "numOfPartitions": 1,
//     "primaryFieldName": "my_id",
//     "enableDynamicField": true,
//     "collectionName": "customized_setup_2"
// }
// 5. View Collections
res = await client.describeCollection({
    collection_name: "customized_setup_2"
})

console.log(res)

// Output
// 
// {
//   virtual_channel_names: [ 'by-dev-rootcoord-dml_13_449007919953017716v0' ],
//   physical_channel_names: [ 'by-dev-rootcoord-dml_13' ],
//   aliases: [],
//   start_positions: [],
//   properties: [],
//   status: {
//     extra_info: {},
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   schema: {
//     fields: [ [Object], [Object] ],
//     properties: [],
//     name: 'customized_setup_2',
//     description: '',
//     autoID: false,
//     enable_dynamic_field: false
//   },
//   collectionID: '449007919953017716',
//   created_timestamp: '449024569603784707',
//   created_utc_timestamp: '1712892797866',
//   shards_num: 1,
//   consistency_level: 'Bounded',
//   collection_name: 'customized_setup_2',
//   db_name: 'default',
//   num_partitions: '1'
// }
// 
curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/describe" \
-H "Content-Type: application/json" \
-d '{
    "dbName": "default",
    "collectionName": "test_collection"
}'

# {
#     "code": 0,
#     "data": {
#         "aliases": [],
#         "autoId": false,
#         "collectionID": 448707763883002014,
#         "collectionName": "test_collection",
#         "consistencyLevel": "Bounded",
#         "description": "",
#         "enableDynamicField": true,
#         "fields": [
#             {
#                 "autoId": false,
#                 "description": "",
#                 "id": 100,
#                 "name": "id",
#                 "partitionKey": false,
#                 "primaryKey": true,
#                 "type": "Int64"
#             },
#             {
#                 "autoId": false,
#                 "description": "",
#                 "id": 101,
#                 "name": "vector",
#                 "params": [
#                     {
#                         "key": "dim",
#                         "value": "5"
#                     }
#                 ],
#                 "partitionKey": false,
#                 "primaryKey": false,
#                 "type": "FloatVector"
#             }
#         ],
#         "indexes": [
#             {
#                 "fieldName": "vector",
#                 "indexName": "vector",
#                 "metricType": "COSINE"
#             }
#         ],
#         "load": "LoadStateLoaded",
#         "partitionsNum": 1,
#         "properties": [],
#         "shardsNum": 1
#     }
# }

Um alle vorhandenen Sammlungen aufzulisten, können Sie wie folgt vorgehen:

# 6. List all collection names
res = client.list_collections()

print(res)

# Output
#
# [
#     "customized_setup_2",
#     "quick_setup",
#     "customized_setup_1"
# ]
import io.milvus.v2.service.collection.response.ListCollectionsResp;

// 5. List all collection names
ListCollectionsResp listCollectionsRes = client.listCollections();

System.out.println(listCollectionsRes.getCollectionNames());

// Output:
// [
//     "customized_setup_2",
//     "quick_setup",
//     "customized_setup_1"
// ]
// 5. List all collection names
ListCollectionsResp listCollectionsRes = client.listCollections();

System.out.println(listCollectionsRes.getCollectionNames());

// Output:
// [
//     "customized_setup_1",
//     "quick_setup",
//     "customized_setup_2"
// ]
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/list" \
-H "Content-Type: application/json" \
-d '{
    "dbName": "default"
}'

# {
#   "code": 0,
#   "data": [
#     "quick_setup",
#     "customized_setup_1",
#     "customized_setup_2"
#   ]
# }

Sammlung laden und freigeben

Während des Ladevorgangs einer Sammlung lädt Milvus die Indexdatei der Sammlung in den Speicher. Umgekehrt entlädt Milvus beim Freigeben einer Sammlung die Indexdatei aus dem Speicher. Bevor Sie eine Suche in einer Sammlung durchführen, stellen Sie sicher, dass die Sammlung geladen ist.

Laden einer Sammlung

Um eine Sammlung zu laden, verwenden Sie die load_collection() Methode und geben Sie den Namen der Sammlung an. Sie können auch replica_number einstellen, um zu bestimmen, wie viele speicherinterne Repliken von Datensegmenten auf Abfrageknoten erstellt werden sollen, wenn die Sammlung geladen wird.

  • Milvus Standalone: Der maximal zulässige Wert für replica_number ist 1.
  • Milvus Cluster: Der Höchstwert sollte die in Ihren Milvus-Konfigurationen festgelegte queryNode.replicas nicht überschreiten. Weitere Einzelheiten finden Sie unter Abfrage von knotenbezogenen Konfigurationen.

Um eine Sammlung zu laden, verwenden Sie die loadCollection() Methode und geben Sie den Namen der Sammlung an.

Um eine Sammlung zu laden, verwenden Sie die loadCollection() Methode und geben Sie den Namen der Sammlung an.

Um eine Sammlung zu laden, können Sie die POST /v2/vectordb/collections/load und die POST /v2/vectordb/collections/get_load_state API-Endpunkte verwenden.

# 7. Load the collection
client.load_collection(
    collection_name="customized_setup_2",
    replica_number=1 # Number of replicas to create on query nodes. Max value is 1 for Milvus Standalone, and no greater than `queryNode.replicas` for Milvus Cluster.
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
import io.milvus.v2.service.collection.request.LoadCollectionReq;

// 6. Load the collection
LoadCollectionReq loadCollectionReq = LoadCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.loadCollection(loadCollectionReq);

// Thread.sleep(5000);

// 7. Get load state of the collection
GetLoadStateReq loadStateReq = GetLoadStateReq.builder()
    .collectionName("customized_setup_2")
    .build();

res = client.getLoadState(loadStateReq);

System.out.println(res);

// Output:
// true
// 7. Load the collection
res = await client.loadCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

await sleep(3000)

res = await client.getLoadState({
    collection_name: "customized_setup_2"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/load" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

# Output
#
# {
#     "code": 0,
#     "data": {},
# }

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "customized_setup_2"
}'

# {
#     "code": 0,
#     "data": {
#         "loadProgress": 100,
#         "loadState": "LoadStateLoaded"
#     }
# }

Eine Sammlung teilweise laden (öffentliche Vorschau)

Diese Funktion befindet sich derzeit in der öffentlichen Vorschau. Die API und die Funktionalität können sich in Zukunft noch ändern.

Beim Empfang Ihrer Ladeanforderung lädt Milvus alle Vektorfeld-Indizes und alle skalaren Felddaten in den Speicher. Wenn einige Felder nicht in Suchen und Abfragen einbezogen werden sollen, können Sie sie vom Laden ausschließen, um die Speichernutzung zu reduzieren und die Suchleistung zu verbessern.

# 7. Load the collection
client.load_collection(
    collection_name="customized_setup_2",
    load_fields=["my_id", "my_vector"], # Load only the specified fields
    skip_load_dynamic_field=True # Skip loading the dynamic field
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

Beachten Sie, dass nur die in load_fields aufgeführten Felder als Filterbedingungen und Ausgabefelder in Suchen und Abfragen verwendet werden können. Sie sollten immer den Primärschlüssel in die Liste aufnehmen. Die Feldnamen, die vom Laden ausgeschlossen sind, sind nicht für die Filterung oder Ausgabe verfügbar.

Sie können skip_load_dynamic_field=True verwenden, um das Laden des dynamischen Feldes zu überspringen. Milvus behandelt das dynamische Feld als ein einziges Feld, so dass alle Schlüssel des dynamischen Feldes zusammen einbezogen oder ausgeschlossen werden.

Eine Sammlung freigeben

Um eine Sammlung freizugeben, verwenden Sie die release_collection() Methode und geben Sie den Namen der Sammlung an.

Um eine Sammlung freizugeben, verwenden Sie die Methode releaseCollection() Methode unter Angabe des Sammlungsnamens.

Um eine Sammlung freizugeben, verwenden Sie die releaseCollection() Methode und geben Sie den Namen der Sammlung an.

Um eine Sammlung freizugeben, können Sie die POST /v2/vectordb/collections/release und die POST /v2/vectordb/collections/get_load_state API-Endpunkte verwenden.

# 8. Release the collection
client.release_collection(
    collection_name="customized_setup_2"
)

res = client.get_load_state(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoad>"
# }
import io.milvus.v2.service.collection.request.ReleaseCollectionReq;

// 8. Release the collection
ReleaseCollectionReq releaseCollectionReq = ReleaseCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.releaseCollection(releaseCollectionReq);

// Thread.sleep(1000);

res = client.getLoadState(loadStateReq);

System.out.println(res);

// Output:
// false
// 8. Release the collection
res = await client.releaseCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.getLoadState({
    collection_name: "customized_setup_2"
})

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/release" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

# Output
#
# {
#     "code": 0,
#     "data": {},
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/get_load_state" \
-H "Content-Type: application/json" \
-d '{
  "collectionName": "customized_setup_2"
}'


# {
#     "code": 0,
#     "data": {
#         "loadState": "LoadStateNotLoad"
#     }
# }

Aliasnamen einrichten

Sie können Sammlungen Aliasnamen zuweisen, um ihnen in einem bestimmten Kontext mehr Bedeutung zu verleihen. Sie können einer Sammlung mehrere Aliasnamen zuweisen, aber nicht mehrere Sammlungen können sich einen Alias teilen.

Aliasnamen erstellen

Um Aliasnamen zu erstellen, verwenden Sie die create_alias() Methode und geben Sie den Namen der Sammlung und den Alias an.

Um Aliasnamen zu erstellen, verwenden Sie die Methode createAlias() unter Angabe des Sammlungsnamens und des Alias.

Um Aliasnamen zu erstellen, verwenden Sie die Methode createAlias() unter Angabe des Sammlungsnamens und des Alias.

Um Aliasnamen für eine Sammlung zu erstellen, können Sie den POST /v2/vectordb/aliases/create API-Endpunkt verwenden.

# 9.1. Create aliases
client.create_alias(
    collection_name="customized_setup_2",
    alias="bob"
)

client.create_alias(
    collection_name="customized_setup_2",
    alias="alice"
)
import io.milvus.v2.service.utility.request.CreateAliasReq;

// 9. Manage aliases

// 9.1 Create alias
CreateAliasReq createAliasReq = CreateAliasReq.builder()
    .collectionName("customized_setup_2")
    .alias("bob")
    .build();

client.createAlias(createAliasReq);

createAliasReq = CreateAliasReq.builder()
    .collectionName("customized_setup_2")
    .alias("alice")
    .build();

client.createAlias(createAliasReq);
// 9. Manage aliases
// 9.1 Create aliases
res = await client.createAlias({
    collection_name: "customized_setup_2",
    alias: "bob"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.createAlias({
    collection_name: "customized_setup_2",
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/create" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2",
    "aliasName": "bob"
}'

# Output
#
# {
#     "code": 0,
#     "data": {}
# }

$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/create" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2",
    "aliasName": "alice"
}'

# Output
#
# {
#     "code": 0,
#     "data": {}
# }
Parameter Beschreibung
collection_name Der Name der Sammlung, für die ein Alias erstellt werden soll.
alias Der Alias der Sammlung. Vergewissern Sie sich vor diesem Vorgang, dass der Alias nicht bereits existiert. Ist dies der Fall, treten Ausnahmen auf.
Parameter Beschreibung
collectionName Der Name der Sammlung, für die ein Alias erstellt werden soll.
alias Der Alias der Sammlung. Vergewissern Sie sich vor diesem Vorgang, dass der Alias nicht bereits existiert. Ist dies der Fall, treten Ausnahmen auf.
Parameter Beschreibung
collection_name Der Name der Sammlung, für die ein Alias erstellt werden soll.
alias Der Alias der Sammlung. Vergewissern Sie sich vor diesem Vorgang, dass der Alias nicht bereits existiert. Ist dies der Fall, treten Ausnahmen auf.
Parameter Beschreibung
collectionName Der Name der Sammlung, für die ein Alias erstellt werden soll.
aliasName Der Alias der Sammlung. Vergewissern Sie sich vor diesem Vorgang, dass der Alias nicht bereits existiert. Ist dies der Fall, treten Ausnahmen auf.

Aliasnamen auflisten

Um Aliasnamen aufzulisten, verwenden Sie die list_aliases() Methode und geben Sie den Namen der Sammlung an.

Um Aliasnamen aufzulisten, verwenden Sie die Methode listAliases() Methode unter Angabe des Sammlungsnamens.

Um Aliasnamen aufzulisten, verwenden Sie die Methode listAliases() Methode unter Angabe des Sammlungsnamens.

Um Aliasnamen für eine Sammlung aufzulisten, können Sie den POST /v2/vectordb/aliases/list API-Endpunkt verwenden.

# 9.2. List aliases
res = client.list_aliases(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "bob",
#         "alice"
#     ],
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }
import io.milvus.v2.service.utility.request.ListAliasesReq;
import io.milvus.v2.service.utility.response.ListAliasResp;

// 9.2 List alises
ListAliasesReq listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_2")
    .build();

ListAliasResp listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// [
//     "bob",
//     "alice"
// ]
// 9.2 List aliases
res = await client.listAliases({
    collection_name: "customized_setup_2"
})

console.log(res.aliases)

// Output
// 
// [ 'bob', 'alice' ]
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'

# {
#     "code": 0,
#     "data": [
#         "bob",
#         "alice"
#     ]
# }

Aliasnamen beschreiben

Um Aliasnamen zu beschreiben, verwenden Sie die describe_alias() Methode und geben Sie den Alias an.

Um Aliasnamen zu beschreiben, verwenden Sie die describeAlias() Methode unter Angabe des Alias.

Um Aliasnamen zu beschreiben, verwenden Sie die Methode describeAlias() Methode und geben Sie den Alias an.

Um Aliase für eine Sammlung zu beschreiben, können Sie den POST /v2/vectordb/aliases/describe API-Endpunkt verwenden.

# 9.3. Describe aliases
res = client.describe_alias(
    alias="bob"
)

print(res)

# Output
#
# {
#     "alias": "bob",
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }
import io.milvus.v2.service.utility.request.DescribeAliasReq;
import io.milvus.v2.service.utility.response.DescribeAliasResp;

// 9.3 Describe alias
DescribeAliasReq describeAliasReq = DescribeAliasReq.builder()
    .alias("bob")
    .build();

DescribeAliasResp describeAliasRes = client.describeAlias(describeAliasReq);

System.out.println(JSONObject.toJSON(describeAliasRes));

// Output:
// {
//     "alias": "bob",
//     "collectionName": "customized_setup_2"
// }
// 9.3 Describe aliases
res = await client.describeAlias({
    collection_name: "customized_setup_2",
    alias: "bob"
})

console.log(res)

// Output
// 
// {
//   status: {
//     extra_info: {},
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   db_name: 'default',
//   alias: 'bob',
//   collection: 'customized_setup_2'
// }
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/describe" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "bob"
}'

# {
#     "code": 0,
#     "data": {
#         "aliasName": "bob",
#         "collectionName": "quick_setup",
#         "dbName": "default"
#     }
# }

Aliasnamen neu zuweisen

Um Aliase anderen Sammlungen neu zuzuordnen, verwenden Sie die alter_alias() und geben Sie dabei den Namen der Sammlung und den Alias an.

Um Aliase anderen Sammlungen neu zuzuordnen, verwenden Sie die Methode alterAlias() unter Angabe des Sammlungsnamens und des Alias.

Um Aliasnamen anderen Sammlungen zuzuordnen, verwenden Sie die Methode alterAlias() unter Angabe des Sammlungsnamens und des Alias.

Um Aliase anderen Sammlungen neu zuzuordnen, können Sie den POST /v2/vectordb/aliases/alter API-Endpunkt verwenden.

# 9.4 Reassign aliases to other collections
client.alter_alias(
    collection_name="customized_setup_1",
    alias="alice"
)

res = client.list_aliases(
    collection_name="customized_setup_1"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "alice"
#     ],
#     "collection_name": "customized_setup_1",
#     "db_name": "default"
# }

res = client.list_aliases(
    collection_name="customized_setup_2"
)

print(res)

# Output
#
# {
#     "aliases": [
#         "bob"
#     ],
#     "collection_name": "customized_setup_2",
#     "db_name": "default"
# }
import io.milvus.v2.service.utility.request.AlterAliasReq;

// 9.4 Reassign alias to other collections
AlterAliasReq alterAliasReq = AlterAliasReq.builder()
    .collectionName("customized_setup_1")
    .alias("alice")
    .build();

client.alterAlias(alterAliasReq);

listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_1")
    .build();

listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// ["alice"]

listAliasesReq = ListAliasesReq.builder()
    .collectionName("customized_setup_2")
    .build();

listAliasRes = client.listAliases(listAliasesReq);

System.out.println(listAliasRes.getAlias());

// Output:
// ["bob"]
// 9.4 Reassign aliases to other collections
res = await client.alterAlias({
    collection_name: "customized_setup_1",
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.listAliases({
    collection_name: "customized_setup_1"
})

console.log(res.aliases)

// Output
// 
// [ 'alice' ]
// 

res = await client.listAliases({
    collection_name: "customized_setup_2"
})

console.log(res.aliases)

// Output
// 
// [ 'bob' ]
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/alter" \
-H "Content-Type: application/json" \
-d '{
     "collectionName": "customized_setup_1",
     "aliasName": "alice"
}'

# {
#     "code": 0,
#     "data": {}
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_1"
}'


# {
#     "code": 0,
#     "data": [
#         "alice"
#     ]
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/list" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'


# {
#     "code": 0,
#     "data": [
#         "bob"
#     ]
# }

Aliasnamen löschen

Um Aliasnamen zu löschen, verwenden Sie die drop_alias() und geben dabei den Alias an.

Um Aliasnamen zu löschen, verwenden Sie die Methode dropAlias() und geben Sie dabei den Alias an.

Um Aliasnamen zu löschen, verwenden Sie die Methode dropAlias() und geben Sie dabei den Alias an.

Um Aliasnamen für eine Sammlung zu löschen, können Sie den POST /v2/vectordb/aliases/drop API-Endpunkt verwenden.

# 9.5 Drop aliases
client.drop_alias(
    alias="bob"
)

client.drop_alias(
    alias="alice"
)
import io.milvus.v2.service.utility.request.DropAliasReq;

// 9.5 Drop alias
DropAliasReq dropAliasReq = DropAliasReq.builder()
    .alias("bob")
    .build();

client.dropAlias(dropAliasReq);

dropAliasReq = DropAliasReq.builder()
    .alias("alice")
    .build();

client.dropAlias(dropAliasReq);
// 9.5 Drop aliases
res = await client.dropAlias({
    alias: "bob"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropAlias({
    alias: "alice"
})

console.log(res.error_code)

// Output
// 
// Success
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/drop" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "bob"
}'

# {
#     "code": 0,
#     "data": {}
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/aliases/drop" \
-H "Content-Type: application/json" \
-d '{
    "aliasName": "alice"
}'


# {
#     "code": 0,
#     "data": {}
# }

Eigenschaften festlegen

Sie können Eigenschaften für eine Sammlung festlegen, z. B. ttl.seconds und mmap.enabled. Weitere Informationen finden Sie unter set_properties().

Die Codeschnipsel in diesem Abschnitt verwenden das PyMilvus ORM-Modul zur Interaktion mit Milvus. Code-Schnipsel mit dem neuen MilvusClient SDK werden bald verfügbar sein.

TTL setzen

Setzen Sie die Time-To-Live (TTL) für die Daten in der Sammlung, die angibt, wie lange die Daten aufbewahrt werden sollen, bevor sie automatisch gelöscht werden.

from pymilvus import Collection, connections

# Connect to Milvus server
connections.connect(host="localhost", port="19530") # Change to your Milvus server IP and port

# Get existing collection
collection = Collection("quick_setup")

# Set the TTL for the data in the collection
collection.set_properties(
    properties={
        "collection.ttl.seconds": 60
    }
)

MMAP einstellen

Konfigurieren Sie die Eigenschaft Speicherzuordnung (MMAP) für die Sammlung, die festlegt, ob Daten im Speicher abgebildet werden, um die Abfrageleistung zu verbessern. Weitere Informationen finden Sie unter Konfigurieren der Speicherzuordnung.

Bevor Sie die MMAP-Eigenschaft einstellen, müssen Sie die Sammlung zuerst freigeben. Andernfalls tritt ein Fehler auf.

from pymilvus import Collection, connections

# Connect to Milvus server
connections.connect(host="localhost", port="19530") # Change to your Milvus server IP and port

# Get existing collection
collection = Collection("quick_setup")

# Before setting memory mapping property, we need to release the collection first.
collection.release()

# Set memory mapping property to True or Flase
collection.set_properties(
    properties={
        "mmap.enabled": True
    }
)

Eine Sammlung löschen

Wenn eine Sammlung nicht mehr benötigt wird, können Sie die Sammlung löschen.

Um eine Sammlung zu löschen, verwenden Sie die drop_collection() Methode und geben Sie den Namen der Sammlung an.

Um eine Sammlung zu löschen, verwenden Sie die dropCollection() und geben Sie dabei den Namen der Sammlung an.

Um eine Sammlung zu löschen, verwenden Sie die dropCollection() Methode unter Angabe des Sammlungsnamens.

Um eine Sammlung zu löschen, können Sie den POST /v2/vectordb/collections/drop API-Endpunkt verwenden.

# 10. Drop the collections
client.drop_collection(
    collection_name="quick_setup"
)

client.drop_collection(
    collection_name="customized_setup_1"
)

client.drop_collection(
    collection_name="customized_setup_2"
)
import io.milvus.v2.service.collection.request.DropCollectionReq;

// 10. Drop collections

DropCollectionReq dropQuickSetupParam = DropCollectionReq.builder()
    .collectionName("quick_setup")
    .build();

client.dropCollection(dropQuickSetupParam);

DropCollectionReq dropCustomizedSetupParam = DropCollectionReq.builder()
    .collectionName("customized_setup_1")
    .build();

client.dropCollection(dropCustomizedSetupParam);

dropCustomizedSetupParam = DropCollectionReq.builder()
    .collectionName("customized_setup_2")
    .build();

client.dropCollection(dropCustomizedSetupParam);
// 10. Drop the collection
res = await client.dropCollection({
    collection_name: "customized_setup_2"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropCollection({
    collection_name: "customized_setup_1"
})

console.log(res.error_code)

// Output
// 
// Success
// 

res = await client.dropCollection({
    collection_name: "quick_setup"
})

console.log(res.error_code)

// Output
// 
// Success
// 
$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "quick_setup"
}'

# {
#     "code": 0,
#     "data": {}
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_1"
}'


# {
#     "code": 0,
#     "data": {}
# }


$ curl -X POST "http://${MILVUS_URI}/v2/vectordb/collections/drop" \
-H "Content-Type: application/json" \
-d '{
    "collectionName": "customized_setup_2"
}'


# {
#     "code": 0,
#     "data": {}
# }

Übersetzt vonDeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

War diese Seite hilfreich?