Milvus笔记

已于 2024-04-16 16:40:40 修改
阅读量421 收藏
点赞数 1
分类专栏： 应知应会 向量数据库 文章标签： milvus 笔记 数据库
于 2024-03-20 15:59:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44996457/article/details/136879564
版权

Milvus版本 2.3.5

    <dependency>
      <groupId>io.milvus</groupId>
      <artifactId>milvus-sdk-java</artifactId>
      <version>2.3.4</version> 还没有2.3.5依赖
        <!--      <scope>provided</scope>-->
    </dependency>

一、创建操作

1、python版本

from pymilvus import Collection, FieldSchema, DataType, CollectionSchema, connections
from pymilvus.orm import utility, db

from knowledge_brain.milvus_sink import milvus_sink
from study.connect import Connect

class MilvusOperatC:

    def __init__(self, host, port, user, password, db_name ,alias,collection_name,schema,num_shards): #,collection_name,schema,shards_num
        print("加载milvus依赖")
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db_name = db_name
        self.alias = alias
        self.collection_name = collection_name
        self.schema = schema
        self.num_shards = num_shards
        self.collection = self.con()

    #创建连接
    """
    host  ip
    port  端口
    user  用户名
    password 密码
    db_name 数据库
    alias 别名
    """

    def con(self):
        connections.connect(
            host=self.host,
            user=self.user,
            password=self.password,
            port=self.port,
            alias=self.alias)
        # 是否有该数据库，无则新建
        print("建立数据库连接~~~~")
        if self.db_name in db.list_database():
            pass
        else:
            print("没有%s数据库，进行新建~~~~" % self.db_name)
            db.create_database(self.db_name)
            print("新建%s数据库完成！" % self.db_name)
        # 使用数据库，建立数据库连接
        db.using_database(self.db_name)
        # 是否有该集合，无则创建
        if utility.has_collection(self.collection_name):
            print("集合已存在")
            pass
        else:
            print("没有%s集合，进行新建~~~~" % self.collection_name)
            self.col_create()
            print("新建%s集合完成！" % self.collection_name)
        collection = Collection(self.collection_name)
        print("数据库连接完成！")
        return collection

    #集合创建
    """
    collection_name 集合名称
    schema   表头描述信息
    database  数据库信息
    shards_num 分片信息
    """

    def col_create(self):
        # fields = [
        #     FieldSchema(name='vec', dtype=DataType.FLOAT_VECTOR, descrition='embedding vectors', dim=1024),
        #     FieldSchema(name='doc_slicing_id', dtype=DataType.VARCHAR, descrition='doc_slicing_id', max_length=100,
        #                 is_primary=True),
        #     FieldSchema(name='doc_id', dtype=DataType.VARCHAR, descrition='doc_id', max_length=100)
        # ]
        # schema = CollectionSchema(fields=fields, description=self.col_name)
        collection = Collection(name=self.collection_name, schema=self.schema,num_shards=self.num_shards)
        print(collection)

    #索引创建
    def index_create(self,index_params:str,vec_field:str):
        # create IVF_FLAT index for collection.
        # index_params = {
        #     'metric_type': 'L2',
        #     'index_type': "IVF_FLAT",
        #     'params': {"nlist": 150}
        # }
        self.collection.create_index(field_name=vec_field, index_params=index_params)
        # collection.create_index(
        #     field_name="doc_id",
        #     index_name="doc_id_index"
        # )
        # collection.load()

    #分区创建
    def partition_create(self,partition_name:str):
        self.collection.create_partition(partition_name)


    def load(self):
        self.collection.load()
        print("数据load成功")

    def unload(self):
        self.collection.release()


if __name__ == '__main__':
    host='XX.17.38'
    port='31639'
    user='Milvus'
    password='Milvus'
    db_name='knowledge_test'
    alias='default'


    fields = [
        FieldSchema(name='pk', dtype=DataType.INT64, descrition='主键', max_length=200, is_primary=True,
                    auto_id=True),
        FieldSchema(name='car_model', dtype=DataType.VARCHAR, descrition='car_model', max_length=65535, is_primary=False,
                    auto_id=False),
        FieldSchema(name='text', dtype=DataType.VARCHAR, descrition='page_content', max_length=65535, is_primary=False,
                    auto_id=False),
        FieldSchema(name='vector', dtype=DataType.FLOAT_VECTOR, descrition='embedding vectors', dim=1024)
    ]
    schema = CollectionSchema(fields=fields, description='集合描述')

    # Collection('test',schema)
    # MilvusCreate(host,port,user,password,db_name,alias,'test',schema,2)

    milvus_sink(db_name,'test',1,1,1)

python调用

from pymilvus import FieldSchema, DataType, CollectionSchema
from study.MilvusOperatC import MilvusOperatC

