milvus-logo
LFAI
Home
  • Guia do utilizador

Gerir colecções

Este guia orienta-o na criação e gestão de colecções utilizando o SDK da sua escolha.

Antes de começar

Visão geral

No Milvus, armazena os seus embeddings vectoriais em colecções. Todos os embeddings vectoriais dentro de uma coleção partilham a mesma dimensionalidade e a mesma métrica de distância para medir a semelhança.

As colecções Milvus suportam campos dinâmicos (ou seja, campos não pré-definidos no esquema) e incrementação automática de chaves primárias.

Para acomodar diferentes preferências, Milvus oferece dois métodos para criar uma coleção. Um permite uma configuração rápida, enquanto o outro permite uma personalização detalhada do esquema da coleção e dos parâmetros do índice.

Adicionalmente, pode visualizar, carregar, libertar e largar uma coleção quando necessário.

Criar coleção

Pode criar uma coleção de uma das seguintes formas:

  • Configuração rápida

    Desta forma, pode criar uma coleção dando-lhe simplesmente um nome e especificando o número de dimensões das incorporações vectoriais a armazenar nesta coleção. Para obter detalhes, consulte Configuração rápida.

  • Configuração personalizada

    Em vez de deixar o In Milvus decidir quase tudo para a sua coleção, pode determinar o esquema e os parâmetros de índice da coleção por si próprio. Para mais detalhes, consulte Configuração personalizada.

Configuração rápida

Tendo como pano de fundo o grande salto na indústria da IA, a maioria dos programadores apenas precisa de uma coleção simples mas dinâmica para começar. Milvus permite uma configuração rápida de tal coleção com apenas três argumentos:

  • Nome da coleção a criar,

  • Dimensão dos vectores a inserir, e

  • Tipo de métrica utilizada para medir as semelhanças entre as incorporações vectoriais.

Para uma configuração rápida, utilize o método create_collection() da classe MilvusClient para criar uma coleção com o nome e a dimensão especificados.

Para uma configuração rápida, utilize o método createCollection() da classe MilvusClientV2 para criar uma coleção com o nome e a dimensão especificados.

Para uma configuração rápida, utilize o método createCollection() da classe MilvusClient para criar uma coleção com o nome e a dimensão especificados.

Para uma configuração rápida, utilize o ponto de extremidade POST /v2/vectordb/collections/create API para criar uma coleção com o nome e a dimensão especificados.

Python Java Node.js cURL
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"
#     }
# }

A coleção gerada no código acima contém apenas dois campos: id (como a chave primária) e vector (como o campo vetorial), com as definições auto_id e enable_dynamic_field activadas por predefinição.

  • auto_id

    A ativação desta definição garante que a chave primária é incrementada automaticamente. Não há necessidade de fornecimento manual de chaves primárias durante a inserção de dados.

  • enable_dynamic_field

    Quando activada, todos os campos, excluindo id e vector nos dados a inserir, são tratados como campos dinâmicos. Estes campos adicionais são guardados como pares chave-valor num campo especial denominado $meta. Esta funcionalidade permite a inclusão de campos extra durante a inserção de dados.

A coleção automaticamente indexada e carregada a partir do código fornecido está pronta para a inserção imediata de dados.

Configuração personalizada

Em vez de deixar o Milvus decidir quase tudo para a sua coleção, pode determinar o esquema e os parâmetros de indexação da coleção por si próprio.

Passo 1: Configurar o esquema

Um esquema define a estrutura de uma coleção. No esquema, tem a opção de ativar ou desativar enable_dynamic_field, adicionar campos pré-definidos e definir atributos para cada campo. Para obter uma explicação detalhada do conceito e dos tipos de dados disponíveis, consulte Esquema explicado.

Para configurar um esquema, utilize create_schema() para criar um objeto de esquema e add_field() para adicionar campos ao esquema.

Para configurar um esquema, utilizar createSchema() para criar um objeto de esquema e addField() para adicionar campos ao esquema.

Para configurar um esquema, utilizar createCollection().

Para configurar um esquema, é necessário definir um objeto JSON que siga o formato do esquema, conforme apresentado na POST /v2/vectordb/collections/create página de referência do ponto de extremidade da API.

