Gestire le raccolte
Questa guida spiega come creare e gestire le raccolte utilizzando l'SDK di vostra scelta.
Prima di iniziare
Avete installato Milvus standalone o Milvus cluster.
Avete installato gli SDK preferiti. È possibile scegliere tra vari linguaggi, tra cui Python, Java, Go e Node.js.
Panoramica
In Milvus, si memorizzano le incorporazioni vettoriali in collezioni. Tutti gli embeddings vettoriali all'interno di una collezione condividono la stessa dimensionalità e la stessa metrica di distanza per misurare la somiglianza.
Le collezioni di Milvus supportano campi dinamici (cioè campi non predefiniti nello schema) e l'incremento automatico delle chiavi primarie.
Per soddisfare le diverse preferenze, Milvus offre due metodi per creare una collezione. Uno fornisce una configurazione rapida, mentre l'altro consente una personalizzazione dettagliata dello schema della collezione e dei parametri degli indici.
Inoltre, è possibile visualizzare, caricare, rilasciare e abbandonare una raccolta quando necessario.
Creare una raccolta
È possibile creare una raccolta in uno dei seguenti modi:
Impostazione rapida
In questo modo, è possibile creare una collezione semplicemente dandole un nome e specificando il numero di dimensioni delle incorporazioni vettoriali da memorizzare in questa collezione. Per ulteriori informazioni, consultare la sezione Impostazione rapida.
Configurazione personalizzata
Invece di lasciare che In Milvus decida quasi tutto per la vostra collezione, potete determinare da soli i parametri dello schema e dell'indice della collezione. Per maggiori dettagli, consultare la sezione Configurazione personalizzata.
Configurazione rapida
Nel contesto del grande balzo dell'industria dell'intelligenza artificiale, la maggior parte degli sviluppatori ha bisogno di una collezione semplice ma dinamica per iniziare. Milvus permette di configurare rapidamente una collezione di questo tipo con soli tre argomenti:
Nome della collezione da creare,
Dimensione delle incorporazioni vettoriali da inserire e
Tipo di metrica utilizzata per misurare le somiglianze tra gli embeddings vettoriali.
Per una rapida impostazione, utilizzare il metodo create_collection()
della classe MilvusClient
per creare un insieme con il nome e la dimensione specificati.
Per una configurazione rapida, utilizzare il metodo createCollection()
della classe MilvusClientV2
per creare un insieme con il nome e la dimensione specificati.
Per un'impostazione rapida, utilizzare il metodo createCollection()
della classe MilvusClient
per creare un insieme con il nome e la dimensione specificati.
Per una configurazione rapida, utilizzare l'endpoint POST /v2/vectordb/collections/create
per creare un insieme con il nome e la dimensione specificati.
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"
# }
# }
L'insieme generato nel codice precedente contiene solo due campi: id
(come chiave primaria) e vector
(come campo vettore), con le impostazioni auto_id
e enable_dynamic_field
abilitate per default.
auto_id
L'attivazione di questa impostazione fa sì che la chiave primaria si incrementi automaticamente. Non è necessario fornire manualmente le chiavi primarie durante l'inserimento dei dati.
enable_dynamic_field
Quando è abilitata, tutti i campi, esclusi
id
evector
nei dati da inserire, sono trattati come campi dinamici. Questi campi aggiuntivi vengono salvati come coppie chiave-valore all'interno di un campo speciale denominato$meta
. Questa funzione consente di includere campi aggiuntivi durante l'inserimento dei dati.
La collezione indicizzata e caricata automaticamente dal codice fornito è pronta per l'inserimento immediato dei dati.
Configurazione personalizzata
Invece di lasciare che Milvus decida quasi tutto per la vostra collezione, potete determinare da soli i parametri dello schema e dell'indice della collezione.
Passo 1: Impostazione dello schema
Uno schema definisce la struttura di una collezione. All'interno dello schema, si ha la possibilità di abilitare o disabilitare enable_dynamic_field
, aggiungere campi predefiniti e impostare attributi per ogni campo. Per una spiegazione dettagliata del concetto e dei tipi di dati disponibili, consultare Schema spiegato.
Per impostare uno schema, usare create_schema()
per creare un oggetto schema e add_field()
per aggiungere campi allo schema.
Per impostare uno schema, usare createSchema()
per creare un oggetto schema e addField()
per aggiungere campi allo schema.
Per impostare uno schema, usare createCollection()
.
Per impostare uno schema, è necessario definire un oggetto JSON che segua il formato dello schema visualizzato nella pagina di riferimento dell'endpoint API. POST /v2/vectordb/collections/create
pagina di riferimento dell'endpoint API.
# 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 \
} \
}]'
Parametro | Descrizione |
---|---|
auto_id |
Determina se il campo primario si incrementa automaticamente. Se si imposta su Vero, il campo primario si incrementa automaticamente. In questo caso, il campo primario non deve essere incluso nei dati da inserire per evitare errori. Gli ID generati automaticamente hanno una lunghezza fissa e non possono essere modificati. |
enable_dynamic_field |
Determina se Milvus salva i valori dei campi non definiti in un campo dinamico se i dati inseriti nella collezione di destinazione includono campi non definiti nello schema della collezione. Quando si imposta questa opzione su True, Milvus crea un campo chiamato $meta per memorizzare i campi non definiti e i loro valori dai dati inseriti. |
field_name |
Il nome del campo. |
datatype |
Il tipo di dati del campo. Per un elenco dei tipi di dati disponibili, consultare Tipo di dati. |
is_primary |
Se il campo corrente è il campo primario di un insieme. Ogni insieme ha un solo campo primario. Un campo primario deve essere del tipo DataType.INT64 o del tipo DataType.VARCHAR. |
dim |
La dimensione delle incorporazioni vettoriali. È obbligatoria per un campo di tipo DataType.FLOAT_VECTOR, DataType.BINARY_VECTOR, DataType.FLOAT16_VECTOR o DataType.BFLOAT16_VECTOR. Se si utilizza DataType.SPARSE_FLOAT_VECTOR, omettere questo parametro. |
Parametro | Descrizione |
---|---|
fieldName |
Il nome del campo. |
dataType |
Il tipo di dati del campo. Per un elenco dei tipi di dati disponibili, consultare DataType. |
isPrimaryKey |
Se il campo corrente è il campo primario di un insieme. Ogni insieme ha un solo campo primario. Un campo primario deve essere del tipo DataType.Int64 o del tipo DataType.VarChar. |
autoID |
Se permette al campo primario di incrementarsi automaticamente. Se si imposta true, il campo primario si incrementa automaticamente. In questo caso, il campo primario non deve essere incluso nei dati da inserire per evitare errori. |
dimension |
La dimensione delle incorporazioni vettoriali. È obbligatoria per un campo di tipo DataType.FloatVector, DataType.BinaryVector, DataType.Float16Vector o DataType.BFloat16Vector. |
Parametro | Descrizione |
---|---|
name |
Il nome del campo. |
data_type |
Il tipo di dati del campo. Per un'enumerazione di tutti i tipi di dati disponibili, consultare DataType. |
is_primary_key |
Se il campo corrente è il campo primario di un insieme. Ogni insieme ha un solo campo primario. Un campo primario deve essere del tipo DataType.INT64 o del tipo DataType.VARCHAR. |
auto_id |
Se il campo primario si incrementa automaticamente all'inserimento dei dati in questa collezione. Il valore predefinito è Falso. Impostando True, il campo primario si incrementa automaticamente. Ignorare questo parametro se si deve impostare una collezione con uno schema personalizzato. |
dim |
La dimensionalità del campo della raccolta che contiene le incorporazioni vettoriali. Il valore deve essere un intero maggiore di 1 e di solito è determinato dal modello utilizzato per generare le incorporazioni vettoriali. |
Parametro | Descrizione |
---|---|
fieldName |
Il nome del campo da creare nella collezione di destinazione. |
dataType |
Il tipo di dati dei valori del campo. |
isPrimary |
Se il campo corrente è il campo primario. Impostando questo valore su True , il campo corrente diventa il campo primario. |
elementTypeParams |
Parametri extra del campo. |
dim |
Un parametro opzionale per i campi FloatVector o BinaryVector che determina la dimensione del vettore. |
Passo 2: Impostazione dei parametri di indice
I parametri di indice determinano il modo in cui Milvus organizza i dati all'interno di una collezione. È possibile personalizzare il processo di indicizzazione per campi specifici regolando i loro metric_type
e index_type
. Per il campo vettoriale, è possibile selezionare COSINE
, L2
, IP
, HAMMING
, o JACCARD
come metric_type
, a seconda del tipo di vettori con cui si lavora. Per ulteriori informazioni, consultare Metriche di somiglianza.
Per impostare i parametri dell'indice, usare prepare_index_params()
per preparare i parametri dell'indice e add_index()
per aggiungere l'indice.
Per impostare i parametri dell'indice, usare IndexParam.
Per impostare i parametri dell'indice, usare createIndex()
.
Per impostare i parametri dell'indice, è necessario definire un oggetto JSON che segua il formato dei parametri dell'indice, come indicato nella pagina di riferimento dell'endpoint API. POST /v2/vectordb/collections/create
pagina di riferimento dell'endpoint API.
# 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 \
} \
}]'
Parametro | Descrizione |
---|---|
field_name |
Il nome del file di destinazione a cui si applica questo oggetto. |
index_type |
Il nome dell'algoritmo utilizzato per organizzare i dati nel campo specifico. Per gli algoritmi applicabili, fare riferimento a Indice in memoria e Indice su disco. |
metric_type |
L'algoritmo utilizzato per misurare la somiglianza tra i vettori. I valori possibili sono IP, L2, COSINE, JACCARD, HAMMING. È disponibile solo quando il campo specificato è un campo vettoriale. Per ulteriori informazioni, consultare la sezione Indici supportati in Milvus. |
params |
I parametri di regolazione fine per il tipo di indice specificato. Per maggiori dettagli sulle chiavi e gli intervalli di valori possibili, consultare Indice in memoria. |
Parametro | Descrizione |
---|---|
fieldName |
Il nome del campo di destinazione a cui si applica questo oggetto IndexParam. |
indexType |
Il nome dell'algoritmo utilizzato per organizzare i dati nel campo specifico. Per gli algoritmi applicabili, fare riferimento a Indice in memoria e Indice su disco. |
metricType |
La metrica di distanza da utilizzare per l'indice. I valori possibili sono IP, L2, COSINE, JACCARD, HAMMING. |
extraParams |
Parametri extra dell'indice. Per i dettagli, fare riferimento a Indice in memoria e Indice su disco. |
Parametro | Descrizione |
---|---|
field_name |
Il nome del campo di destinazione su cui creare un indice. |
index_type |
Il nome dell'algoritmo utilizzato per organizzare i dati nel campo specifico. Per gli algoritmi applicabili, fare riferimento a Indice in memoria e Indice su disco. |
metric_type |
L'algoritmo utilizzato per misurare la somiglianza tra i vettori. I valori possibili sono IP, L2, COSINE, JACCARD, HAMMING. È disponibile solo quando il campo specificato è un campo vettoriale. Per ulteriori informazioni, consultare la sezione Indici supportati in Milvus. |
params |
I parametri di regolazione fine per il tipo di indice specificato. Per maggiori dettagli sulle chiavi e gli intervalli di valori possibili, consultare Indice in memoria. |
Parametro | Descrizione |
---|---|
fieldName |
Il nome del campo di destinazione su cui creare un indice. |
indexName |
Il nome dell'indice da creare. Il valore predefinito è il nome del campo di destinazione. |
metricType |
L'algoritmo utilizzato per misurare la somiglianza tra i vettori. I valori possibili sono IP, L2, COSINE, JACCARD, HAMMING. Questa opzione è disponibile solo quando il campo specificato è un campo vettoriale. Per ulteriori informazioni, consultare la sezione Indici supportati in Milvus. |
params |
Il tipo di indice e le relative impostazioni. Per maggiori informazioni, vedere Indice in memoria. |
params.index_type |
Il tipo di indice da creare. |
params.nlist |
Il numero di unità cluster. Questo vale per i tipi di indice legati alla FIV. |
Il frammento di codice qui sopra mostra come impostare i parametri dell'indice rispettivamente per un campo vettoriale e per un campo scalare. Per il campo vettoriale, impostare sia il tipo di metrica che il tipo di indice. Per un campo scalare, impostare solo il tipo di indice. Si consiglia di creare un indice per il campo vettoriale e per tutti i campi scalari che vengono utilizzati frequentemente per il filtraggio.
Passo 3: Creare l'insieme
Si può scegliere di creare una collezione e un file indice separatamente o di creare una collezione con l'indice caricato contemporaneamente alla creazione.
Usare create_collection() per creare una collezione con i parametri di schema e indice specificati e get_load_state() per verificare lo stato di caricamento della collezione.
Usare createCollection() per creare una raccolta con i parametri di schema e indice specificati e getLoadState() per verificare lo stato di caricamento della raccolta.
Usare createCollection() per creare un insieme con i parametri di schema e indice specificati e getLoadState() per verificare lo stato di caricamento dell'insieme.
Creare una collezione con l'indice caricato contemporaneamente alla creazione.
# 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" # } # }
L'insieme creato in precedenza viene caricato automaticamente. Per ulteriori informazioni sul caricamento e il rilascio di una raccolta, consultare Carica e rilascia una raccolta.
Creare una raccolta e un file di indice separatamente.
# 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" # } # }
L'insieme creato sopra non viene caricato automaticamente. È possibile creare un indice per la raccolta come segue. La creazione di un indice per la raccolta in modo separato non carica automaticamente la raccolta. Per ulteriori informazioni, consultare la sezione Caricare e rilasciare la raccolta.
Parametro Descrizione collection_name
Il nome della raccolta. schema
Lo schema di questa raccolta.
Impostando questo valore a Nessuno, la raccolta verrà creata con le impostazioni predefinite.
Per impostare una raccolta con uno schema personalizzato, è necessario creare un oggetto CollectionSchema e fare riferimento a questo oggetto. In questo caso, Milvus ignora tutte le altre impostazioni relative allo schema contenute nella richiesta.index_params
I parametri per costruire l'indice sul campo vettoriale di questa collezione. Per impostare una collezione con uno schema personalizzato e caricare automaticamente la collezione in memoria, è necessario creare un oggetto IndexParams e fare riferimento qui.
È necessario aggiungere almeno un indice per il campo vettoriale di questa collezione. Si può anche saltare questo parametro se si preferisce impostare i parametri dell'indice in un secondo momento.Parametro Descrizione collectionName
Il nome della collezione. collectionSchema
Lo schema di questa raccolta.
Se lo si lascia vuoto, significa che la raccolta verrà creata con le impostazioni predefinite. Per impostare un insieme con uno schema personalizzato, è necessario creare un oggetto CollectionSchema e fare riferimento ad esso.indexParams
I parametri per costruire l'indice sul campo vettoriale di questa collezione. Per impostare una collezione con uno schema personalizzato e caricare automaticamente la collezione in memoria, creare un oggetto IndexParams con un elenco di oggetti IndexParam e fare riferimento qui. Parametro Descrizione collection_name
Il nome dell'insieme. fields
I campi della collezione. index_params
I parametri dell'indice per la collezione da creare. Parametro Descrizione collectionName
Il nome della raccolta. schema
Lo schema è responsabile dell'organizzazione dei dati nella raccolta di destinazione. Uno schema valido deve avere più campi, che devono includere una chiave primaria, un campo vettore e diversi campi scalari. schema.autoID
Se permette al campo primario di incrementarsi automaticamente. Impostando True, il campo primario si incrementa automaticamente. In questo caso, il campo primario non dovrebbe essere incluso nei dati da inserire per evitare errori. Impostare questo parametro nel campo con is_primary impostato su True. schema.enableDynamicField
Se permette di usare il campo riservato $meta per contenere campi non definiti dallo schema in coppie chiave-valore. fields
Un elenco di oggetti campo. fields.fieldName
Il nome del campo da creare nell'insieme di destinazione. fields.dataType
Il tipo di dati dei valori del campo. fields.isPrimary
Se il campo corrente è il campo primario. Impostando True, il campo corrente diventa il campo primario. fields.elementTypeParams
Parametri extra del campo. fields.elementTypeParams.dim
Un parametro opzionale per i campi FloatVector o BinaryVector che determina la dimensione del vettore. L'insieme creato sopra non viene caricato automaticamente. È possibile creare un indice per l'insieme come segue. La creazione di un indice per l'insieme in modo separato non carica automaticamente l'insieme. Per ulteriori informazioni, consultare la sezione Caricare e rilasciare l'insieme.
# 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" # } # }
Parametro Descrizione collection_name
Il nome della collezione. index_params
Un oggetto IndexParams contenente un elenco di oggetti IndexParam.
Parametro | Descrizione |
---|---|
collectionName |
Il nome della collezione. |
indexParams |
Un elenco di oggetti IndexParam. |
Parametro | Descrizione |
---|---|
collection_name |
Il nome della collezione. |
field_name |
Il nome del campo in cui creare un indice. |
index_type |
Il nome dell'algoritmo utilizzato per organizzare i dati nel campo specifico. Per gli algoritmi applicabili, fare riferimento a Indice in memoria e Indice su disco. |
metric_type |
L'algoritmo utilizzato per misurare la somiglianza tra i vettori. I valori possibili sono IP, L2, COSINE, JACCARD, HAMMING. È disponibile solo quando il campo specificato è un campo vettoriale. Per ulteriori informazioni, consultare la sezione Indici supportati in Milvus. |
params |
I parametri di regolazione fine per il tipo di indice specificato. Per maggiori dettagli sulle chiavi e gli intervalli di valori possibili, consultare Indice in memoria. |
Parametro | Descrizione |
---|---|
collectionName |
Il nome della collezione. |
indexParams |
I parametri dell'indice per la raccolta da creare. |
indexParams.metricType |
Il tipo di metrica di somiglianza utilizzata per costruire l'indice. Il valore predefinito è COSINE. |
indexParams.fieldName |
Il nome del campo di destinazione su cui creare un indice. |
indexParams.indexName |
Il nome dell'indice da creare; il valore predefinito è il nome del campo di destinazione. |
indexParams.indexConfig.index_type |
Il tipo di indice da creare. |
indexParams.indexConfig.nlist |
Il numero di unità di cluster. Questo vale per i tipi di indice legati alla FIV. |
Visualizzare le raccolte
Per verificare i dettagli di una raccolta esistente, usare describe_collection().
Per verificare i dettagli di una raccolta esistente, usare describeCollection().
Per verificare i dettagli di una collezione esistente, usare describeCollection().
Per visualizzare la definizione di un insieme, si possono usare i tasti POST /v2/vectordb/collections/describe
e l'endpoint POST /v2/vectordb/collections/list
endpoint dell'API.
# 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
# }
# }
Per elencare tutte le collezioni esistenti, si può procedere come segue:
# 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"
# ]
# }
Caricamento e rilascio della raccolta
Durante il processo di caricamento di una raccolta, Milvus carica in memoria il file di indice della raccolta. Al contrario, quando si rilascia una raccolta, Milvus scarica il file di indice dalla memoria. Prima di effettuare ricerche in una collezione, assicurarsi che la collezione sia caricata.
Caricare una collezione
Per caricare un insieme, utilizzare il metodo load_collection()
specificando il nome della collezione. Si può anche impostare replica_number
per determinare quante repliche in memoria dei segmenti di dati creare sui nodi di query quando la raccolta viene caricata.
- Milvus Standalone: Il valore massimo consentito per
replica_number
è 1. - Milvus Cluster: Il valore massimo non deve superare il valore
queryNode.replicas
impostato nelle configurazioni di Milvus. Per ulteriori dettagli, consultare la sezione Configurazioni relative ai nodi di query.
Per caricare una raccolta, usare il metodo loadCollection()
specificando il nome della collezione.
Per caricare un insieme, usare il metodo loadCollection()
specificando il nome dell'insieme.
Per caricare un insieme, si possono usare i metodi POST /v2/vectordb/collections/load
e il metodo POST /v2/vectordb/collections/get_load_state
endpoint dell'API.
# 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"
# }
# }
Caricare parzialmente una raccolta (anteprima pubblica)
Questa funzione è attualmente in anteprima pubblica. L'API e la funzionalità potrebbero cambiare in futuro.
Quando riceve la richiesta di caricamento, Milvus carica in memoria tutti gli indici dei campi vettoriali e tutti i dati dei campi scalari. Se alcuni campi non devono essere coinvolti nelle ricerche e nelle query, è possibile escluderli dal caricamento per ridurre l'utilizzo della memoria, migliorando le prestazioni della ricerca.
# 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>"
# }
Si noti che solo i campi elencati in load_fields
possono essere utilizzati come condizioni di filtraggio e campi di output nelle ricerche e nelle query. È necessario includere sempre la chiave primaria nell'elenco. I nomi dei campi esclusi dal caricamento non saranno disponibili per il filtraggio o l'output.
È possibile utilizzare skip_load_dynamic_field=True
per saltare il caricamento del campo dinamico. Milvus tratta il campo dinamico come un singolo campo, quindi tutte le chiavi del campo dinamico saranno incluse o escluse insieme.
Rilasciare una raccolta
Per rilasciare una collezione, utilizzare il metodo release_collection()
specificando il nome della collezione.
Per rilasciare un insieme, utilizzare il metodo releaseCollection()
specificando il nome dell'insieme.
Per rilasciare un insieme, utilizzare il metodo releaseCollection()
specificando il nome dell'insieme.
Per rilasciare un insieme, si possono usare i metodi POST /v2/vectordb/collections/release
e il metodo POST /v2/vectordb/collections/get_load_state
endpoint dell'API.
# 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"
# }
# }
Impostare gli alias
È possibile assegnare alias alle raccolte per renderle più significative in un contesto specifico. È possibile assegnare più alias a una raccolta, ma più raccolte non possono condividere un alias.
Creare gli alias
Per creare alias, utilizzare il metodo create_alias()
specificando il nome della collezione e l'alias.
Per creare alias, usare il metodo createAlias()
specificando il nome della collezione e l'alias.
Per creare alias, utilizzare il metodo createAlias()
specificando il nome della collezione e l'alias.
Per creare alias per una collezione, è possibile utilizzare l'endpoint POST /v2/vectordb/aliases/create
endpoint dell'API.
# 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": {}
# }
Parametro | Descrizione |
---|---|
collection_name |
Il nome della collezione per cui creare un alias. |
alias |
L'alias della raccolta. Prima di questa operazione, assicurarsi che l'alias non esista già. In caso contrario, si verificheranno delle eccezioni. |
Parametro | Descrizione |
---|---|
collectionName |
Il nome della collezione per cui creare un alias. |
alias |
L'alias della collezione. Prima di questa operazione, assicurarsi che l'alias non esista già. In caso contrario, si verificheranno delle eccezioni. |
Parametro | Descrizione |
---|---|
collection_name |
Il nome della collezione per cui creare un alias. |
alias |
L'alias della collezione. Prima di questa operazione, assicurarsi che l'alias non esista già. In caso contrario, si verificheranno delle eccezioni. |
Parametro | Descrizione |
---|---|
collectionName |
Il nome della collezione per cui creare un alias. |
aliasName |
L'alias della collezione. Prima di questa operazione, assicurarsi che l'alias non esista già. In caso contrario, si verificheranno delle eccezioni. |
Elenco degli alias
Per elencare gli alias, utilizzare il metodo list_aliases()
specificando il nome della collezione.
Per elencare gli alias, utilizzare il metodo listAliases()
specificando il nome dell'insieme.
Per elencare gli alias, utilizzare il metodo listAliases()
specificando il nome dell'insieme.
Per elencare gli alias di un insieme, è possibile utilizzare l'endpoint POST /v2/vectordb/aliases/list
endpoint dell'API.
# 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"
# ]
# }
Descrivere gli alias
Per descrivere gli alias, utilizzare il metodo describe_alias()
specificando l'alias.
Per descrivere gli alias, utilizzare il metodo describeAlias()
specificando l'alias.
Per descrivere gli alias, utilizzare il metodo describeAlias()
specificando l'alias.
Per descrivere gli alias di un insieme, è possibile utilizzare l'endpoint POST /v2/vectordb/aliases/describe
endpoint dell'API.
# 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"
# }
# }
Riassegnare gli alias
Per riassegnare gli alias ad altre raccolte, utilizzare il metodo alter_alias()
specificando il nome della collezione e l'alias.
Per riassegnare gli alias ad altre raccolte, utilizzare il metodo alterAlias()
specificando il nome della collezione e l'alias.
Per riassegnare gli alias ad altre raccolte, utilizzare il metodo alterAlias()
specificando il nome della collezione e l'alias.
Per riassegnare gli alias ad altre raccolte, è possibile utilizzare l'endpoint POST /v2/vectordb/aliases/alter
endpoint dell'API.
# 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"
# ]
# }
Eliminare gli alias
Per eliminare gli alias, utilizzare il metodo drop_alias()
specificando l'alias.
Per eliminare gli alias, utilizzare il metodo dropAlias()
specificando l'alias.
Per eliminare gli alias, utilizzare il metodo dropAlias()
specificando l'alias.
Per eliminare gli alias per un insieme, è possibile utilizzare il punto finale dell'API POST /v2/vectordb/aliases/drop
endpoint dell'API.
# 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": {}
# }
Impostare le proprietà
È possibile impostare le proprietà di un insieme, come ttl.seconds
e mmap.enabled
. Per ulteriori informazioni, consultare set_properties().
I frammenti di codice di questa sezione utilizzano il modulo ORM PyMilvus per interagire con Milvus. I frammenti di codice con il nuovo SDK MilvusClient saranno presto disponibili.
Imposta TTL
Imposta il Time-To-Live (TTL) per i dati della raccolta, che specifica per quanto tempo i dati devono essere conservati prima di essere cancellati automaticamente.
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
}
)
Imposta MMAP
Configura la proprietà di mappatura della memoria (MMAP) per l'insieme, che determina se i dati sono mappati in memoria per migliorare le prestazioni delle query. Per ulteriori informazioni, consultare Configurazione della mappatura della memoria.
Prima di impostare la proprietà MMAP, rilasciare l'insieme. In caso contrario, si verificherà un errore.
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
}
)
Abbandonare una raccolta
Se una raccolta non è più necessaria, è possibile eliminarla.
Per eliminare un insieme, utilizzare il metodo drop_collection()
specificando il nome dell'insieme.
Per eliminare un insieme, utilizzare il metodo dropCollection()
specificando il nome dell'insieme.
Per eliminare un insieme, utilizzare il metodo dropCollection()
specificando il nome dell'insieme.
Per eliminare un insieme, è possibile utilizzare l'endpoint POST /v2/vectordb/collections/drop
endpoint dell'API.
# 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": {}
# }