if __name__ == '__main__':
    host='XXX.17.38'
    port='31639sss'
    user='Milvus'
    password='Milvus'
    db_name='knowledge_test'
    alias='default'
    fields = [
        FieldSchema(name='pk', dtype=DataType.INT64, descrition='主键', max_length=200, is_primary=True,
                    auto_id=True),
        FieldSchema(name='car_model', dtype=DataType.VARCHAR, descrition='car_model', max_length=65535,
                    is_primary=False,
                    auto_id=False),
        FieldSchema(name='text', dtype=DataType.VARCHAR, descrition='page_content', max_length=65535, is_primary=False,
                    auto_id=False),
        FieldSchema(name='vector', dtype=DataType.FLOAT_VECTOR, descrition='embedding vectors', dim=1024)
    ]
    schema = CollectionSchema(fields=fields, description='集合描述')
    index_params = {
        'metric_type': 'L2',#COSINE IP
        'index_type': "IVF_FLAT",
        'params': {"nlist": 150}
    }
    #embedding字段名称
    vec_field = "vector"
    mc = MilvusOperatC(host,port,user,password,db_name,alias,'test',schema,2)
    mc.index_create(index_params,vec_field)
    mc.partition_create('2024032103')
    mc.load()
    mc.unload()


search_params = {
        "metric_type": "L2",
        "offset": 0,
        "ignore_growing": False,
        "params": {"nprobe": 10}
    }
    mc1 = MilvusOperatR(host, port, user, password, db_name, alias,'test')
    res = mc1.search(search_params=search_params,embeddings=[[0.5441558957099915,0.9319176077842712]],anns_field='vector',topK=10,expr=None,output_fields=['id','vector'])
    print(res)
    output_fields = ["id"]
    res1 = mc1.query(expr="",offset=0,topK=10,output_fields=output_fields)
    print(res1)
    res2 = mc1.count(expr="",output_fields=["count(*)"])
    print(res2)

2、java版本

package com.gwm.milvus;

import com.google.gson.internal.$Gson$Preconditions;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.DataType;
import io.milvus.grpc.GetLoadStateResponse;
import io.milvus.grpc.GetLoadingProgressResponse;
import io.milvus.param.*;
import io.milvus.param.collection.*;
import io.milvus.param.index.CreateIndexParam;
import io.milvus.param.partition.CreatePartitionParam;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/20 16:02
 */
public class MilvusOperateC {

    /**
     * 获取连接
     * @param host
     * @param port
     * @param username
     * @param password
     * @param database
     * @return
     */
    public static MilvusServiceClient getConn(String host,Integer port,String username,String password,String database){
        MilvusServiceClient milvusServiceClient= new MilvusServiceClient(ConnectParam
                .newBuilder()
                .withHost(host)
                .withPort(port)
                .withAuthorization(username, password)
                .withDatabaseName(database)
                .build());
        return milvusServiceClient;
    }

    /**
     * 创建集合
     * @param milvusServiceClient
     * @param collectionName
     * @param databaseName
     * @param shardsNum
     * @param description
     * @return
     */
    public static Integer col_create(MilvusServiceClient milvusServiceClient,String collectionName,String databaseName,Integer shardsNum,String description){
        FieldType fieldType1 = FieldType.newBuilder()
                .withName("id")
                .withDataType(DataType.Int64)
                .withPrimaryKey(true)
                .withAutoID(true)
                .build();
        FieldType fieldType2 = FieldType.newBuilder()
                .withName("text")
                .withDataType(DataType.VarChar)
                .withMaxLength(65535) //varchar类型必填
                .build();
        FieldType fieldType3 = FieldType.newBuilder()
                .withName("vector")
                .withDataType(DataType.FloatVector)
                .withDimension(1024)
                .build();
        CreateCollectionParam createCollectionParam
                = CreateCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .withDatabaseName(databaseName)
                .withShardsNum(shardsNum)
                .withDescription(description)
                .addFieldType(fieldType1)
                .addFieldType(fieldType2)
                .addFieldType(fieldType3)
                .build();
        R<RpcStatus> collection = milvusServiceClient.createCollection(createCollectionParam);
        Integer status = collection.getStatus();
        return status;
    }

    /**
     * 创建 索引
     * @param milvusServiceClient
     * @param metricType
     * @param collectionName
     * @param fieldName
     * @param INDEX_TYPE
     * @param INDEX_PARAM
     * @return
     */
    public static Integer index_create(MilvusServiceClient milvusServiceClient,MetricType metricType, String collectionName, String fieldName, IndexType INDEX_TYPE,String INDEX_PARAM){
        R<RpcStatus> index = milvusServiceClient.createIndex(
                CreateIndexParam.newBuilder()
                        .withCollectionName(collectionName)
                        .withFieldName(fieldName)
                        .withIndexType(INDEX_TYPE)
                        .withMetricType(metricType)
                        .withExtraParam(INDEX_PARAM)
                        .withSyncMode(Boolean.FALSE)
                        .build()
        );
        Integer status = index.getStatus();
        return status;
    }

    /**
     * 创建分区
     * @param milvusServiceClient
     * @param collectionName
     * @param partitionName
     * @return
     */
    public static Integer partition_create(MilvusServiceClient milvusServiceClient,String collectionName,String partitionName){
        R<RpcStatus> partition = milvusServiceClient.createPartition(
                CreatePartitionParam.newBuilder()
                        .withCollectionName(collectionName)
                        .withPartitionName(partitionName)
                        .build()
        );
        Integer status = partition.getStatus();
        return status;
    }