Python Java Node.js cURL
# 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 \
    } \
}]'
Parâmetro Descrição
auto_id Determina se o campo primário é incrementado automaticamente.
Definir este parâmetro como Verdadeiro faz com que o campo primário seja incrementado automaticamente. Neste caso, o campo primário não deve ser incluído nos dados a inserir para evitar erros. Os IDs gerados automaticamente têm um comprimento fixo e não podem ser alterados.
enable_dynamic_field Determina se o Milvus guarda os valores dos campos indefinidos num campo dinâmico, se os dados que estão a ser inseridos na coleção de destino incluírem campos que não estão definidos no esquema da coleção.
Se definir esta opção como True, o Milvus criará um campo chamado $meta para guardar quaisquer campos indefinidos e os respectivos valores dos dados inseridos.
field_name O nome do campo.
datatype O tipo de dados do campo. Para obter uma lista dos tipos de dados disponíveis, consulte DataType.
is_primary Se o campo atual é o campo primário de uma coleção.
Cada coleção tem apenas um campo primário. Um campo primário deve ser do tipo DataType.INT64 ou do tipo DataType.VARCHAR.
dim A dimensão dos embeddings de vetor.
Isto é obrigatório para um campo do tipo DataType.FLOAT_VECTOR, DataType.BINARY_VECTOR, DataType.FLOAT16_VECTOR ou DataType.BFLOAT16_VECTOR. Se utilizar DataType.SPARSE_FLOAT_VECTOR, omita este parâmetro.
Parâmetro Descrição do campo
fieldName O nome do campo.
dataType O tipo de dados do campo. Para obter uma lista dos tipos de dados disponíveis, consulte DataType.
isPrimaryKey Se o campo atual é o campo primário de uma coleção.
Cada coleção tem apenas um campo primário. Um campo primário deve ser do tipo DataType.Int64 ou do tipo DataType.VarChar.
autoID Se permite que o campo primário seja incrementado automaticamente.
Se definir este valor como verdadeiro, o campo primário é incrementado automaticamente. Neste caso, o campo primário não deve ser incluído nos dados a inserir para evitar erros.
dimension A dimensão dos embeddings de vetor.
Isto é obrigatório para um campo do tipo DataType.FloatVector, DataType.BinaryVector, DataType.Float16Vector ou DataType.BFloat16Vector.
Parâmetro Descrição do campo
name O nome do campo.
data_type O tipo de dados do campo. Para obter uma enumeração de todos os tipos de dados disponíveis, consulte DataType.
is_primary_key Se o campo atual é o campo primário de uma coleção.
Cada coleção tem apenas um campo primário. Um campo primário deve ser do tipo DataType.INT64 ou do tipo DataType.VARCHAR.
auto_id Se o campo primário é automaticamente incrementado aquando da inserção de dados nesta coleção.
O valor predefinido é False. Definir este parâmetro como True faz com que o campo primário seja incrementado automaticamente. Ignore este parâmetro se precisar de configurar uma coleção com um esquema personalizado.
dim A dimensionalidade do campo de coleção que contém as incorporações de vetor.
O valor deve ser um número inteiro superior a 1 e é normalmente determinado pelo modelo que utiliza para gerar incorporações de vetor.
Parâmetro Descrição
fieldName O nome do campo a criar na coleção de destino.
dataType O tipo de dados dos valores do campo.
isPrimary Se o campo atual é o campo primário. Definir isto como True faz com que o campo atual seja o campo primário.
elementTypeParams Parâmetros de campo extra.
dim Um parâmetro opcional para campos FloatVector ou BinaryVector que determina a dimensão do vetor.

Passo 2: Configurar parâmetros de índice

Os parâmetros de indexação ditam a forma como o Milvus organiza os seus dados dentro de uma coleção. Pode personalizar o processo de indexação para campos específicos, ajustando os seus metric_type e index_type. Para o campo vetorial, tem a flexibilidade de selecionar COSINE, L2, IP, HAMMING, ou JACCARD como metric_type, dependendo do tipo de vectores com que está a trabalhar. Para obter mais informações, consulte Métricas de similaridade.

Para configurar os parâmetros de índice, utilize prepare_index_params() para preparar os parâmetros do índice e add_index() para adicionar o índice.

