milvus-logo
LFAI
Casa
  • Guida per l'utente

Gestire le raccolte

Questa guida spiega come creare e gestire le raccolte utilizzando l'SDK di vostra scelta.

Prima di iniziare

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 e vector 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": {}
# }

Tradotto daDeepLogo

Try Managed Milvus for Free

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

Get Started
Feedback

Questa pagina è stata utile?