    /**
     * load数据到内存中，load进展情况
     * @param milvusServiceClient
     * @param collectionName
     * @param database
     * @return
     */
    public static Integer load(MilvusServiceClient milvusServiceClient,String collectionName,String database){
        // You can check the loading status
        Integer loadstatus = -1;
        GetLoadStateParam loadparam = GetLoadStateParam.newBuilder()
                .withCollectionName(collectionName)
                .build();
        R<GetLoadStateResponse> responseLoad = milvusServiceClient.getLoadState(loadparam);
        System.out.println("当前状态："+responseLoad.getData().getState());
        System.out.println("当前状态："+responseLoad.getStatus() + R.Status.Success.getCode());
        if (responseLoad.getStatus() != R.Status.Success.getCode()) {
            System.out.println(responseLoad.getMessage());
        }
//        System.out.println(responseLoad.getStatus());
//
//        // and loading progress as well
//
//        GetLoadingProgressParam loadingparam = GetLoadingProgressParam.newBuilder()
//                .withCollectionName(collectionName)
//                .build();
//        R<GetLoadingProgressResponse> responseLoading = milvusServiceClient.getLoadingProgress(loadingparam);
//        if (responseLoading.getStatus() != R.Status.Success.getCode()) {
//            System.out.println(responseLoading.getMessage());
//        }
//        /**
//         * load进展
//         */
//        System.out.println(responseLoading.getData().getProgress());
        LoadCollectionParam loadCollectionParam = LoadCollectionParam.newBuilder().withDatabaseName(database).withCollectionName(collectionName).build();
        R<RpcStatus> rpcStatusR = milvusServiceClient.loadCollection(loadCollectionParam);
        loadstatus = rpcStatusR.getStatus();
        return loadstatus;
    }

    /**
     * 释放内存数据
     * @param milvusServiceClient
     * @param collectionName
     * @return
     */
    public static Integer release(MilvusServiceClient milvusServiceClient,String collectionName){
        R<RpcStatus> rpcStatusR = milvusServiceClient.releaseCollection(
                ReleaseCollectionParam.newBuilder()
                        .withCollectionName(collectionName)
                        .build()
        );
        Integer status = rpcStatusR.getStatus();
        return status;
    }
}

rpcStatusR.getStatus()状态码
Success(0),
UnexpectedError(1),
ConnectFailed(2),           // Deprecated
PermissionDenied(3),        // Deprecated
CollectionNotExists(4),     // Deprecated
IllegalArgument(5),
IllegalDimension(7),        // Deprecated
IllegalIndexType(8),        // Deprecated
IllegalCollectionName(9),   // Deprecated
IllegalTOPK(10),            // Deprecated
IllegalRowRecord(11),       // Deprecated
IllegalVectorID(12),        // Deprecated
IllegalSearchResult(13),    // Deprecated
FileNotFound(14),           // Deprecated
MetaFailed(15),             // Deprecated
CacheFailed(16),            // Deprecated
CannotCreateFolder(17),     // Deprecated
CannotCreateFile(18),       // Deprecated
CannotDeleteFolder(19),     // Deprecated
CannotDeleteFile(20),       // Deprecated
BuildIndexError(21),        // Deprecated
IllegalNLIST(22),           // Deprecated
IllegalMetricType(23),      // Deprecated
OutOfMemory(24),            // Deprecated
IndexNotExist(25),          // Deprecated
EmptyCollection(26),
// internal error code.
DDRequestRace(1000),        // Deprecated
// Client side error
RpcError(-1),
ClientNotConnected(-2),
Unknown(-3),
VersionMismatch(-4),
ParamError(-5),
IllegalResponse(-6);

调用

package com.gwm.milvus;

import io.milvus.client.MilvusServiceClient;
import io.milvus.param.IndexType;
import io.milvus.param.MetricType;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/20 16:50
 */
public class MilvusTest {

    public static void main(String[] args) {

        String collectionName = "repositoryId_test1";
        String databaseName = "knowledge_cosine_test";
        Integer shards =2;
        String description = "测试java创建collection";
        MilvusServiceClient milvusClient =
                MilvusOperateC.getConn("XXX.17.38", 31630, "Milvus", "Milvus", "knowledge_test");

        Integer integer = MilvusOperateC.col_create(milvusClient,collectionName,databaseName,shards,description);
        System.out.println("collection创建状态："+integer);
        String INDEX_PARAM = "{\"nlist\":1024}";
        Integer vector = MilvusOperateC.index_create(milvusClient, MetricType.COSINE, collectionName, "vector", IndexType.IVF_FLAT, INDEX_PARAM);
        System.out.println("索引创建状态："+vector);
        Integer partitionCreate = MilvusOperateC.partition_create(milvusClient, collectionName, "20240320");
        System.out.println("分区创建状态："+partitionCreate);
        Integer load = MilvusOperateC.load(milvusClient, collectionName, databaseName);
        System.out.println("集合load状态："+load);
        Integer release = MilvusOperateC.release(milvusClient, collectionName);
        System.out.println("集合释放状态"+release);



ArrayList<ArrayList<Float>> embeddings = new ArrayList<>();
        List<Float> list = new ArrayList<>();
        list.add((float) 0.5441558957099915);
        list.add((float) 0.9319176077842712);
        ArrayList<String> outFields = new ArrayList<>();
        outFields.add("id");
        embeddings.add((ArrayList<Float>) list);
        ArrayList<String> countField = new ArrayList<>();
        countField.add("count(*)");
        SearchResults result = MilvusOperateR.search(milvusClient, collectionName, null, ConsistencyLevelEnum.STRONG, MetricType.L2,
                "vector", embeddings, 10, "", outFields
        );
        System.out.println(result.getResults());

        QueryResults query = MilvusOperateR.query(milvusClient, collectionName, null, ConsistencyLevelEnum.STRONG, "", 0L, 10L, outFields);
        System.out.println(query);

        QueryResults count = MilvusOperateR.count(milvusClient, collectionName, "", countField);
        System.out.println(count);
        List<FieldData> fieldsDataList = count.getFieldsDataList();
        for (FieldData fieldData:fieldsDataList){
            System.out.println(fieldData.getType());
            System.out.println(fieldData.getFieldName());
            System.out.println(fieldData.getScalars().getLongData().getData(0));
        }

    }