Para configurar os parâmetros do índice, utilize IndexParam.

Para configurar os parâmetros do índice, utilize createIndex().

Para configurar os parâmetros do índice, é necessário definir um objeto JSON que siga o formato dos parâmetros do índice, conforme apresentado na POST /v2/vectordb/collections/create página de referência do ponto de extremidade da API.

Python Java Node.js cURL
# 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 \
  } \
}]'
Parâmetro Descrição do objeto
field_name O nome do ficheiro de destino a que se aplica este objeto.
index_type O nome do algoritmo utilizado para organizar os dados no campo específico. Para os algoritmos aplicáveis, consulte Índice na memória e Índice no disco.
metric_type O algoritmo que é utilizado para medir a semelhança entre vectores. Os valores possíveis são IP, L2, COSINE, JACCARD, HAMMING. Esta opção só está disponível quando o campo especificado é um campo vetorial. Para mais informações, consulte Índices suportados no Milvus.
params Os parâmetros de ajuste fino para o tipo de índice especificado. Para obter detalhes sobre as chaves possíveis e intervalos de valores, consulte Índice na memória.
Parâmetro Descrição
fieldName O nome do campo de destino a que se aplica este objeto IndexParam.
indexType O nome do algoritmo utilizado para organizar os dados no campo específico. Para os algoritmos aplicáveis, consulte Índice na memória e Índice no disco.
metricType A métrica de distância a utilizar para o índice. Os valores possíveis são IP, L2, COSINE, JACCARD, HAMMING.
extraParams Parâmetros de índice extra. Para obter detalhes, consulte Índice na memória e Índice no disco.
Parâmetro Descrição
field_name O nome do campo de destino no qual um índice deve ser criado.
index_type O nome do algoritmo utilizado para organizar os dados no campo específico. Para os algoritmos aplicáveis, consulte Índice na memória e Índice no disco.
metric_type O algoritmo que é utilizado para medir a semelhança entre vectores. Os valores possíveis são IP, L2, COSINE, JACCARD, HAMMING. Esta opção só está disponível quando o campo especificado é um campo vetorial. Para mais informações, consulte Índices suportados no Milvus.
params Os parâmetros de ajuste fino para o tipo de índice especificado. Para obter detalhes sobre as chaves possíveis e intervalos de valores, consulte Índice na memória.
Parâmetro Descrição
fieldName O nome do campo de destino no qual um índice deve ser criado.
indexName O nome do índice a ser criado. A predefinição do valor é o nome do campo de destino.
metricType O algoritmo que é utilizado para medir a semelhança entre vectores. Os valores possíveis são IP, L2, COSINE, JACCARD, HAMMING. Esta opção só está disponível quando o campo especificado é um campo de vetor. Para obter mais informações, consulte Índices suportados no Milvus.
params O tipo de índice e as configurações relacionadas. Para obter detalhes, consulte Índice na memória.
params.index_type O tipo do índice a ser criado.
params.nlist O número de unidades de cluster. Isto aplica-se aos tipos de índice relacionados com o IVF.

O fragmento de código acima demonstra como configurar os parâmetros de índice para o campo vetorial e um campo escalar, respetivamente. Para o campo vetorial, defina o tipo de métrica e o tipo de índice. Para um campo escalar, defina apenas o tipo de índice. Recomenda-se a criação de um índice para o campo vetorial e quaisquer campos escalares que sejam frequentemente utilizados para filtragem.

Passo 3: Criar a coleção

Tem a opção de criar uma coleção e um ficheiro de índice separadamente ou de criar uma coleção com o índice carregado simultaneamente na criação.

Utilize create_collection() para criar uma coleção com o esquema e os parâmetros de índice especificados e get_load_state() para verificar o estado de carregamento da coleção.

Utilize createCollection() para criar uma coleção com o esquema e os parâmetros de índice especificados e getLoadState() para verificar o estado de carregamento da coleção.

Utilize createCollection() para criar uma coleção com o esquema e os parâmetros de índice especificados e getLoadState() para verificar o estado de carregamento da coleção.

  • Crie uma coleção com o índice carregado simultaneamente aquando da criação.

    Python JavaNode.jscURL

    # 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"
