Verwalten von Sammlungen
Dieser Leitfaden führt Sie durch die Erstellung und Verwaltung von Sammlungen mit dem SDK Ihrer Wahl.
Bevor Sie beginnen
Sie haben Milvus standalone oder Milvus cluster installiert.
Sie haben die gewünschten SDKs installiert. Sie können zwischen verschiedenen Sprachen wählen, darunter Python, Java, Go und Node.js.
Ü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
undvector
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": {}
# }