 System.out.println(MilvusCheck.databaseCheck(milvusClient, "test"));
        System.out.println(MilvusCheck.collectionCheck(milvusClient,databaseName,collectionName));
        System.out.println(MilvusCheck.partitionCheck(milvusClient,collectionName,"20240325"));
}

二、删除操作

1、python版本

from pymilvus import connections, Collection
from pymilvus.orm import db, utility


class MilvusOperatD:
    def __init__(self,host, port, user, password, db_name ,alias):
        print("加载milvus依赖")
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db_name = db_name
        self.alias = alias
        self.collection = self.con()

    def con(self):
        connections.connect(
            host=self.host,
            user=self.user,
            password=self.password,
            port=self.port,
            alias=self.alias)
        # 是否有该数据库，无则新建
        print("建立数据库连接~~~~")
        if self.db_name in db.list_database():
            pass
        else:
            print("没有%s数据库，进行新建~~~~" % self.db_name)
            db.create_database(self.db_name)
            print("新建%s数据库完成！" % self.db_name)
        # 使用数据库，建立数据库连接
        db.using_database(self.db_name)
        # 是否有该集合，无则创建
        if utility.has_collection(self.collection_name):
            print("集合已存在")
            pass
        else:
            print("没有%s集合，进行新建~~~~" % self.collection_name)
            self.col_create()
            print("新建%s集合完成！" % self.collection_name)
        collection = Collection(self.collection_name)
        print("数据库连接完成！")
        return collection
    #删除数据库
    def database_del(self,database_name):
        db.drop_database(database_name)

    #删除集合
    def collection_del(self,collection_name):
        utility.drop_collection(collection_name)

    #删除分区
    def partition_del(self,partition_name):
        self.collection.drop_partition(partition_name)
    #删除索引
    def index_del(self,index_name):
        self.collection.drop_index(index_name=index_name)

    #删除数据
    #expr rules  https://milvus.io/docs/v2.3.x/boolean.md
    def entity_del(self,expr):
        self.collection.delete(expr)

2、java版本

package com.gwm.milvus;

import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.MutationResult;
import io.milvus.param.ConnectParam;
import io.milvus.param.R;
import io.milvus.param.RpcStatus;
import io.milvus.param.collection.DropCollectionParam;
import io.milvus.param.collection.DropDatabaseParam;
import io.milvus.param.dml.DeleteParam;
import io.milvus.param.index.DropIndexParam;
import io.milvus.param.partition.DropPartitionParam;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/25 13:18
 */
public class MilvusOperateD {
    /**
     * 获取连接
     * @param host
     * @param port
     * @param username
     * @param password
     * @param database
     * @return
     */
    public static MilvusServiceClient getConn(String host, Integer port, String username, String password, String database){
        MilvusServiceClient milvusServiceClient= new MilvusServiceClient(ConnectParam
                .newBuilder()
                .withHost(host)
                .withPort(port)
                .withAuthorization(username, password)
                .withDatabaseName(database)
                .build());
        return milvusServiceClient;
    }

    /**
     * 删除数据库
     * @param milvusServiceClient
     * @param databaseName
     * @return
     */
    public static Integer database_del(MilvusServiceClient milvusServiceClient,String databaseName){
        DropDatabaseParam dropDatabaseParam= DropDatabaseParam.newBuilder().withDatabaseName(databaseName).build();
        R<RpcStatus> rpcStatusR = milvusServiceClient.dropDatabase(dropDatabaseParam);
        Integer status = rpcStatusR.getStatus();
        return status;
    }
    /**
     * 删除集合
     * @param milvusServiceClient
     * @param collectionName
     * @return
     */
    public static Integer collection_del(MilvusServiceClient milvusServiceClient,String databaseName,String collectionName){
        DropCollectionParam dropCollectionParam= DropCollectionParam.newBuilder().withDatabaseName(databaseName)
                .withCollectionName(collectionName).build();
        R<RpcStatus> rpcStatusR = milvusServiceClient.dropCollection(dropCollectionParam);
        Integer status = rpcStatusR.getStatus();
        return status;
    }

    /**
     * 删除分区
     * @param milvusServiceClient
     * @param collectionName
     * @return
     */
    public static Integer partition_del(MilvusServiceClient milvusServiceClient,String collectionName,String partitionName){
        DropPartitionParam dropPartitionParam= DropPartitionParam.newBuilder()
                .withCollectionName(collectionName)
                .withPartitionName(partitionName)
                .build();
        R<RpcStatus> rpcStatusR = milvusServiceClient.dropPartition(dropPartitionParam);
        Integer status = rpcStatusR.getStatus();
        return status;
    }