#     }
# }

    A coleção criada acima é carregada automaticamente. Para saber mais sobre o carregamento e a libertação de uma coleção, consulte Carregar e libertar colecções.

  • Crie uma coleção e um arquivo de índice separadamente.

    Python JavaNode.jscURL

    # 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"
#     }
# }

    A coleção criada acima não é carregada automaticamente. Pode criar um índice para a coleção da seguinte forma. A criação de um índice para a coleção de uma forma separada não carrega automaticamente a coleção. Para obter detalhes, consulte Carregar e liberar coleção.

    Parâmetro Descrição
    collection_name O nome da coleção.
    schema O esquema desta coleção.
    Se definir este parâmetro como None indica que esta coleção será criada com as definições por defeito.
    Para configurar uma coleção com um esquema personalizado, é necessário criar um objeto CollectionSchema e referenciá-lo aqui. Neste caso, o Milvus ignora todas as outras definições relacionadas com o esquema incluídas no pedido.
    index_params Os parâmetros para construir o índice no campo vetorial desta coleção. Para configurar uma coleção com um esquema personalizado e carregar automaticamente a coleção para a memória, é necessário criar um objeto IndexParams e referenciá-lo aqui.
    Deve pelo menos adicionar um índice para o campo vetorial nesta coleção. Também pode ignorar este parâmetro se preferir configurar os parâmetros do índice mais tarde.

    Parâmetro Descrição
    collectionName O nome da coleção.
    collectionSchema O esquema desta coleção.
    Se o deixar vazio, indica que esta coleção será criada com as predefinições. Para configurar uma coleção com um esquema personalizado, é necessário criar um objeto CollectionSchema e referenciá-lo aqui.
    indexParams Os parâmetros para criar o índice no campo de vetor nesta coleção. Para configurar uma coleção com um esquema personalizado e carregar automaticamente a coleção para a memória, crie um objeto IndexParams com uma lista de objectos IndexParam e faça referência a este objeto aqui.

    Parâmetro Descrição
    collection_name O nome da coleção.
    fields Os campos na coleção.
    index_params Os parâmetros de índice para a coleção a criar.

    Parâmetro Descrição
    collectionName O nome da coleção.
    schema O esquema é responsável pela organização dos dados na coleção de destino. Um esquema válido deve ter vários campos, que devem incluir uma chave primária, um campo vetorial e vários campos escalares.
    schema.autoID Se permite que o campo primário seja incrementado automaticamente. Definir este valor como True faz com que o campo primário seja incrementado automaticamente. Neste caso, o campo primário não deve ser incluído nos dados a inserir para evitar erros. Defina este parâmetro no campo com is_primary definido como True.
    schema.enableDynamicField Se permite utilizar o campo reservado $meta para guardar campos não definidos pelo esquema em pares de valores chave.
    fields Uma lista de objectos de campo.
    fields.fieldName O nome do campo a criar na coleção de destino.
    fields.dataType O tipo de dados dos valores do campo.
    fields.isPrimary Se o campo atual é o campo primário. Definir isto como Verdadeiro torna o campo atual o campo primário.
    fields.elementTypeParams Parâmetros de campo extra.
    fields.elementTypeParams.dim Um parâmetro opcional para campos FloatVector ou BinaryVector que determina a dimensão do vetor.

    A coleção criada acima não é carregada automaticamente. Pode criar um índice para a coleção da seguinte forma. A criação de um índice para a coleção de uma forma separada não carrega automaticamente a coleção. Para obter detalhes, consulte Carregar e liberar coleção.

    Python JavaNode.jscURL

    # 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"
#     }
# }
    Parâmetro Descrição da coleção
    collection_name O nome da coleção.
    index_params Um objeto IndexParams que contém uma lista de objectos IndexParam.
