Database

Milvus introduce un livello di database al di sopra delle collezioni, fornendo un modo più efficiente di gestire e organizzare i dati e supportando la multi-tenancy.

Cos'è un database

In Milvus, un database serve come unità logica per organizzare e gestire i dati. Per migliorare la sicurezza dei dati e ottenere la multi-tenancy, è possibile creare più database per isolare logicamente i dati per diverse applicazioni o tenant. Ad esempio, si crea un database per archiviare i dati dell'utente A e un altro database per l'utente B.

Creare un database

È possibile utilizzare l'API RESTful di Milvus o gli SDK per creare i dati in modo programmatico.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

client.create_database(
    db_name="my_database_1"
)

import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.service.database.request.*;

ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

CreateDatabaseReq createDatabaseReq = CreateDatabaseReq.builder()
        .databaseName("my_database_1")
        .build();
client.createDatabase(createDatabaseReq);

import {MilvusClient} from '@zilliz/milvus2-sdk-node';
const client = new MilvusClient({ 
    address: "http://localhost:19530",
    token: 'root:Milvus' 
});

await client.createDatabase({
    db_name: "my_database_1"
 });

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
    Username: "root",
    Password: "Milvus",
})
if err != nil {
    // handle err
}

err = cli.CreateDatabase(ctx, milvusclient.NewCreateDatabaseOption("my_database_1"))
if err != nil {
    // handle err
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "my_database_1"
}'

È anche possibile impostare le proprietà del database quando lo si crea. L'esempio seguente imposta il numero di repliche del database.

client.create_database(
    db_name="my_database_2",
    properties={
        "database.replica.number": 3
    }
)

Map<String, String> properties = new HashMap<>();
properties.put("database.replica.number", "3");
CreateDatabaseReq createDatabaseReq = CreateDatabaseReq.builder()
        .databaseName("my_database_2")
        .properties(properties)
        .build();
client.createDatabase(createDatabaseReq);

await client.createDatabase({
    db_name: "my_database_2",
    properties: {
        "database.replica.number": 3
    }
});

err := cli.CreateDatabase(ctx, milvusclient.NewCreateDatabaseOption("my_database_2").WithProperty("database.replica.number", 3))
if err != nil {
    // handle err
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "my_database_2",
    "properties": {
        "database.replica.number": 3
    }
}'

Visualizzare i database

È possibile utilizzare l'API RESTful di Milvus o gli SDK per elencare tutti i database esistenti e visualizzarne i dettagli.

# List all existing databases
client.list_databases()

# Output
# ['default', 'my_database_1', 'my_database_2']

# Check database details
client.describe_database(
    db_name="default"
)

# Output
# {"name": "default"}

import io.milvus.v2.service.database.response.*;

ListDatabasesResp listDatabasesResp = client.listDatabases();

DescribeDatabaseResp descDBResp = client.describeDatabase(DescribeDatabaseReq.builder()
        .databaseName("default")
        .build());

await client.describeDatabase({ 
    db_name: 'default'
});

// List all existing databases
databases, err := cli.ListDatabase(ctx, milvusclient.NewListDatabaseOption())
if err != nil {
    // handle err
}
log.Println(databases)

db, err := cli.DescribeDatabase(ctx, milvusclient.NewDescribeDatabaseOption("default"))
if err != nil {
    // handle err
}
log.Println(db)

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/describe" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "default"
}'

Gestire le proprietà dei database

Ogni database ha le sue proprietà; è possibile impostare le proprietà di un database quando lo si crea, come descritto in Creare un database, oppure è possibile modificare e eliminare le proprietà di qualsiasi database esistente.

La seguente tabella elenca le possibili proprietà del database.

Proprietà Nome	Tipo	Proprietà Descrizione
database.replica.number	intero	Il numero di repliche per il database specificato.
database.resource_groups	stringa	I nomi dei gruppi di risorse associati al database specificato in un elenco comunemente separato.
database.diskQuota.mb	intero	La dimensione massima dello spazio su disco per il database specificato, in megabyte (MB).
database.max.collections	intero	Il numero massimo di raccolte consentite nel database specificato.
database.force.deny.writing	booleano	Se forzare il database specificato a negare le operazioni di scrittura.
database.force.deny.reading	booleano	Se forzare il database specificato a negare le operazioni di lettura.

Modifica delle proprietà del database

È possibile modificare le proprietà di un database esistente come segue. L'esempio seguente limita il numero di collezioni che si possono creare nel database.

client.alter_database_properties(
    db_name: "my_database_1",
    properties: {
        "database.max.collections": 10
    }
)

client.alterDatabaseProperties(AlterDatabasePropertiesReq.builder()
        .databaseName("my_database_1")
        .property("database.max.collections", "10")
        .build());

await milvusClient.alterDatabaseProperties({
  db_name: "my_database_1",
  properties: {"database.max.collections", "10" },
})

err := cli.AlterDatabaseProperties(ctx, milvusclient.NewAlterDatabasePropertiesOption("my_database_1").
    WithProperty("database.max.collections", 1))
if err != nil {
    // handle err
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/alter" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "my_database",
    "properties": {
        "database.max.collections": 10
    }
}'

Eliminare le proprietà del database

È anche possibile ripristinare una proprietà del database eliminandola come segue. L'esempio seguente rimuove il limite del numero di collezioni che si possono creare nel database.

client.drop_database_properties(
    db_name: "my_database_1",
    property_keys: [
        "database.max.collections"
    ]
)

client.dropDatabaseProperties(DropDatabasePropertiesReq.builder()
        .databaseName("my_database_1")
        .propertyKeys(Collections.singletonList("database.max.collections"))
        .build());

await milvusClient.dropDatabaseProperties({
  db_name: my_database_1,
  properties: ["database.max.collections"],
});

err := cli.DropDatabaseProperties(ctx, milvusclient.NewDropDatabasePropertiesOption("my_database_1", "database.max.collections"))
if err != nil {
    // handle err
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/alter" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "my_database",
    "propertyKeys": [
        "database.max.collections"
    ]
}'

Usa database

È possibile passare da un database all'altro senza disconnettersi da Milvus.

client.use_database(
    db_name="my_database_2"
)

client.useDatabase("my_database_2");

await milvusClient.useDatabase({
  db_name: "my_database_2",
});

err = cli.UseDatabase(ctx, milvusclient.NewUseDatabaseOption("my_database_2"))
if err != nil {
    // handle err
}

# This operation is unsupported because RESTful does not provide a persistent connection.
# As a workaround, initiate the required request again with the target database.

Abbandono del database

Quando un database non è più necessario, è possibile eliminarlo. Si noti che:

• I database predefiniti non possono essere eliminati.

• Prima di eliminare un database, è necessario eliminare tutte le collezioni nel database.

È possibile utilizzare l'API RESTful di Milvus o gli SDK per creare dati in modo programmatico.

client.drop_database(
    db_name="my_database_2"
)

client.dropDatabase(DropDatabaseReq.builder()
        .databaseName("my_database_2")
        .build());

await milvusClient.dropDatabase({
  db_name: "my_database_2",
});

err = cli.DropDatabase(ctx, milvusclient.NewDropDatabaseOption("my_database_2"))
if err != nil {
    // handle err
}

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/databases/drop" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "dbName": "my_database"
}'