    /**
     * 删除索引
     * @param milvusServiceClient
     * @param collectionName
     * @return
     */
    public static Integer index_del(MilvusServiceClient milvusServiceClient,String collectionName,String indexName){
        DropIndexParam indexParam= DropIndexParam.newBuilder()
                .withCollectionName(collectionName)
                .withIndexName(indexName)
                .build();
        R<RpcStatus> rpcStatusR = milvusServiceClient.dropIndex(indexParam);
        Integer status = rpcStatusR.getStatus();
        return status;
    }

    /**
     * 删除数据
     * @param milvusServiceClient
     * @param collectionName
     * @return
     */
      public static Integer entity_del(MilvusServiceClient milvusServiceClient,String collectionName,String partitionName,String expr){
        DeleteParam deleteParam = DeleteParam.newBuilder()
                .withCollectionName(collectionName)
                .withPartitionName(partitionName)
                .withExpr(expr)
                .build();
        R<MutationResult> delete = milvusServiceClient.delete(deleteParam);
        Integer status = delete.getStatus();
        return status;
    }
}

三、修改操作

1、python版本

from random import random

from pymilvus import connections, Collection
from pymilvus.orm import db, utility


class MilvusOperatU:
    def __init__(self,host, port, user, password, db_name ,alias):
        print("加载milvus依赖")
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db_name = db_name
        self.alias = alias
        self.collection = self.con()

    def con(self):
        connections.connect(
            host=self.host,
            user=self.user,
            password=self.password,
            port=self.port,
            alias=self.alias)
        # 是否有该数据库，无则新建
        print("建立数据库连接~~~~")
        if self.db_name in db.list_database():
            pass
        else:
            print("没有%s数据库，进行新建~~~~" % self.db_name)
            db.create_database(self.db_name)
            print("新建%s数据库完成！" % self.db_name)
        # 使用数据库，建立数据库连接
        db.using_database(self.db_name)
        # 是否有该集合，无则创建
        if utility.has_collection(self.collection_name):
            print("集合已存在")
            pass
        else:
            print("没有%s集合，进行新建~~~~" % self.collection_name)
            self.col_create()
            print("新建%s集合完成！" % self.collection_name)
        collection = Collection(self.collection_name)
        print("数据库连接完成！")
        return collection

    def collection_rename(self,old_collection,new_collection):
        utility.rename_collection(old_collection, new_collection) # Output: True

    def collection_modify(self):
        self.collection.set_properties(properties={"collection.ttl.seconds": 1800})

    def upsert_entities(self,data):
        # nb = 3000
        # dim = 8
        # vectors = [[random.random() for _ in range(dim)] for _ in range(nb)]
        # data = [
        #     [i for i in range(nb)],
        #     [str(i) for i in range(nb)],
        #     [i for i in range(10000, 10000 + nb)],
        #     vectors,
        #     [str("dy" * i) for i in range(nb)]
        # ]
        mr = self.collection.upsert(data)
        mr.delete_count
        mr.upsert_count
        mr.insert_count

2、java版本

package com.gwm.milvus;

import com.alibaba.fastjson.JSONObject;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.MutationResult;
import io.milvus.param.ConnectParam;
import io.milvus.param.R;
import io.milvus.param.dml.InsertParam;
import io.milvus.param.dml.UpsertParam;

import java.util.List;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/25 13:54
 */
public class MilvusOperateU {
    /**
     * 获取连接
     * @param host
     * @param port
     * @param username
     * @param password
     * @param database
     * @return
     */
    public static MilvusServiceClient getConn(String host, Integer port, String username, String password, String database){
        MilvusServiceClient milvusServiceClient= new MilvusServiceClient(ConnectParam
                .newBuilder()
                .withHost(host)
                .withPort(port)
                .withAuthorization(username, password)
                .withDatabaseName(database)
                .build());
        return milvusServiceClient;
    }

    public static void collection_modify(MilvusServiceClient milvusServiceClient,String  collectionName){
        //没有java api
    }
    public static Integer upsert_entities(MilvusServiceClient milvusServiceClient, String databaseName, String colectionName, String partitionName
                    , List<InsertParam.Field> fields,List<JSONObject> rows){
        UpsertParam upsertParam = UpsertParam.newBuilder()
                .withDatabaseName(databaseName)
                .withCollectionName(colectionName)
                .withPartitionName(partitionName)
                .withFields(fields)
                .withRows(rows)
                .build();
        R<MutationResult> upsert = milvusServiceClient.upsert(upsertParam);
        Integer status = upsert.getStatus();
        return status;
    }
}

四、查询操作

1、python版本

import json

from pymilvus import connections, Collection
from pymilvus.orm import db, utility