Parâmetro Descrição
collectionName O nome da coleção.
indexParams Uma lista de objectos IndexParam.
Parâmetro Descrição
collection_name O nome da coleção.
field_name O nome do campo no qual se pretende criar um índice.
index_type O nome do algoritmo utilizado para organizar os dados no campo específico. Para obter informações sobre os algoritmos aplicáveis, consulte Índice na memória e Índice no disco.
metric_type O algoritmo que é utilizado para medir a semelhança entre vectores. Os valores possíveis são IP, L2, COSINE, JACCARD, HAMMING. Esta opção só está disponível quando o campo especificado é um campo vetorial. Para mais informações, consulte Índices suportados no Milvus.
params Os parâmetros de ajuste fino para o tipo de índice especificado. Para obter detalhes sobre as chaves possíveis e intervalos de valores, consulte Índice na memória.
Parâmetro Descrição
collectionName O nome da coleção.
indexParams Os parâmetros de índice para a coleção a criar.
indexParams.metricType O tipo de métrica de similaridade utilizado para criar o índice. O valor predefinido é COSINE.
indexParams.fieldName O nome do campo de destino no qual um índice deve ser criado.
indexParams.indexName O nome do índice a criar, o valor predefinido é o nome do campo de destino.
indexParams.indexConfig.index_type O tipo do índice a ser criado.
indexParams.indexConfig.nlist O número de unidades de cluster. Isto aplica-se aos tipos de índice relacionados com FIV.

Visualizar colecções

Para verificar os detalhes de uma coleção existente, utilize describe_collection().

Para verificar os detalhes de uma coleção existente, utilize describeCollection().

Para verificar os detalhes de uma coleção existente, utilize describeCollection().

Para ver a definição de uma coleção, pode utilizar os botões POST /v2/vectordb/collections/describe e o POST /v2/vectordb/collections/list pontos de extremidade da API.

Python Java Node.js cURL
# 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
#     }
# }

Para listar todas as colecções existentes, pode fazer o seguinte:

Python Java Node.js cURL
# 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"
#   ]
# }

Carregar e libertar uma coleção

Durante o processo de carregamento de uma coleção, o Milvus carrega o ficheiro de índice da coleção para a memória. Por outro lado, ao liberar uma coleção, Milvus descarrega o arquivo de índice da memória. Antes de efetuar pesquisas numa coleção, certifique-se de que a coleção está carregada.

Carregar uma coleção

Para carregar uma coleção, utilize o método load_collection() especificando o nome da coleção. Também pode definir replica_number para determinar quantas réplicas de segmentos de dados na memória devem ser criadas nos nós de consulta quando a coleção é carregada.

  • Milvus Standalone: O valor máximo permitido para replica_number é 1.
  • Milvus Cluster: O valor máximo não deve exceder o queryNode.replicas definido nas configurações do Milvus. Para obter mais detalhes, consulte Configurações relacionadas ao nó de consulta.

Para carregar uma coleção, utilize o método loadCollection() especificando o nome da coleção.

Para carregar uma coleção, utilize o método loadCollection() especificando o nome da coleção.

Para carregar uma coleção, pode utilizar os métodos POST /v2/vectordb/collections/load e o POST /v2/vectordb/collections/get_load_state pontos de extremidade da API.

Python Java Node.js cURL
# 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"
#     }
# }

Libertar uma coleção

Para libertar uma coleção, utilize o método release_collection() especificando o nome da coleção.

Para libertar uma coleção, utilize o método releaseCollection() especificando o nome da coleção.

Para libertar uma coleção, utilize o método releaseCollection() método, especificando o nome da coleção.

Para libertar uma coleção, pode utilizar o método POST /v2/vectordb/collections/release e o POST /v2/vectordb/collections/get_load_state pontos de extremidade da API.

Python Java Node.js cURL
# 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"
#     }
# }

Configurar pseudónimos

Pode atribuir pseudónimos às colecções para as tornar mais significativas num contexto específico. É possível atribuir vários pseudónimos a uma coleção, mas não é possível partilhar um pseudónimo com várias colecções.

Criar aliases

Para criar aliases, utilize o método create_alias() especificando o nome da coleção e o alias.

Para criar aliases, utilize o método createAlias() especificando o nome da coleção e o alias.

Para criar aliases, utilize o método createAlias() especificando o nome da coleção e o pseudónimo.

Para criar aliases para uma coleção, pode utilizar o POST /v2/vectordb/aliases/create ponto de extremidade da API.

Python Java Node.js cURL
# 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": {}
# }
Parâmetro Descrição da coleção
collection_name O nome da coleção para a qual se pretende criar um alias.
alias O pseudónimo da coleção. Antes desta operação, certifique-se de que o pseudónimo ainda não existe. Se existir, ocorrerão excepções.
Parâmetro Descrição
collectionName O nome da coleção para a qual se pretende criar um alias.
alias O pseudónimo da coleção. Antes desta operação, certifique-se de que o alias ainda não existe. Se existir, ocorrerão excepções.
Parâmetro Descrição
collection_name O nome da coleção para a qual se pretende criar um alias.
alias O pseudónimo da coleção. Antes desta operação, certifique-se de que o alias ainda não existe. Se existir, ocorrerão excepções.
Parâmetro Descrição
collectionName O nome da coleção para a qual se pretende criar um alias.
aliasName O pseudónimo da coleção. Antes desta operação, certifique-se de que o alias ainda não existe. Se existir, ocorrerão excepções.

Listar aliases

Para listar os aliases, utilize o método list_aliases() especificando o nome da coleção.

Para listar aliases, utilize o método listAliases() especificando o nome da coleção.

Para listar os aliases, utilize o método listAliases() especificando o nome da coleção.

Para listar os aliases de uma coleção, pode utilizar o POST /v2/vectordb/aliases/list ponto de extremidade da API.

Python Java Node.js cURL
# 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"
#     ]
# }

Descrever pseudónimos

Para descrever aliases, utilize o método describe_alias() especificando o alias.

Para descrever aliases, utilize o método describeAlias() método, especificando o alias.

Para descrever os aliases, utilize o método describeAlias() especificando o alias.

Para descrever os aliases de uma coleção, pode utilizar o POST /v2/vectordb/aliases/describe ponto de extremidade da API.

Python Java Node.js cURL
# 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"
#     }
# }

Reatribuir aliases

Para reatribuir aliases a outras colecções, utilize o método alter_alias() especificando o nome da coleção e o alias.

Para reatribuir aliases a outras colecções, utilize o método alterAlias() especificando o nome da coleção e o pseudónimo.

Para reatribuir aliases a outras colecções, utilize o método alterAlias() especificando o nome da coleção e o pseudónimo.

Para reatribuir aliases a outras colecções, pode utilizar o POST /v2/vectordb/aliases/alter ponto de extremidade da API.

Python Java Node.js cURL
# 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"
#     ]
# }

Eliminar pseudónimos

Para eliminar aliases, utilize o método drop_alias() especificando o alias.

Para eliminar aliases, utilize o método dropAlias() especificando o alias.

Para eliminar os pseudónimos, utilize o método dropAlias() especificando o alias.

Para eliminar os aliases de uma coleção, pode utilizar o POST /v2/vectordb/aliases/drop ponto final da API.

Python Java Node.js
# 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": {}
# }

Definir propriedades

É possível definir propriedades para uma coleção, tais como ttl.seconds e mmap.enabled. Para mais informações, consulte set_properties().

Os trechos de código nesta secção utilizam o módulo PyMilvus ORM para interagir com Milvus. Os trechos de código com o novo SDK MilvusClient estarão disponíveis em breve.

Definir TTL

Define o Time-To-Live (TTL) para os dados na coleção, o que especifica quanto tempo os dados devem ser retidos antes de serem automaticamente eliminados.

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

Definir MMAP

Configure a propriedade de mapeamento de memória (MMAP) para a coleção, que determina se os dados são mapeados na memória para melhorar o desempenho da consulta. Para obter mais informações, consulte Configurar mapeamento de memória.

Antes de definir a propriedade MMAP, liberte primeiro a coleção. Caso contrário, ocorrerá um erro.

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

Abandonar uma coleção

Se uma coleção já não for necessária, pode abandoná-la.

Para eliminar uma coleção, utilize o método drop_collection() especificando o nome da coleção.

Para eliminar uma coleção, utilize o método dropCollection() especificando o nome da coleção.

Para eliminar uma coleção, utilize o método dropCollection() método, especificando o nome da coleção.

Para eliminar uma coleção, pode utilizar o POST /v2/vectordb/collections/drop ponto final da API.

Python Java Node.js cURL
# 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": {}
# }

Traduzido porDeepLogo

Tabela de conteúdos

Try Zilliz Cloud for Free

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

Get Started
Feedback

Esta página foi útil?