class MilvusOperatR:
    def __init__(self,host, port, user, password, db_name ,alias,collection_name):
        print("加载milvus依赖")
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db_name = db_name
        self.collection_name = collection_name
        self.alias = alias
        self.collection = self.con()

    def con(self):
        connections.connect(
            host=self.host,
            user=self.user,
            password=self.password,
            port=self.port,
            alias=self.alias)
        # 是否有该数据库，无则新建
        print("建立数据库连接~~~~")
        if self.db_name in db.list_database():
            pass
        else:
            print("没有%s数据库，进行新建~~~~" % self.db_name)
            db.create_database(self.db_name)
            print("新建%s数据库完成！" % self.db_name)
        # 使用数据库，建立数据库连接
        db.using_database(self.db_name)
        # 是否有该集合，无则创建
        if utility.has_collection(self.collection_name):
            print("集合已存在")
            pass
        else:
            print("没有%s集合，进行新建~~~~" % self.collection_name)
            self.col_create()
            print("新建%s集合完成！" % self.collection_name)
        collection = Collection(self.collection_name)
        print("数据库连接完成！")
        return collection

    def search(self,search_params,embeddings,anns_field,topK,expr,output_fields):
        #load状态才能查询
        self.collection.load()
        # search_params = {
        #     "metric_type": "L2",
        #     "offset": 0,
        #     "ignore_growing": False,
        #     "params": {"nprobe": 10}
        # }
        results = self.collection.search(
            data=embeddings,
            anns_field=anns_field,
            # the sum of `offset` in `param` and `limit`
            # should be less than 16384.
            param=search_params,
            limit=topK,
            expr=expr,
            # set the names of the fields you want to
            # retrieve from the search result.
            output_fields=output_fields,
            consistency_level="Strong"
        )
        return results

    def query(self, expr, offset, topK, output_fields):
        self.collection.load()
        res = self.collection.query(
            expr=expr,
            offset=offset,
            limit=topK,
            # output_fields=["book_id", "book_intro"],
            output_fields=output_fields
        )
        return res

    def count(self, expr, output_fields):
        self.collection.load()

        #count计算不允许设置limit
        res = self.collection.query(
            expr=expr,
            # output_fields = ["count(*)"],
            output_fields=output_fields
        )
        return res

2、java版本

package com.gwm.milvus;

import io.milvus.client.MilvusServiceClient;
import io.milvus.common.clientenum.ConsistencyLevelEnum;
import io.milvus.grpc.QueryResults;
import io.milvus.grpc.SearchResults;
import io.milvus.param.ConnectParam;
import io.milvus.param.MetricType;
import io.milvus.param.R;
import io.milvus.param.dml.QueryParam;
import io.milvus.param.dml.SearchParam;
import io.milvus.param.highlevel.dml.QuerySimpleParam;

import java.util.ArrayList;
import java.util.List;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/25 15:28
 */
public class MilvusOperateR {
    /**
     * 获取连接
     * @param host
     * @param port
     * @param username
     * @param password
     * @param database
     * @return
     */
    public static MilvusServiceClient getConn(String host, Integer port, String username, String password, String database){
        MilvusServiceClient milvusServiceClient= new MilvusServiceClient(ConnectParam
                .newBuilder()
                .withHost(host)
                .withPort(port)
                .withAuthorization(username, password)
                .withDatabaseName(database)
                .build());
        return milvusServiceClient;
    }

    public static SearchResults search(MilvusServiceClient milvusServiceClient, String collectionName, List<String> partitionNames
                            , ConsistencyLevelEnum levelEnum    , MetricType metricType, String vectorName
                            , ArrayList<ArrayList<Float>> embeddings, Integer topK, String expr, List<String> outFields
                              ){
        SearchParam searchParam = SearchParam.newBuilder()
                .withCollectionName(collectionName)
//                .withPartitionNames(partitionNames)
                .withConsistencyLevel(levelEnum)
                .withMetricType(metricType)
                .withVectorFieldName(vectorName)
                .withVectors(embeddings)
                .withTopK(topK)
                .withExpr(expr)
                .withOutFields(outFields)
                .build();
        R<SearchResults> search = milvusServiceClient.search(searchParam);
        SearchResults data = search.getData();
        return data;

    }
    public static QueryResults query(MilvusServiceClient milvusServiceClient,String collectionName,List<String> partitionNames
                    ,ConsistencyLevelEnum levelEnum, String  expr      ,Long offset     ,Long topK,List<String> outFields
    ){
        QueryParam queryParam = QueryParam.newBuilder()
                .withCollectionName(collectionName)
//                .withPartitionNames(partitionNames)
                .withConsistencyLevel(levelEnum)
                .withExpr(expr)
                .withOffset(offset)
                .withLimit(topK)
                .withOutFields(outFields)
                .build();
        R<QueryResults> query = milvusServiceClient.query(queryParam);
        QueryResults data = query.getData();
        return data;

    }
    public static QueryResults count(MilvusServiceClient milvusServiceClient,String collectionName,String expr,List<String> outFields){
        QueryParam queryParam = QueryParam.newBuilder()
                .withCollectionName(collectionName)
                .withExpr(expr)
                .withOutFields(outFields) //["count(*)"]
                .build();
        R<QueryResults> query = milvusServiceClient.query(queryParam);
        QueryResults data = query.getData();
        return data;
    }
}

五、校验操作

1、python版本

from pymilvus import Collection
from pymilvus.orm import db, utility


class MilvusCheck:
    def __init__(self, host, port, user, password, db_name, alias, collection_name):
        print("加载milvus依赖")
        self.host = host
        self.port = port
        self.user = user
        self.password = password
        self.db_name = db_name
        self.collection_name = collection_name
        self.alias = alias
    def database_check(self):
        if self.db_name in db.list_database():
            return True
        else:
            return False
    def collection_check(self):
        if  utility.has_collection(self.collection_name):
            return True
        else:
            return False
    def partition_check(self,partition_name):
        collection = Collection(self.collection_name)
        if collection.has_partition(partition_name):
            return True
        else:
            return False
    def index_check(self):
        collection = Collection(self.collection_name)
        if collection.has_index():
            return True
        else:
            return False

2、java版本

package com.gwm.milvus;

import com.google.protobuf.ProtocolStringList;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.ListDatabasesResponse;
import io.milvus.param.ConnectParam;
import io.milvus.param.R;
import io.milvus.param.collection.HasCollectionParam;
import io.milvus.param.partition.HasPartitionParam;

/**
 * @author yangyingchun
 * @version 1.0
 * @date 2024/3/25 16:17
 */
public class MilvusCheck {
    /**
     * 获取连接
     * @param host
     * @param port
     * @param username
     * @param password
     * @param database
     * @return
     */
    public static MilvusServiceClient getConn(String host, Integer port, String username, String password, String database){
        MilvusServiceClient milvusServiceClient= new MilvusServiceClient(ConnectParam
                .newBuilder()
                .withHost(host)
                .withPort(port)
                .withAuthorization(username, password)
                .withDatabaseName(database)
                .build());
        return milvusServiceClient;
    }

    public static boolean databaseCheck(MilvusServiceClient milvusServiceClient,String databaseName){
        R<ListDatabasesResponse> listDatabasesResponseR = milvusServiceClient.listDatabases();
        ListDatabasesResponse data = listDatabasesResponseR.getData();
        System.out.println(data);
        ProtocolStringList dbNamesList = data.getDbNamesList();
        if (dbNamesList.contains(databaseName)){
            return true;
        }else {
            return false;
        }
    }

    public static boolean  collectionCheck(MilvusServiceClient milvusServiceClient,String databaseName,String collectionName){
        HasCollectionParam hasCollectionParam = HasCollectionParam.newBuilder()
                .withDatabaseName(databaseName)
                .withCollectionName(collectionName)
                .build();
        R<Boolean> booleanR = milvusServiceClient.hasCollection(hasCollectionParam);
        boolean b = booleanR.getData().booleanValue();
        return b;
    }

    public static boolean partitionCheck(MilvusServiceClient milvusServiceClient,String collectionName,String partitionName){
        HasPartitionParam hasPartitionParam = HasPartitionParam.newBuilder()
                .withCollectionName(collectionName)
                .withPartitionName(partitionName)
                .build();
        R<Boolean> booleanR = milvusServiceClient.hasPartition(hasPartitionParam);
        boolean b = booleanR.getData().booleanValue();
        return b;
    }

}

大数据00
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Milvus 2.3.功能全面升级，核心组件再升级，超低延迟
2301_78234743的博客
11-21 97
帝迈， QT客户端， N*15，2500基数5%公积金，975华大智造， 生信相关偏计算机， （N-1）* 14，全额12%公积金，965两个方向，算上公积金总。11.4通知简历初筛通过，线下面试11.5(三面)一面：询问研究生期间做的项目，主要让我介绍我做的项目：（1）矿业相关的app，以及作品截图(我有带) 、（2）1. 问项目，讲具体做了什么2. 项目里用到了 ES，讲了下 ES 为什么是近实时的3. 讲了讲 jvm，从内存分配到垃圾回收，cms，g1，还没开始讲类加载4。//原序列cin>>n;
使用Milvus搭建以图搜图服务
耿直丶的博客
04-03 1475
安装Milvus，使用deeplearning4j提取图片向量，实现以图搜图
Java【代码 16】Milvus向量库工具类和SeetaSDK获取人像向量和属性的工具类分享
Java与大数据相关实践内容分享！
07-07 1813
Milvus向量库工具类和SeetaSDK获取人像向量和属性的工具类分享
JAVA整合Milvus矢量数据库及数据
FDX0821的博客
06-10 9577
Milvus下载安装步骤及可视化工具、java整合Milvus进行数据操作，MilvusServiceClient
向量数据库Milvus-sdk-java整合Spring-Boot, 并整合apache-commons-pool2实现连接池管理
qq_44754301的博客
05-17 536
Milvus官方提供的milvus-sdk-java, 未能提供连接池管理能力, 故笔者借助apache-commons-pool2实现了基本的milvus连接池, 且将之与spring-boot整合, 方便嵌入开发流程, 仅供大家参考。
milvus安装资源以及zilliz安装资源
05-17
milvus 版本2.1.4 安装部署 前提，安装好docker 1、docker load -i xxx.tar 解压资源包 2、./conder-compose up -d //用docker-compost直接启动 3、docker run -itd --restart=always -p 13000:3000 -e HOST_URL=...
docs：Milvus文档
02-23
Milvus文档 该存储库包含技术文档， 是设计的开源矢量相似度搜索引擎。 可以在上找到最新的技术文档。 请注意，并非该存储库中存在网站上的所有文档。 一些项目具有自己的独立存储库和特定于项目的文档。 欢迎大家...
Milvus安装工具包
最新发布
06-12
Milvus安装工具包
milvus离线安装包1
11-17
milvus离线安装所需的镜像包，按照https://milvus.io/docs/v2.1.x/install_offline-docker.md#Download-files-and-images操作得到，一共3个包。
milvus离线安装包3
11-17
milvus离线安装所需的镜像包，按照https://milvus.io/docs/v2.1.x/install_offline-docker.md#Download-files-and-images操作得到，一共3个包。
milvus-sdk-node:Milvus 节点 SDK
07-24
Milvus2-sdk-节点 这是milvus2-sdk-node对Milvus的基本介绍。 all 函数将返回一个 promise，因此我们可以使用 async await 来获取结果。 依赖关系 Milvus：v2.x 节点：v12+ 安装 npm install @ zilliz / milvus2 - sdk - node 先决条件 在我们开始之前，有一些先决条件。 确保： 您有一个正在运行的 Milvus 实例。 @zilliz/milvus2-sdk-node 已正确安装。 连接 Milvus 首先，我们需要导入@zilliz/milvus-sdk-node。 import { MilvusClient } from "@zilliz/milvus2-sdk-node" ; 然后，我们就可以连接 Milvus 服务器了。 默认情况下 Milvus 运行在 l
Milvus 2.1 版本更新 - 简单可信赖、性能持续提升
ZILLIZ
10-14 4907
本文更新于 2.1.4 版本发布之际，与大家分享 Milvus 的新变化和产品的成长。
云原生向量数据库Milvus:数据与索引的处理流程、索引类型及Schema
丨汀、的博客
07-12 2243
本文将介绍 Milvus 系统中数据写入、索引构建、数据查询的具体处理流程，同时，还会介绍 Milvus 支持的索引类型；另外，还将讲述如何定义字段和集合 Schema。
疯狂SQL转换系列- SQL for Milvus
colorknight的专栏
03-22 438
Milvus提供的检索接口与SQL语法有一定差异，其SearchParam提供的部分参数可以直接映射为SQL语法的等同语义子句。由于这些概念在SQL中没有对应语义的子句，为不增加语法概念，MOQL Transx将这类接口都以Where子句中的函数形式进行表达。写在最后，我们如此疯狂的为各种数据库提供基于SQL访问的接口，主要是为了降低用户使用各类数据库进行数据检索时的学习成本。有兴趣的朋友可以关注我们的微信号“自由你的数据”并给我们留言，也可以通过直接扫描下面的二维码找到我们。Milvus查询参数接口。
SpringBoot集成Milvus|（实现向量的存储和查询）
Oaklkm的博客
04-17 3272
随着互联网不断发展，电子邮件、论文、物联网传感数据、社交媒体照片、蛋白质分子结构等非结构化数据已经变得越来越普遍。如果想要使用计算机来处理这些数据，需要使用 embedding 技术将这些数据转化为向量。随后，Milvus 会存储这些向量，并为其建立索引。Milvus 能够根据两个向量之间的距离来分析他们的相关性。如果两个向量十分相似，这说明向量所代表的源数据也十分相似Milvus 是一款云原生向量数据库，它具备高可用、高性能、易拓展的特点，用于海量向量数据的实时召回。
使用 Nginx 实现对 Milvus 的负载均衡
Archi-dreamer的博客
07-22 253
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
向量距离计算 java_Milvus 开发者专栏向量检索的应用
weixin_39961943的博客
12-04 448
作者：侯宇，业务架构师，Milvus 社区用户在深度学习的浪潮下，无论是文本、语音、图像、时间序列还是消费者特征，都可以用一组形如 [0.6, 0.3, 0.7,......0.19] 的实数来表征。这一组实数被称为特征向量。那什么是向量检索呢[1]？向量检索就是在一个给定向量数据集合中，检索出与查询向量最相近的 Topk 个向量。| 常见应用场景图片、视频、语音、文本等非结构化数据可以...
Milvus实践 第一章：简介与部署
weixin_47336776的博客
04-06 4412
业内最好的向量数据库及向量检索工具
milvus springboot
02-04
Milvus 是一个开源的向量相似度搜索引擎，而Spring Boot 是一个用于构建基于 Java 的独立、生产级的应用程序的框架。 Milvus Spring Boot 是将 Milvus 与 Spring Boot 框架结合使用的一种方式。借助 Spring Boot，我们可以更方便地构建基于 Milvus 的应用程序。 首先，我们可以使用 Spring Boot 的依赖管理功能，将 Milvus 的 Java 客户端库添加到项目中。这样，我们就可以在我们的应用程序中直接使用 Milvus 的功能，如向量的插入、查询和删除等。 其次，Spring Boot 提供了强大的配置管理功能，我们可以轻松地将 Milvus 的连接配置信息添加到应用程序的配置文件中，例如指定 Milvus 的 IP 地址、端口号和连接池大小等。这样，我们就可以灵活地管理 Milvus 与其他组件的连接。 另外，Spring Boot 还提供了便捷的 RESTful API 开发功能。我们可以利用这一特性，将 Milvus 的搜索引擎功能以接口的形式暴露给客户端，使得客户端可以通过 HTTP 请求来进行向量的检索。这样，我们可以轻松地建立一个灵活、高性能的分布式向量搜索系统。 总的来说，Milvus Spring Boot 结合了 Milvus 的强大功能和 Spring Boot 的便捷开发特性，使得我们可以更快速、灵活地搭建起一个高性能的向量搜索应用程序。它在大数据、人工智能等领域有广泛的应用前景，可以应对各种复杂的向量查询需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值