milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add collection alias (#7255) 

Signed-off-by: Yusup <yusup@lsgrep.com>
pull/8197/head
Yusup 2021-09-18 03:13:51 +00:00 committed by GitHub
parent a6b6d16381
commit ccb57ba4b2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 5201 additions and 1026 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
internal/core/src/pb/common.pb.cc
View File

@ -226,36 +226,37 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"sued\020\001\022\016\n\nInProgress\020\002\022\014\n\010Finished\020\003\022\n\n\006"
"Failed\020\004*f\n\014SegmentState\022\024\n\020SegmentState"
"None\020\000\022\014\n\010NotExist\020\001\022\013\n\007Growing\020\002\022\n\n\006Sea"
"led\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005*\204\010\n\007Msg"
"led\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005*\264\010\n\007Msg"
"Type\022\r\n\tUndefined\020\000\022\024\n\020CreateCollection\020"
"d\022\022\n\016DropCollection\020e\022\021\n\rHasCollection\020f"
"\022\026\n\022DescribeCollection\020g\022\023\n\017ShowCollecti"
"ons\020h\022\024\n\020GetSystemConfigs\020i\022\022\n\016LoadColle"
"ction\020j\022\025\n\021ReleaseCollection\020k\022\024\n\017Create"
"Partition\020\310\001\022\022\n\rDropPartition\020\311\001\022\021\n\014HasP"
"artition\020\312\001\022\026\n\021DescribePartition\020\313\001\022\023\n\016S"
"howPartitions\020\314\001\022\023\n\016LoadPartitions\020\315\001\022\026\n"
"\021ReleasePartitions\020\316\001\022\021\n\014ShowSegments\020\372\001"
"\022\024\n\017DescribeSegment\020\373\001\022\021\n\014LoadSegments\020\374"
"\001\022\024\n\017ReleaseSegments\020\375\001\022\024\n\017HandoffSegmen"
"ts\020\376\001\022\030\n\023LoadBalanceSegments\020\377\001\022\020\n\013Creat"
"eIndex\020\254\002\022\022\n\rDescribeIndex\020\255\002\022\016\n\tDropInd"
"ex\020\256\002\022\013\n\006Insert\020\220\003\022\013\n\006Delete\020\221\003\022\n\n\005Flush"
"\020\222\003\022\013\n\006Search\020\364\003\022\021\n\014SearchResult\020\365\003\022\022\n\rG"
"etIndexState\020\366\003\022\032\n\025GetIndexBuildProgress"
"\020\367\003\022\034\n\027GetCollectionStatistics\020\370\003\022\033\n\026Get"
"PartitionStatistics\020\371\003\022\r\n\010Retrieve\020\372\003\022\023\n"
"\016RetrieveResult\020\373\003\022\024\n\017WatchDmChannels\020\374\003"
"\022\025\n\020RemoveDmChannels\020\375\003\022\027\n\022WatchQueryCha"
"nnels\020\376\003\022\030\n\023RemoveQueryChannels\020\377\003\022\020\n\013Se"
"gmentInfo\020\330\004\022\r\n\010TimeTick\020\260\t\022\023\n\016QueryNode"
"Stats\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016\n\tRequestID\020\263\t"
"\022\017\n\nRequestTSO\020\264\t\022\024\n\017AllocateSegment\020\265\t\022"
"\026\n\021SegmentStatistics\020\266\t\022\025\n\020SegmentFlushD"
"one\020\267\t\022\017\n\nDataNodeTt\020\270\t*\"\n\007DslType\022\007\n\003Ds"
"l\020\000\022\016\n\nBoolExprV1\020\001B5Z3github.com/milvus"
"-io/milvus/internal/proto/commonpbb\006prot"
"o3"
"ction\020j\022\025\n\021ReleaseCollection\020k\022\017\n\013Create"
"Alias\020l\022\r\n\tDropAlias\020m\022\016\n\nAlterAlias\020n\022\024"
"\n\017CreatePartition\020\310\001\022\022\n\rDropPartition\020\311\001"
"\022\021\n\014HasPartition\020\312\001\022\026\n\021DescribePartition"
"\020\313\001\022\023\n\016ShowPartitions\020\314\001\022\023\n\016LoadPartitio"
"ns\020\315\001\022\026\n\021ReleasePartitions\020\316\001\022\021\n\014ShowSeg"
"ments\020\372\001\022\024\n\017DescribeSegment\020\373\001\022\021\n\014LoadSe"
"gments\020\374\001\022\024\n\017ReleaseSegments\020\375\001\022\024\n\017Hando"
"ffSegments\020\376\001\022\030\n\023LoadBalanceSegments\020\377\001\022"
"\020\n\013CreateIndex\020\254\002\022\022\n\rDescribeIndex\020\255\002\022\016\n"
"\tDropIndex\020\256\002\022\013\n\006Insert\020\220\003\022\013\n\006Delete\020\221\003\022"
"\n\n\005Flush\020\222\003\022\013\n\006Search\020\364\003\022\021\n\014SearchResult"
"\020\365\003\022\022\n\rGetIndexState\020\366\003\022\032\n\025GetIndexBuild"
"Progress\020\367\003\022\034\n\027GetCollectionStatistics\020\370"
"\003\022\033\n\026GetPartitionStatistics\020\371\003\022\r\n\010Retrie"
"ve\020\372\003\022\023\n\016RetrieveResult\020\373\003\022\024\n\017WatchDmCha"
"nnels\020\374\003\022\025\n\020RemoveDmChannels\020\375\003\022\027\n\022Watch"
"QueryChannels\020\376\003\022\030\n\023RemoveQueryChannels\020"
"\377\003\022\020\n\013SegmentInfo\020\330\004\022\r\n\010TimeTick\020\260\t\022\023\n\016Q"
"ueryNodeStats\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016\n\tRequ"
"estID\020\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017AllocateSeg"
"ment\020\265\t\022\026\n\021SegmentStatistics\020\266\t\022\025\n\020Segme"
"ntFlushDone\020\267\t\022\017\n\nDataNodeTt\020\270\t*\"\n\007DslTy"
"pe\022\007\n\003Dsl\020\000\022\016\n\nBoolExprV1\020\001B5Z3github.co"
"m/milvus-io/milvus/internal/proto/common"
"pbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
};
@ -270,7 +271,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2282,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2330,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 6, 0,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 6, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -370,6 +371,9 @@ bool MsgType_IsValid(int value) {
case 105:
case 106:
case 107:
case 108:
case 109:
case 110:
case 200:
case 201:
case 202:

3
internal/core/src/pb/common.pb.h
View File

@ -208,6 +208,9 @@ enum MsgType : int {
GetSystemConfigs = 105,
LoadCollection = 106,
ReleaseCollection = 107,
CreateAlias = 108,
DropAlias = 109,
AlterAlias = 110,
CreatePartition = 200,
DropPartition = 201,
HasPartition = 202,

2052
internal/core/src/pb/milvus.pb.cc
View File

File diff suppressed because it is too large Load Diff

1101
internal/core/src/pb/milvus.pb.h
View File

File diff suppressed because it is too large Load Diff

12
internal/datacoord/mock_test.go
View File

@ -192,6 +192,18 @@ type mockRootCoordService struct {
cnt int64
}
func (m *mockRootCoordService) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoordService) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoordService) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func newMockRootCoordService() *mockRootCoordService {
return &mockRootCoordService{state: internalpb.StateCode_Healthy}
}

12
internal/distributed/proxy/service.go
View File

@ -417,3 +417,15 @@ func (s *Server) RegisterLink(ctx context.Context, request *milvuspb.RegisterLin
func (s *Server) GetMetrics(ctx context.Context, request *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
return s.proxy.GetMetrics(ctx, request)
}
func (s *Server) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
return s.proxy.CreateAlias(ctx, request)
}
func (s *Server) DropAlias(ctx context.Context, request *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
return s.proxy.DropAlias(ctx, request)
}
func (s *Server) AlterAlias(ctx context.Context, request *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
return s.proxy.AlterAlias(ctx, request)
}

21
internal/distributed/rootcoord/client/client.go
View File

@ -559,3 +559,24 @@ func (c *GrpcClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequ
}
return ret.(*milvuspb.GetMetricsResponse), err
}
func (c *GrpcClient) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
ret, err := c.recall(func() (interface{}, error) {
return c.grpcClient.CreateAlias(ctx, req)
})
return ret.(*commonpb.Status), err
}
func (c *GrpcClient) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
ret, err := c.recall(func() (interface{}, error) {
return c.grpcClient.DropAlias(ctx, req)
})
return ret.(*commonpb.Status), err
}
func (c *GrpcClient) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
ret, err := c.recall(func() (interface{}, error) {
return c.grpcClient.AlterAlias(ctx, req)
})
return ret.(*commonpb.Status), err
}

12
internal/distributed/rootcoord/service.go
View File

@ -63,6 +63,18 @@ type Server struct {
closer io.Closer
}
func (s *Server) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
return s.rootCoord.CreateAlias(ctx, request)
}
func (s *Server) DropAlias(ctx context.Context, request *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
return s.rootCoord.DropAlias(ctx, request)
}
func (s *Server) AlterAlias(ctx context.Context, request *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
return s.rootCoord.AlterAlias(ctx, request)
}
func NewServer(ctx context.Context, factory msgstream.Factory) (*Server, error) {
ctx1, cancel := context.WithCancel(ctx)
s := &Server{

4
internal/proto/common.proto
View File

@ -83,6 +83,10 @@ enum MsgType {
GetSystemConfigs = 105;
LoadCollection = 106;
ReleaseCollection = 107;
CreateAlias = 108;
DropAlias = 109;
AlterAlias = 110;
/* DEFINITION REQUESTS: PARTITION */
CreatePartition = 200;

174
internal/proto/commonpb/common.pb.go
View File

@ -205,6 +205,9 @@ const (
MsgType_GetSystemConfigs MsgType = 105
MsgType_LoadCollection MsgType = 106
MsgType_ReleaseCollection MsgType = 107
MsgType_CreateAlias MsgType = 108
MsgType_DropAlias MsgType = 109
MsgType_AlterAlias MsgType = 110
// DEFINITION REQUESTS: PARTITION
MsgType_CreatePartition MsgType = 200
MsgType_DropPartition MsgType = 201
@ -265,6 +268,9 @@ var MsgType_name = map[int32]string{
105: "GetSystemConfigs",
106: "LoadCollection",
107: "ReleaseCollection",
108: "CreateAlias",
109: "DropAlias",
110: "AlterAlias",
200: "CreatePartition",
201: "DropPartition",
202: "HasPartition",
@ -318,6 +324,9 @@ var MsgType_value = map[string]int32{
"GetSystemConfigs": 105,
"LoadCollection": 106,
"ReleaseCollection": 107,
"CreateAlias": 108,
"DropAlias": 109,
"AlterAlias": 110,
"CreatePartition": 200,
"DropPartition": 201,
"HasPartition": 202,
@ -694,86 +703,87 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 1288 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0xd9, 0x6e, 0xdb, 0x46,
0x17, 0xb6, 0x44, 0xd9, 0x32, 0xc7, 0xb2, 0x3d, 0x1e, 0x2f, 0x71, 0xf2, 0x1b, 0x3f, 0x02, 0x5f,
0x05, 0x06, 0x62, 0xb7, 0x0d, 0xda, 0x5e, 0xe5, 0x22, 0x16, 0xbd, 0x08, 0x89, 0x97, 0x52, 0x4e,
0x5a, 0xf4, 0x26, 0x18, 0x93, 0x47, 0xd2, 0x34, 0xe4, 0x8c, 0x3a, 0x33, 0x74, 0xac, 0xfb, 0x3e,
0x40, 0x9b, 0xe7, 0x68, 0x8b, 0xee, 0x2d, 0xfa, 0x04, 0xdd, 0xaf, 0xfb, 0x08, 0x7d, 0x80, 0xae,
0x59, 0x8b, 0x33, 0xa4, 0x24, 0x06, 0x48, 0xef, 0x78, 0xbe, 0xb3, 0x7d, 0xf3, 0x9d, 0x39, 0x43,
0xd2, 0x88, 0x54, 0x9a, 0x2a, 0xb9, 0xd9, 0xd7, 0xca, 0x2a, 0xb6, 0x98, 0x8a, 0xe4, 0x2c, 0x33,
0xb9, 0xb5, 0x99, 0xbb, 0xd6, 0xef, 0x92, 0xa9, 0xb6, 0xe5, 0x36, 0x33, 0xec, 0x3a, 0x21, 0xa0,
0xb5, 0xd2, 0x77, 0x23, 0x15, 0xc3, 0x6a, 0xe5, 0x72, 0xe5, 0xca, 0xdc, 0x2b, 0xff, 0xdf, 0x7c,
0x41, 0xce, 0xe6, 0x0e, 0x86, 0x35, 0x55, 0x0c, 0xa1, 0x0f, 0xc3, 0x4f, 0xb6, 0x42, 0xa6, 0x34,
0x70, 0xa3, 0xe4, 0x6a, 0xf5, 0x72, 0xe5, 0x8a, 0x1f, 0x16, 0xd6, 0xfa, 0x6b, 0xa4, 0x71, 0x13,
0x06, 0x77, 0x78, 0x92, 0xc1, 0x31, 0x17, 0x9a, 0x51, 0xe2, 0xdd, 0x83, 0x81, 0xab, 0xef, 0x87,
0xf8, 0xc9, 0x96, 0xc8, 0xe4, 0x19, 0xba, 0x8b, 0xc4, 0xdc, 0x58, 0x5f, 0x23, 0xb5, 0xed, 0x44,
0x9d, 0x8e, 0xbd, 0x98, 0xd1, 0x18, 0x7a, 0xaf, 0x92, 0xfa, 0x8d, 0x38, 0xd6, 0x60, 0x0c, 0x9b,
0x23, 0x55, 0xd1, 0x2f, 0xea, 0x55, 0x45, 0x9f, 0x31, 0x52, 0xeb, 0x2b, 0x6d, 0x5d, 0x35, 0x2f,
0x74, 0xdf, 0xeb, 0x0f, 0x2a, 0xa4, 0x7e, 0x60, 0xba, 0xdb, 0xdc, 0x00, 0x7b, 0x9d, 0x4c, 0xa7,
0xa6, 0x7b, 0xd7, 0x0e, 0xfa, 0xc3, 0x53, 0xae, 0xbd, 0xf0, 0x94, 0x07, 0xa6, 0x7b, 0x32, 0xe8,
0x43, 0x58, 0x4f, 0xf3, 0x0f, 0x64, 0x92, 0x9a, 0x6e, 0x2b, 0x28, 0x2a, 0xe7, 0x06, 0x5b, 0x23,
0xbe, 0x15, 0x29, 0x18, 0xcb, 0xd3, 0xfe, 0xaa, 0x77, 0xb9, 0x72, 0xa5, 0x16, 0x8e, 0x01, 0x76,
0x89, 0x4c, 0x1b, 0x95, 0xe9, 0x08, 0x5a, 0xc1, 0x6a, 0xcd, 0xa5, 0x8d, 0xec, 0xf5, 0xeb, 0xc4,
0x3f, 0x30, 0xdd, 0x7d, 0xe0, 0x31, 0x68, 0xf6, 0x12, 0xa9, 0x9d, 0x72, 0x93, 0x33, 0x9a, 0xf9,
0x6f, 0x46, 0x78, 0x82, 0xd0, 0x45, 0x6e, 0x7c, 0x5b, 0x23, 0xfe, 0x68, 0x12, 0x6c, 0x86, 0xd4,
0xdb, 0x59, 0x14, 0x81, 0x31, 0x74, 0x82, 0x2d, 0x92, 0xf9, 0xdb, 0x12, 0xce, 0xfb, 0x10, 0x59,
0x88, 0x5d, 0x0c, 0xad, 0xb0, 0x05, 0x32, 0xdb, 0x54, 0x52, 0x42, 0x64, 0x77, 0xb9, 0x48, 0x20,
0xa6, 0x55, 0xb6, 0x44, 0xe8, 0x31, 0xe8, 0x54, 0x18, 0x23, 0x94, 0x0c, 0x40, 0x0a, 0x88, 0xa9,
0xc7, 0x2e, 0x90, 0xc5, 0xa6, 0x4a, 0x12, 0x88, 0xac, 0x50, 0xf2, 0x50, 0xd9, 0x9d, 0x73, 0x61,
0xac, 0xa1, 0x35, 0x2c, 0xdb, 0x4a, 0x12, 0xe8, 0xf2, 0xe4, 0x86, 0xee, 0x66, 0x29, 0x48, 0x4b,
0x27, 0xb1, 0x46, 0x01, 0x06, 0x22, 0x05, 0x89, 0x95, 0x68, 0xbd, 0x84, 0xb6, 0x64, 0x0c, 0xe7,
0xa8, 0x1f, 0x9d, 0x66, 0x17, 0xc9, 0x72, 0x81, 0x96, 0x1a, 0xf0, 0x14, 0xa8, 0xcf, 0xe6, 0xc9,
0x4c, 0xe1, 0x3a, 0x39, 0x3a, 0xbe, 0x49, 0x49, 0xa9, 0x42, 0xa8, 0xee, 0x87, 0x10, 0x29, 0x1d,
0xd3, 0x99, 0x12, 0x85, 0x3b, 0x10, 0x59, 0xa5, 0x5b, 0x01, 0x6d, 0x20, 0xe1, 0x02, 0x6c, 0x03,
0xd7, 0x51, 0x2f, 0x04, 0x93, 0x25, 0x96, 0xce, 0x32, 0x4a, 0x1a, 0xbb, 0x22, 0x81, 0x43, 0x65,
0x77, 0x55, 0x26, 0x63, 0x3a, 0xc7, 0xe6, 0x08, 0x39, 0x00, 0xcb, 0x0b, 0x05, 0xe6, 0xb1, 0x6d,
0x93, 0x47, 0x3d, 0x28, 0x00, 0xca, 0x56, 0x08, 0x6b, 0x72, 0x29, 0x95, 0x6d, 0x6a, 0xe0, 0x16,
0x76, 0x55, 0x12, 0x83, 0xa6, 0x0b, 0x48, 0xe7, 0x39, 0x5c, 0x24, 0x40, 0xd9, 0x38, 0x3a, 0x80,
0x04, 0x46, 0xd1, 0x8b, 0xe3, 0xe8, 0x02, 0xc7, 0xe8, 0x25, 0x24, 0xbf, 0x9d, 0x89, 0x24, 0x76,
0x92, 0xe4, 0x63, 0x59, 0x46, 0x8e, 0x05, 0xf9, 0xc3, 0x5b, 0xad, 0xf6, 0x09, 0x5d, 0x61, 0xcb,
0x64, 0xa1, 0x40, 0x0e, 0xc0, 0x6a, 0x11, 0x39, 0xf1, 0x2e, 0x20, 0xd5, 0xa3, 0xcc, 0x1e, 0x75,
0x0e, 0x20, 0x55, 0x7a, 0x40, 0x57, 0x71, 0xa0, 0xae, 0xd2, 0x70, 0x44, 0xf4, 0x22, 0x76, 0xd8,
0x49, 0xfb, 0x76, 0x30, 0x96, 0x97, 0x5e, 0x62, 0x8c, 0xcc, 0x06, 0x41, 0x08, 0xef, 0x66, 0x60,
0x6c, 0xc8, 0x23, 0xa0, 0xbf, 0xd5, 0x37, 0xde, 0x22, 0xc4, 0xe5, 0xe2, 0xee, 0x03, 0x63, 0x64,
0x6e, 0x6c, 0x1d, 0x2a, 0x09, 0x74, 0x82, 0x35, 0xc8, 0xf4, 0x6d, 0x29, 0x8c, 0xc9, 0x20, 0xa6,
0x15, 0xd4, 0xad, 0x25, 0x8f, 0xb5, 0xea, 0xe2, 0xca, 0xd1, 0x2a, 0x7a, 0x77, 0x85, 0x14, 0xa6,
0xe7, 0x6e, 0x0c, 0x21, 0x53, 0x85, 0x80, 0xb5, 0x8d, 0x0e, 0x69, 0xb4, 0xa1, 0x8b, 0x97, 0x23,
0xaf, 0xbd, 0x44, 0x68, 0xd9, 0x1e, 0x57, 0x1f, 0xd1, 0xae, 0xe0, 0xe5, 0xdd, 0xd3, 0xea, 0xbe,
0x90, 0x5d, 0x5a, 0xc5, 0x62, 0x6d, 0xe0, 0x89, 0x2b, 0x3c, 0x43, 0xea, 0xbb, 0x49, 0xe6, 0xba,
0xd4, 0x5c, 0x4f, 0x34, 0x30, 0x6c, 0x72, 0xe3, 0xbd, 0x69, 0xb7, 0xd2, 0x6e, 0x33, 0x67, 0x89,
0x7f, 0x5b, 0xc6, 0xd0, 0x11, 0x12, 0x62, 0x3a, 0xe1, 0xd4, 0x77, 0x53, 0x2a, 0xc9, 0x10, 0xe3,
0x21, 0x03, 0xad, 0xfa, 0x25, 0x0c, 0x50, 0xc2, 0x7d, 0x6e, 0x4a, 0x50, 0x07, 0x47, 0x1a, 0x80,
0x89, 0xb4, 0x38, 0x2d, 0xa7, 0x77, 0x51, 0xda, 0x76, 0x4f, 0xdd, 0x1f, 0x63, 0x86, 0xf6, 0xb0,
0xd3, 0x1e, 0xd8, 0xf6, 0xc0, 0x58, 0x48, 0x9b, 0x4a, 0x76, 0x44, 0xd7, 0x50, 0x81, 0x9d, 0x6e,
0x29, 0x1e, 0x97, 0xd2, 0xdf, 0xc1, 0xa1, 0x86, 0x90, 0x00, 0x37, 0xe5, 0xaa, 0xf7, 0xd8, 0x12,
0x99, 0xcf, 0xa9, 0x1e, 0x73, 0x6d, 0x85, 0x03, 0xbf, 0xab, 0xb8, 0x89, 0x69, 0xd5, 0x1f, 0x63,
0xdf, 0xe3, 0xfa, 0x36, 0xf6, 0xb9, 0x19, 0x43, 0x3f, 0x54, 0xd8, 0x0a, 0x59, 0x18, 0x52, 0x1d,
0xe3, 0x3f, 0x56, 0xd8, 0x22, 0x99, 0x43, 0xaa, 0x23, 0xcc, 0xd0, 0x9f, 0x1c, 0x88, 0xa4, 0x4a,
0xe0, 0xcf, 0xae, 0x42, 0xc1, 0xaa, 0x84, 0xff, 0xe2, 0x9a, 0x61, 0x85, 0x62, 0x70, 0x86, 0x3e,
0xac, 0x20, 0xd3, 0x61, 0xb3, 0x02, 0xa6, 0x8f, 0x5c, 0x20, 0x56, 0x1d, 0x05, 0x3e, 0x76, 0x81,
0x45, 0xcd, 0x11, 0xfa, 0xc4, 0xa1, 0xfb, 0x5c, 0xc6, 0xaa, 0xd3, 0x19, 0xa1, 0x4f, 0x2b, 0x6c,
0x95, 0x2c, 0x62, 0xfa, 0x36, 0x4f, 0xb8, 0x8c, 0xc6, 0xf1, 0xcf, 0x2a, 0x8c, 0x92, 0x99, 0x5c,
0x18, 0x77, 0x31, 0xe9, 0x87, 0x55, 0x27, 0x4a, 0x41, 0x20, 0xc7, 0x3e, 0xaa, 0xb2, 0x39, 0xe2,
0xa3, 0x50, 0xb9, 0xfd, 0x71, 0x95, 0xcd, 0x90, 0xa9, 0x96, 0x34, 0xa0, 0x2d, 0x7d, 0x1f, 0x2f,
0xcf, 0x54, 0xbe, 0x7e, 0xf4, 0x03, 0xbc, 0xa2, 0x93, 0xee, 0xf2, 0xd0, 0x07, 0xce, 0x91, 0x3f,
0x14, 0xf4, 0x77, 0xcf, 0x1d, 0xb5, 0xfc, 0x6a, 0xfc, 0xe1, 0x61, 0xa7, 0x3d, 0xb0, 0xe3, 0x8d,
0xa0, 0x7f, 0x7a, 0xec, 0x12, 0x59, 0x1e, 0x62, 0x6e, 0x87, 0x47, 0xbb, 0xf0, 0x97, 0xc7, 0xd6,
0xc8, 0x85, 0x3d, 0xb0, 0xe3, 0xb9, 0x62, 0x92, 0x30, 0x56, 0x44, 0x86, 0xfe, 0xed, 0xb1, 0xff,
0x91, 0x95, 0x3d, 0xb0, 0x23, 0x7d, 0x4b, 0xce, 0x7f, 0x3c, 0x36, 0x4b, 0xa6, 0x43, 0x5c, 0x72,
0x38, 0x03, 0xfa, 0xd0, 0xc3, 0x21, 0x0d, 0xcd, 0x82, 0xce, 0x23, 0x0f, 0xa5, 0x7b, 0x93, 0xdb,
0xa8, 0x17, 0xa4, 0xcd, 0x1e, 0x97, 0x12, 0x12, 0x43, 0x1f, 0x7b, 0x6c, 0x99, 0xd0, 0x10, 0x52,
0x75, 0x06, 0x25, 0xf8, 0x09, 0x3e, 0xde, 0xcc, 0x05, 0xbf, 0x91, 0x81, 0x1e, 0x8c, 0x1c, 0x4f,
0x3d, 0x94, 0x3a, 0x8f, 0x7f, 0xde, 0xf3, 0xcc, 0x43, 0xa9, 0x0b, 0xe5, 0x5b, 0xb2, 0xa3, 0xe8,
0xaf, 0x35, 0x64, 0x75, 0x22, 0x52, 0x38, 0x11, 0xd1, 0x3d, 0xfa, 0x89, 0x8f, 0xac, 0x5c, 0xd2,
0xa1, 0x8a, 0x01, 0xe9, 0x1b, 0xfa, 0xa9, 0x8f, 0xd2, 0xe3, 0xe8, 0x72, 0xe9, 0x3f, 0x73, 0x76,
0xf1, 0xc6, 0xb4, 0x02, 0xfa, 0x39, 0x3e, 0xe8, 0xa4, 0xb0, 0x4f, 0xda, 0x47, 0xf4, 0x0b, 0x1f,
0x8f, 0x71, 0x23, 0x49, 0x54, 0xc4, 0xed, 0xe8, 0x02, 0x7d, 0xe9, 0xe3, 0x0d, 0x2c, 0x3d, 0x0f,
0x85, 0x30, 0x5f, 0xf9, 0x78, 0xbc, 0x02, 0x77, 0x63, 0x0b, 0xf0, 0xd9, 0xf8, 0xda, 0x55, 0x0d,
0xb8, 0xe5, 0xc8, 0xe4, 0xc4, 0xd2, 0x6f, 0xfc, 0x8d, 0x75, 0x52, 0x0f, 0x4c, 0xe2, 0x5e, 0x81,
0x3a, 0xf1, 0x02, 0x93, 0xd0, 0x09, 0x7c, 0xac, 0xb6, 0x95, 0x4a, 0x76, 0xce, 0xfb, 0xfa, 0xce,
0xcb, 0xb4, 0xb2, 0xfd, 0xea, 0xdb, 0xd7, 0xba, 0xc2, 0xf6, 0xb2, 0x53, 0xfc, 0x91, 0x6e, 0xe5,
0x7f, 0xd6, 0xab, 0x42, 0x15, 0x5f, 0x5b, 0x42, 0x5a, 0xd0, 0x92, 0x27, 0x5b, 0xee, 0x67, 0xbb,
0x95, 0xff, 0x6c, 0xfb, 0xa7, 0xa7, 0x53, 0xce, 0xbe, 0xf6, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff,
0xe0, 0x24, 0x61, 0xe5, 0x46, 0x09, 0x00, 0x00,
// 1310 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x55, 0xdb, 0x6e, 0x1b, 0xb7,
0x16, 0xf5, 0x68, 0x64, 0xcb, 0xa2, 0x65, 0x9b, 0xa6, 0x2f, 0x71, 0x72, 0x8c, 0x83, 0xc0, 0x4f,
0x81, 0x81, 0xd8, 0xe7, 0x9c, 0xe0, 0xb4, 0x4f, 0x79, 0xb0, 0x35, 0xbe, 0x08, 0x89, 0x2f, 0x1d,
0x39, 0x69, 0xd1, 0x97, 0x80, 0x9e, 0xd9, 0x92, 0xd8, 0xcc, 0x90, 0x2a, 0xc9, 0x71, 0xac, 0xbf,
0x68, 0xf3, 0x1d, 0x6d, 0xd1, 0x4b, 0x7a, 0x41, 0xbf, 0xa0, 0xf7, 0xe7, 0x7e, 0x42, 0x3f, 0xa0,
0xd7, 0x5c, 0x8b, 0xcd, 0x19, 0x49, 0x13, 0x20, 0x7d, 0x9b, 0xbd, 0xb8, 0xb9, 0xb8, 0xf6, 0xda,
0x9b, 0x1c, 0xd2, 0x88, 0x54, 0x9a, 0x2a, 0xb9, 0xd9, 0xd7, 0xca, 0x2a, 0xb6, 0x98, 0x8a, 0xe4,
0x3c, 0x33, 0x79, 0xb4, 0x99, 0x2f, 0xad, 0xdf, 0x23, 0x53, 0x6d, 0xcb, 0x6d, 0x66, 0xd8, 0x4d,
0x42, 0x40, 0x6b, 0xa5, 0xef, 0x45, 0x2a, 0x86, 0x55, 0xef, 0xaa, 0x77, 0x6d, 0xee, 0x7f, 0xff,
0xde, 0x7c, 0xc5, 0x9e, 0xcd, 0x5d, 0x4c, 0x6b, 0xaa, 0x18, 0xc2, 0x3a, 0x0c, 0x3f, 0xd9, 0x0a,
0x99, 0xd2, 0xc0, 0x8d, 0x92, 0xab, 0x95, 0xab, 0xde, 0xb5, 0x7a, 0x58, 0x44, 0xeb, 0xaf, 0x91,
0xc6, 0x2d, 0x18, 0xdc, 0xe5, 0x49, 0x06, 0x27, 0x5c, 0x68, 0x46, 0x89, 0x7f, 0x1f, 0x06, 0x8e,
0xbf, 0x1e, 0xe2, 0x27, 0x5b, 0x22, 0x93, 0xe7, 0xb8, 0x5c, 0x6c, 0xcc, 0x83, 0xf5, 0x35, 0x52,
0xdd, 0x49, 0xd4, 0xd9, 0x78, 0x15, 0x77, 0x34, 0x86, 0xab, 0xd7, 0x49, 0x6d, 0x3b, 0x8e, 0x35,
0x18, 0xc3, 0xe6, 0x48, 0x45, 0xf4, 0x0b, 0xbe, 0x8a, 0xe8, 0x33, 0x46, 0xaa, 0x7d, 0xa5, 0xad,
0x63, 0xf3, 0x43, 0xf7, 0xbd, 0xfe, 0xd0, 0x23, 0xb5, 0x43, 0xd3, 0xdd, 0xe1, 0x06, 0xd8, 0xeb,
0x64, 0x3a, 0x35, 0xdd, 0x7b, 0x76, 0xd0, 0x1f, 0x56, 0xb9, 0xf6, 0xca, 0x2a, 0x0f, 0x4d, 0xf7,
0x74, 0xd0, 0x87, 0xb0, 0x96, 0xe6, 0x1f, 0xa8, 0x24, 0x35, 0xdd, 0x56, 0x50, 0x30, 0xe7, 0x01,
0x5b, 0x23, 0x75, 0x2b, 0x52, 0x30, 0x96, 0xa7, 0xfd, 0x55, 0xff, 0xaa, 0x77, 0xad, 0x1a, 0x8e,
0x01, 0x76, 0x85, 0x4c, 0x1b, 0x95, 0xe9, 0x08, 0x5a, 0xc1, 0x6a, 0xd5, 0x6d, 0x1b, 0xc5, 0xeb,
0x37, 0x49, 0xfd, 0xd0, 0x74, 0x0f, 0x80, 0xc7, 0xa0, 0xd9, 0x7f, 0x48, 0xf5, 0x8c, 0x9b, 0x5c,
0xd1, 0xcc, 0x3f, 0x2b, 0xc2, 0x0a, 0x42, 0x97, 0xb9, 0xf1, 0x75, 0x95, 0xd4, 0x47, 0x9d, 0x60,
0x33, 0xa4, 0xd6, 0xce, 0xa2, 0x08, 0x8c, 0xa1, 0x13, 0x6c, 0x91, 0xcc, 0xdf, 0x91, 0x70, 0xd1,
0x87, 0xc8, 0x42, 0xec, 0x72, 0xa8, 0xc7, 0x16, 0xc8, 0x6c, 0x53, 0x49, 0x09, 0x91, 0xdd, 0xe3,
0x22, 0x81, 0x98, 0x56, 0xd8, 0x12, 0xa1, 0x27, 0xa0, 0x53, 0x61, 0x8c, 0x50, 0x32, 0x00, 0x29,
0x20, 0xa6, 0x3e, 0xbb, 0x44, 0x16, 0x9b, 0x2a, 0x49, 0x20, 0xb2, 0x42, 0xc9, 0x23, 0x65, 0x77,
0x2f, 0x84, 0xb1, 0x86, 0x56, 0x91, 0xb6, 0x95, 0x24, 0xd0, 0xe5, 0xc9, 0xb6, 0xee, 0x66, 0x29,
0x48, 0x4b, 0x27, 0x91, 0xa3, 0x00, 0x03, 0x91, 0x82, 0x44, 0x26, 0x5a, 0x2b, 0xa1, 0x2d, 0x19,
0xc3, 0x05, 0xfa, 0x47, 0xa7, 0xd9, 0x65, 0xb2, 0x5c, 0xa0, 0xa5, 0x03, 0x78, 0x0a, 0xb4, 0xce,
0xe6, 0xc9, 0x4c, 0xb1, 0x74, 0x7a, 0x7c, 0x72, 0x8b, 0x92, 0x12, 0x43, 0xa8, 0x1e, 0x84, 0x10,
0x29, 0x1d, 0xd3, 0x99, 0x92, 0x84, 0xbb, 0x10, 0x59, 0xa5, 0x5b, 0x01, 0x6d, 0xa0, 0xe0, 0x02,
0x6c, 0x03, 0xd7, 0x51, 0x2f, 0x04, 0x93, 0x25, 0x96, 0xce, 0x32, 0x4a, 0x1a, 0x7b, 0x22, 0x81,
0x23, 0x65, 0xf7, 0x54, 0x26, 0x63, 0x3a, 0xc7, 0xe6, 0x08, 0x39, 0x04, 0xcb, 0x0b, 0x07, 0xe6,
0xf1, 0xd8, 0x26, 0x8f, 0x7a, 0x50, 0x00, 0x94, 0xad, 0x10, 0xd6, 0xe4, 0x52, 0x2a, 0xdb, 0xd4,
0xc0, 0x2d, 0xec, 0xa9, 0x24, 0x06, 0x4d, 0x17, 0x50, 0xce, 0x4b, 0xb8, 0x48, 0x80, 0xb2, 0x71,
0x76, 0x00, 0x09, 0x8c, 0xb2, 0x17, 0xc7, 0xd9, 0x05, 0x8e, 0xd9, 0x4b, 0x28, 0x7e, 0x27, 0x13,
0x49, 0xec, 0x2c, 0xc9, 0xdb, 0xb2, 0x8c, 0x1a, 0x0b, 0xf1, 0x47, 0xb7, 0x5b, 0xed, 0x53, 0xba,
0xc2, 0x96, 0xc9, 0x42, 0x81, 0x1c, 0x82, 0xd5, 0x22, 0x72, 0xe6, 0x5d, 0x42, 0xa9, 0xc7, 0x99,
0x3d, 0xee, 0x1c, 0x42, 0xaa, 0xf4, 0x80, 0xae, 0x62, 0x43, 0x1d, 0xd3, 0xb0, 0x45, 0xf4, 0x32,
0x9e, 0xb0, 0x9b, 0xf6, 0xed, 0x60, 0x6c, 0x2f, 0xbd, 0xc2, 0x18, 0x99, 0x0d, 0x82, 0x10, 0xde,
0xcd, 0xc0, 0xd8, 0x90, 0x47, 0x40, 0x7f, 0xa9, 0x6d, 0xbc, 0x45, 0x88, 0xdb, 0x8b, 0x77, 0x1f,
0x18, 0x23, 0x73, 0xe3, 0xe8, 0x48, 0x49, 0xa0, 0x13, 0xac, 0x41, 0xa6, 0xef, 0x48, 0x61, 0x4c,
0x06, 0x31, 0xf5, 0xd0, 0xb7, 0x96, 0x3c, 0xd1, 0xaa, 0x8b, 0x57, 0x8e, 0x56, 0x70, 0x75, 0x4f,
0x48, 0x61, 0x7a, 0x6e, 0x62, 0x08, 0x99, 0x2a, 0x0c, 0xac, 0x6e, 0x74, 0x48, 0xa3, 0x0d, 0x5d,
0x1c, 0x8e, 0x9c, 0x7b, 0x89, 0xd0, 0x72, 0x3c, 0x66, 0x1f, 0xc9, 0xf6, 0x70, 0x78, 0xf7, 0xb5,
0x7a, 0x20, 0x64, 0x97, 0x56, 0x90, 0xac, 0x0d, 0x3c, 0x71, 0xc4, 0x33, 0xa4, 0xb6, 0x97, 0x64,
0xee, 0x94, 0xaa, 0x3b, 0x13, 0x03, 0x4c, 0x9b, 0xdc, 0x78, 0x34, 0xed, 0xae, 0xb4, 0xbb, 0x99,
0xb3, 0xa4, 0x7e, 0x47, 0xc6, 0xd0, 0x11, 0x12, 0x62, 0x3a, 0xe1, 0xdc, 0x77, 0x5d, 0x2a, 0xd9,
0x10, 0x63, 0x91, 0x81, 0x56, 0xfd, 0x12, 0x06, 0x68, 0xe1, 0x01, 0x37, 0x25, 0xa8, 0x83, 0x2d,
0x0d, 0xc0, 0x44, 0x5a, 0x9c, 0x95, 0xb7, 0x77, 0xd1, 0xda, 0x76, 0x4f, 0x3d, 0x18, 0x63, 0x86,
0xf6, 0xf0, 0xa4, 0x7d, 0xb0, 0xed, 0x81, 0xb1, 0x90, 0x36, 0x95, 0xec, 0x88, 0xae, 0xa1, 0x02,
0x4f, 0xba, 0xad, 0x78, 0x5c, 0xda, 0xfe, 0x0e, 0x36, 0x35, 0x84, 0x04, 0xb8, 0x29, 0xb3, 0xde,
0x77, 0xf3, 0xe7, 0xa4, 0x6e, 0x27, 0x82, 0x1b, 0x9a, 0x60, 0x29, 0xa8, 0x32, 0x0f, 0x53, 0xf4,
0x7d, 0x3b, 0xb1, 0xa0, 0xf3, 0x58, 0xb2, 0x25, 0x32, 0x9f, 0xe7, 0x9f, 0x70, 0x6d, 0x85, 0x23,
0xf9, 0xc6, 0x73, 0x1d, 0xd6, 0xaa, 0x3f, 0xc6, 0xbe, 0xc5, 0xeb, 0xde, 0x38, 0xe0, 0x66, 0x0c,
0x7d, 0xe7, 0xb1, 0x15, 0xb2, 0x30, 0x2c, 0x6d, 0x8c, 0x7f, 0xef, 0xb1, 0x45, 0x32, 0x87, 0xa5,
0x8d, 0x30, 0x43, 0x7f, 0x70, 0x20, 0x16, 0x51, 0x02, 0x7f, 0x74, 0x0c, 0x45, 0x15, 0x25, 0xfc,
0x27, 0x77, 0x18, 0x32, 0x14, 0x8d, 0x36, 0xf4, 0xb1, 0x87, 0x4a, 0x87, 0x87, 0x15, 0x30, 0x7d,
0xe2, 0x12, 0x91, 0x75, 0x94, 0xf8, 0xd4, 0x25, 0x16, 0x9c, 0x23, 0xf4, 0x99, 0x43, 0x0f, 0xb8,
0x8c, 0x55, 0xa7, 0x33, 0x42, 0x9f, 0x7b, 0x6c, 0x95, 0x2c, 0xe2, 0xf6, 0x1d, 0x9e, 0x70, 0x19,
0x8d, 0xf3, 0x5f, 0x78, 0x8c, 0x0e, 0x8d, 0x74, 0x83, 0x4c, 0x3f, 0xa8, 0x38, 0x53, 0x0a, 0x01,
0x39, 0xf6, 0x61, 0x85, 0xcd, 0xe5, 0xee, 0xe6, 0xf1, 0x47, 0x15, 0x36, 0x43, 0xa6, 0x5a, 0xd2,
0x80, 0xb6, 0xf4, 0x3d, 0x1c, 0xb6, 0xa9, 0xfc, 0xba, 0xd2, 0xf7, 0x71, 0xa4, 0x27, 0xdd, 0xb0,
0xd1, 0x87, 0x6e, 0x21, 0x7f, 0x58, 0xe8, 0xaf, 0xbe, 0x2b, 0xb5, 0xfc, 0xca, 0xfc, 0xe6, 0xe3,
0x49, 0xfb, 0x60, 0xc7, 0x37, 0x88, 0xfe, 0xee, 0xb3, 0x2b, 0x64, 0x79, 0x88, 0xb9, 0x3b, 0x3f,
0xba, 0x3b, 0x7f, 0xf8, 0x6c, 0x8d, 0x5c, 0xda, 0x07, 0x3b, 0x9e, 0x03, 0xdc, 0x24, 0x8c, 0x15,
0x91, 0xa1, 0x7f, 0xfa, 0xec, 0x5f, 0x64, 0x65, 0x1f, 0xec, 0xc8, 0xdf, 0xd2, 0xe2, 0x5f, 0x3e,
0x9b, 0x25, 0xd3, 0x21, 0x3e, 0x0a, 0x70, 0x0e, 0xf4, 0xb1, 0x8f, 0x4d, 0x1a, 0x86, 0x85, 0x9c,
0x27, 0x3e, 0x5a, 0xf7, 0x26, 0xb7, 0x51, 0x2f, 0x48, 0x9b, 0x3d, 0x2e, 0x25, 0x24, 0x86, 0x3e,
0xf5, 0xd9, 0x32, 0xa1, 0x21, 0xa4, 0xea, 0x1c, 0x4a, 0xf0, 0x33, 0x7c, 0xec, 0x99, 0x4b, 0x7e,
0x23, 0x03, 0x3d, 0x18, 0x2d, 0x3c, 0xf7, 0xd1, 0xea, 0x3c, 0xff, 0xe5, 0x95, 0x17, 0x3e, 0x5a,
0x5d, 0x38, 0xdf, 0x92, 0x1d, 0x45, 0x7f, 0xae, 0xa2, 0xaa, 0x53, 0x91, 0xc2, 0xa9, 0x88, 0xee,
0xd3, 0x8f, 0xeb, 0xa8, 0xca, 0x6d, 0x3a, 0x52, 0x31, 0xa0, 0x7c, 0x43, 0x3f, 0xa9, 0xa3, 0xf5,
0xd8, 0xba, 0xdc, 0xfa, 0x4f, 0x5d, 0x5c, 0xbc, 0x49, 0xad, 0x80, 0x7e, 0x86, 0x3f, 0x00, 0x52,
0xc4, 0xa7, 0xed, 0x63, 0xfa, 0xa8, 0x8e, 0x65, 0x6c, 0x27, 0x89, 0x8a, 0xb8, 0x1d, 0x0d, 0xd0,
0xe7, 0x75, 0x9c, 0xc0, 0xd2, 0x73, 0x52, 0x18, 0xf3, 0x45, 0x1d, 0xcb, 0x2b, 0x70, 0xd7, 0xb6,
0x00, 0x9f, 0x99, 0x2f, 0x1d, 0x6b, 0xc0, 0x2d, 0x47, 0x25, 0xa7, 0x96, 0x7e, 0x55, 0xdf, 0x58,
0x27, 0xb5, 0xc0, 0x24, 0xee, 0xd5, 0xa8, 0x11, 0x3f, 0x30, 0x09, 0x9d, 0xc0, 0x4b, 0xb6, 0xa3,
0x54, 0xb2, 0x7b, 0xd1, 0xd7, 0x77, 0xff, 0x4b, 0xbd, 0x9d, 0xff, 0xbf, 0x7d, 0xa3, 0x2b, 0x6c,
0x2f, 0x3b, 0xc3, 0x1f, 0xef, 0x56, 0xfe, 0x27, 0xbe, 0x2e, 0x54, 0xf1, 0xb5, 0x25, 0xa4, 0x05,
0x2d, 0x79, 0xb2, 0xe5, 0x7e, 0xce, 0x5b, 0xf9, 0xcf, 0xb9, 0x7f, 0x76, 0x36, 0xe5, 0xe2, 0x1b,
0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x10, 0x52, 0xd9, 0x76, 0x09, 0x00, 0x00,
}

17
internal/proto/internal.proto
View File

@ -97,6 +97,23 @@ message DropPartitionRequest {
int64 partitionID = 7;
}
message CreateAliasRequest {
common.MsgBase base = 1;
string collection_name = 2;
string alias = 3;
}
message DropAliasRequest {
common.MsgBase base = 1;
string alias = 2;
}
message AlterAliasRequest{
common.MsgBase base = 1;
string collection_name = 2;
string alias = 3;
}
message CreateIndexRequest {
common.MsgBase base = 1;
string db_name = 2;

445
internal/proto/internalpb/internal.pb.go
View File

@ -829,6 +829,163 @@ func (m *DropPartitionRequest) GetPartitionID() int64 {
return 0
}
type CreateAliasRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionName string `protobuf:"bytes,2,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
Alias string `protobuf:"bytes,3,opt,name=alias,proto3" json:"alias,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateAliasRequest) Reset() { *m = CreateAliasRequest{} }
func (m *CreateAliasRequest) String() string { return proto.CompactTextString(m) }
func (*CreateAliasRequest) ProtoMessage() {}
func (*CreateAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{14}
}
func (m *CreateAliasRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateAliasRequest.Unmarshal(m, b)
}
func (m *CreateAliasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateAliasRequest.Marshal(b, m, deterministic)
}
func (m *CreateAliasRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateAliasRequest.Merge(m, src)
}
func (m *CreateAliasRequest) XXX_Size() int {
return xxx_messageInfo_CreateAliasRequest.Size(m)
}
func (m *CreateAliasRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateAliasRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateAliasRequest proto.InternalMessageInfo
func (m *CreateAliasRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *CreateAliasRequest) GetCollectionName() string {
if m != nil {
return m.CollectionName
}
return ""
}
func (m *CreateAliasRequest) GetAlias() string {
if m != nil {
return m.Alias
}
return ""
}
type DropAliasRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
Alias string `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DropAliasRequest) Reset() { *m = DropAliasRequest{} }
func (m *DropAliasRequest) String() string { return proto.CompactTextString(m) }
func (*DropAliasRequest) ProtoMessage() {}
func (*DropAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{15}
}
func (m *DropAliasRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DropAliasRequest.Unmarshal(m, b)
}
func (m *DropAliasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropAliasRequest.Marshal(b, m, deterministic)
}
func (m *DropAliasRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DropAliasRequest.Merge(m, src)
}
func (m *DropAliasRequest) XXX_Size() int {
return xxx_messageInfo_DropAliasRequest.Size(m)
}
func (m *DropAliasRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DropAliasRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DropAliasRequest proto.InternalMessageInfo
func (m *DropAliasRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *DropAliasRequest) GetAlias() string {
if m != nil {
return m.Alias
}
return ""
}
type AlterAliasRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionName string `protobuf:"bytes,2,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
Alias string `protobuf:"bytes,3,opt,name=alias,proto3" json:"alias,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AlterAliasRequest) Reset() { *m = AlterAliasRequest{} }
func (m *AlterAliasRequest) String() string { return proto.CompactTextString(m) }
func (*AlterAliasRequest) ProtoMessage() {}
func (*AlterAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{16}
}
func (m *AlterAliasRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AlterAliasRequest.Unmarshal(m, b)
}
func (m *AlterAliasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AlterAliasRequest.Marshal(b, m, deterministic)
}
func (m *AlterAliasRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_AlterAliasRequest.Merge(m, src)
}
func (m *AlterAliasRequest) XXX_Size() int {
return xxx_messageInfo_AlterAliasRequest.Size(m)
}
func (m *AlterAliasRequest) XXX_DiscardUnknown() {
xxx_messageInfo_AlterAliasRequest.DiscardUnknown(m)
}
var xxx_messageInfo_AlterAliasRequest proto.InternalMessageInfo
func (m *AlterAliasRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *AlterAliasRequest) GetCollectionName() string {
if m != nil {
return m.CollectionName
}
return ""
}
func (m *AlterAliasRequest) GetAlias() string {
if m != nil {
return m.Alias
}
return ""
}
type CreateIndexRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
@ -847,7 +1004,7 @@ func (m *CreateIndexRequest) Reset() { *m = CreateIndexRequest{} }
func (m *CreateIndexRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIndexRequest) ProtoMessage() {}
func (*CreateIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{14}
return fileDescriptor_41f4a519b878ee3b, []int{17}
}
func (m *CreateIndexRequest) XXX_Unmarshal(b []byte) error {
@ -946,7 +1103,7 @@ func (m *InsertRequest) Reset() { *m = InsertRequest{} }
func (m *InsertRequest) String() string { return proto.CompactTextString(m) }
func (*InsertRequest) ProtoMessage() {}
func (*InsertRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{15}
return fileDescriptor_41f4a519b878ee3b, []int{18}
}
func (m *InsertRequest) XXX_Unmarshal(b []byte) error {
@ -1074,7 +1231,7 @@ func (m *SearchRequest) Reset() { *m = SearchRequest{} }
func (m *SearchRequest) String() string { return proto.CompactTextString(m) }
func (*SearchRequest) ProtoMessage() {}
func (*SearchRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{16}
return fileDescriptor_41f4a519b878ee3b, []int{19}
}
func (m *SearchRequest) XXX_Unmarshal(b []byte) error {
@ -1202,7 +1359,7 @@ func (m *SearchResults) Reset() { *m = SearchResults{} }
func (m *SearchResults) String() string { return proto.CompactTextString(m) }
func (*SearchResults) ProtoMessage() {}
func (*SearchResults) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{17}
return fileDescriptor_41f4a519b878ee3b, []int{20}
}
func (m *SearchResults) XXX_Unmarshal(b []byte) error {
@ -1326,7 +1483,7 @@ func (m *RetrieveRequest) Reset() { *m = RetrieveRequest{} }
func (m *RetrieveRequest) String() string { return proto.CompactTextString(m) }
func (*RetrieveRequest) ProtoMessage() {}
func (*RetrieveRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{18}
return fileDescriptor_41f4a519b878ee3b, []int{21}
}
func (m *RetrieveRequest) XXX_Unmarshal(b []byte) error {
@ -1428,7 +1585,7 @@ func (m *RetrieveResults) Reset() { *m = RetrieveResults{} }
func (m *RetrieveResults) String() string { return proto.CompactTextString(m) }
func (*RetrieveResults) ProtoMessage() {}
func (*RetrieveResults) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{19}
return fileDescriptor_41f4a519b878ee3b, []int{22}
}
func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
@ -1520,7 +1677,7 @@ func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteRequest) ProtoMessage() {}
func (*DeleteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{20}
return fileDescriptor_41f4a519b878ee3b, []int{23}
}
func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
@ -1588,7 +1745,7 @@ func (m *LoadBalanceSegmentsRequest) Reset() { *m = LoadBalanceSegmentsR
func (m *LoadBalanceSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*LoadBalanceSegmentsRequest) ProtoMessage() {}
func (*LoadBalanceSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{21}
return fileDescriptor_41f4a519b878ee3b, []int{24}
}
func (m *LoadBalanceSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1639,7 +1796,7 @@ func (m *LoadIndex) Reset() { *m = LoadIndex{} }
func (m *LoadIndex) String() string { return proto.CompactTextString(m) }
func (*LoadIndex) ProtoMessage() {}
func (*LoadIndex) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{22}
return fileDescriptor_41f4a519b878ee3b, []int{25}
}
func (m *LoadIndex) XXX_Unmarshal(b []byte) error {
@ -1719,7 +1876,7 @@ func (m *SegmentStatisticsUpdates) Reset() { *m = SegmentStatisticsUpdat
func (m *SegmentStatisticsUpdates) String() string { return proto.CompactTextString(m) }
func (*SegmentStatisticsUpdates) ProtoMessage() {}
func (*SegmentStatisticsUpdates) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{23}
return fileDescriptor_41f4a519b878ee3b, []int{26}
}
func (m *SegmentStatisticsUpdates) XXX_Unmarshal(b []byte) error {
@ -1801,7 +1958,7 @@ func (m *SegmentStatistics) Reset() { *m = SegmentStatistics{} }
func (m *SegmentStatistics) String() string { return proto.CompactTextString(m) }
func (*SegmentStatistics) ProtoMessage() {}
func (*SegmentStatistics) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{24}
return fileDescriptor_41f4a519b878ee3b, []int{27}
}
func (m *SegmentStatistics) XXX_Unmarshal(b []byte) error {
@ -1848,7 +2005,7 @@ func (m *IndexStats) Reset() { *m = IndexStats{} }
func (m *IndexStats) String() string { return proto.CompactTextString(m) }
func (*IndexStats) ProtoMessage() {}
func (*IndexStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{25}
return fileDescriptor_41f4a519b878ee3b, []int{28}
}
func (m *IndexStats) XXX_Unmarshal(b []byte) error {
@ -1896,7 +2053,7 @@ func (m *FieldStats) Reset() { *m = FieldStats{} }
func (m *FieldStats) String() string { return proto.CompactTextString(m) }
func (*FieldStats) ProtoMessage() {}
func (*FieldStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{26}
return fileDescriptor_41f4a519b878ee3b, []int{29}
}
func (m *FieldStats) XXX_Unmarshal(b []byte) error {
@ -1952,7 +2109,7 @@ func (m *SegmentStats) Reset() { *m = SegmentStats{} }
func (m *SegmentStats) String() string { return proto.CompactTextString(m) }
func (*SegmentStats) ProtoMessage() {}
func (*SegmentStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{27}
return fileDescriptor_41f4a519b878ee3b, []int{30}
}
func (m *SegmentStats) XXX_Unmarshal(b []byte) error {
@ -2014,7 +2171,7 @@ func (m *QueryNodeStats) Reset() { *m = QueryNodeStats{} }
func (m *QueryNodeStats) String() string { return proto.CompactTextString(m) }
func (*QueryNodeStats) ProtoMessage() {}
func (*QueryNodeStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{28}
return fileDescriptor_41f4a519b878ee3b, []int{31}
}
func (m *QueryNodeStats) XXX_Unmarshal(b []byte) error {
@ -2070,7 +2227,7 @@ func (m *MsgPosition) Reset() { *m = MsgPosition{} }
func (m *MsgPosition) String() string { return proto.CompactTextString(m) }
func (*MsgPosition) ProtoMessage() {}
func (*MsgPosition) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{29}
return fileDescriptor_41f4a519b878ee3b, []int{32}
}
func (m *MsgPosition) XXX_Unmarshal(b []byte) error {
@ -2133,7 +2290,7 @@ func (m *ChannelTimeTickMsg) Reset() { *m = ChannelTimeTickMsg{} }
func (m *ChannelTimeTickMsg) String() string { return proto.CompactTextString(m) }
func (*ChannelTimeTickMsg) ProtoMessage() {}
func (*ChannelTimeTickMsg) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{30}
return fileDescriptor_41f4a519b878ee3b, []int{33}
}
func (m *ChannelTimeTickMsg) XXX_Unmarshal(b []byte) error {
@ -2198,6 +2355,9 @@ func init() {
proto.RegisterType((*DropCollectionRequest)(nil), "milvus.proto.internal.DropCollectionRequest")
proto.RegisterType((*CreatePartitionRequest)(nil), "milvus.proto.internal.CreatePartitionRequest")
proto.RegisterType((*DropPartitionRequest)(nil), "milvus.proto.internal.DropPartitionRequest")
proto.RegisterType((*CreateAliasRequest)(nil), "milvus.proto.internal.CreateAliasRequest")
proto.RegisterType((*DropAliasRequest)(nil), "milvus.proto.internal.DropAliasRequest")
proto.RegisterType((*AlterAliasRequest)(nil), "milvus.proto.internal.AlterAliasRequest")
proto.RegisterType((*CreateIndexRequest)(nil), "milvus.proto.internal.CreateIndexRequest")
proto.RegisterType((*InsertRequest)(nil), "milvus.proto.internal.InsertRequest")
proto.RegisterType((*SearchRequest)(nil), "milvus.proto.internal.SearchRequest")
@ -2220,128 +2380,131 @@ func init() {
func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
var fileDescriptor_41f4a519b878ee3b = []byte{
// 1958 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x5b, 0x6f, 0x1c, 0x49,
0x15, 0xa6, 0xa7, 0xc7, 0x9e, 0x99, 0xd3, 0x63, 0x67, 0x52, 0xf1, 0x66, 0xdb, 0x4e, 0x36, 0xf1,
0xf6, 0x2e, 0x60, 0x36, 0x22, 0x0e, 0x5e, 0x60, 0x57, 0x08, 0x91, 0x5d, 0x7b, 0x96, 0x30, 0xca,
0xda, 0x98, 0x76, 0x76, 0x25, 0x78, 0x69, 0xd5, 0x74, 0x97, 0xc7, 0x4d, 0xfa, 0xb6, 0x5d, 0xd5,
0x4e, 0x66, 0x9f, 0x10, 0xe2, 0x09, 0x04, 0x12, 0x48, 0xfc, 0x0d, 0x5e, 0x79, 0xe2, 0x22, 0x9e,
0x90, 0xf8, 0x05, 0xfc, 0x13, 0xc4, 0x13, 0xaa, 0x53, 0xd5, 0x97, 0x19, 0x8f, 0x8d, 0xe3, 0x08,
0x58, 0x04, 0x6f, 0x5d, 0xdf, 0x39, 0x75, 0x39, 0xdf, 0xb9, 0xd4, 0x99, 0x1a, 0x58, 0x0d, 0x13,
0xc1, 0xf2, 0x84, 0x46, 0xf7, 0xb3, 0x3c, 0x15, 0x29, 0x79, 0x25, 0x0e, 0xa3, 0xd3, 0x82, 0xab,
0xd1, 0xfd, 0x52, 0xb8, 0xd1, 0xf7, 0xd3, 0x38, 0x4e, 0x13, 0x05, 0x6f, 0xf4, 0xb9, 0x7f, 0xc2,
0x62, 0xaa, 0x46, 0xce, 0xef, 0x0d, 0x58, 0xd9, 0x4b, 0xe3, 0x2c, 0x4d, 0x58, 0x22, 0x46, 0xc9,
0x71, 0x4a, 0x6e, 0xc2, 0x72, 0x92, 0x06, 0x6c, 0x34, 0xb4, 0x8d, 0x4d, 0x63, 0xcb, 0x74, 0xf5,
0x88, 0x10, 0x68, 0xe7, 0x69, 0xc4, 0xec, 0xd6, 0xa6, 0xb1, 0xd5, 0x73, 0xf1, 0x9b, 0x3c, 0x04,
0xe0, 0x82, 0x0a, 0xe6, 0xf9, 0x69, 0xc0, 0x6c, 0x73, 0xd3, 0xd8, 0x5a, 0xdd, 0xd9, 0xbc, 0xbf,
0xf0, 0x14, 0xf7, 0x8f, 0xa4, 0xe2, 0x5e, 0x1a, 0x30, 0xb7, 0xc7, 0xcb, 0x4f, 0xf2, 0x1e, 0x00,
0x7b, 0x2e, 0x72, 0xea, 0x85, 0xc9, 0x71, 0x6a, 0xb7, 0x37, 0xcd, 0x2d, 0x6b, 0xe7, 0xf5, 0xd9,
0x05, 0xf4, 0xe1, 0x1f, 0xb3, 0xe9, 0xc7, 0x34, 0x2a, 0xd8, 0x21, 0x0d, 0x73, 0xb7, 0x87, 0x93,
0xe4, 0x71, 0x9d, 0xbf, 0x1a, 0x70, 0xad, 0x32, 0x00, 0xf7, 0xe0, 0xe4, 0x1b, 0xb0, 0x84, 0x5b,
0xa0, 0x05, 0xd6, 0xce, 0x9b, 0xe7, 0x9c, 0x68, 0xc6, 0x6e, 0x57, 0x4d, 0x21, 0x1f, 0xc1, 0x0d,
0x5e, 0x8c, 0xfd, 0x52, 0xe4, 0x21, 0xca, 0xed, 0x16, 0x1e, 0xed, 0x72, 0x2b, 0x91, 0xe6, 0x02,
0xfa, 0x48, 0x6f, 0xc3, 0xb2, 0x5c, 0xa9, 0xe0, 0xc8, 0x92, 0xb5, 0x73, 0x6b, 0xa1, 0x91, 0x47,
0xa8, 0xe2, 0x6a, 0x55, 0xe7, 0x16, 0xac, 0x3f, 0x62, 0x62, 0xce, 0x3a, 0x97, 0x7d, 0x52, 0x30,
0x2e, 0xb4, 0xf0, 0x49, 0x18, 0xb3, 0x27, 0xa1, 0xff, 0x74, 0xef, 0x84, 0x26, 0x09, 0x8b, 0x4a,
0xe1, 0x6b, 0x70, 0xeb, 0x11, 0xc3, 0x09, 0x21, 0x17, 0xa1, 0xcf, 0xe7, 0xc4, 0xaf, 0xc0, 0x8d,
0x47, 0x4c, 0x0c, 0x83, 0x39, 0xf8, 0x63, 0xe8, 0x1e, 0x48, 0x67, 0xcb, 0x30, 0xf8, 0x3a, 0x74,
0x68, 0x10, 0xe4, 0x8c, 0x73, 0xcd, 0xe2, 0xed, 0x85, 0x27, 0x7e, 0x5f, 0xe9, 0xb8, 0xa5, 0xf2,
0xa2, 0x30, 0x71, 0x7e, 0x08, 0x30, 0x4a, 0x42, 0x71, 0x48, 0x73, 0x1a, 0xf3, 0x73, 0x03, 0x6c,
0x08, 0x7d, 0x2e, 0x68, 0x2e, 0xbc, 0x0c, 0xf5, 0x34, 0xe5, 0x97, 0x88, 0x06, 0x0b, 0xa7, 0xa9,
0xd5, 0x9d, 0xef, 0x03, 0x1c, 0x89, 0x3c, 0x4c, 0x26, 0x1f, 0x86, 0x5c, 0xc8, 0xbd, 0x4e, 0xa5,
0x9e, 0x34, 0xc2, 0xdc, 0xea, 0xb9, 0x7a, 0xd4, 0x70, 0x47, 0xeb, 0xf2, 0xee, 0x78, 0x08, 0x56,
0x49, 0xf7, 0x3e, 0x9f, 0x90, 0x07, 0xd0, 0x1e, 0x53, 0xce, 0x2e, 0xa4, 0x67, 0x9f, 0x4f, 0x76,
0x29, 0x67, 0x2e, 0x6a, 0x3a, 0x3f, 0x35, 0xe1, 0xd5, 0xbd, 0x9c, 0x61, 0xf0, 0x47, 0x11, 0xf3,
0x45, 0x98, 0x26, 0x9a, 0xfb, 0x17, 0x5f, 0x8d, 0xbc, 0x0a, 0x9d, 0x60, 0xec, 0x25, 0x34, 0x2e,
0xc9, 0x5e, 0x0e, 0xc6, 0x07, 0x34, 0x66, 0xe4, 0x0b, 0xb0, 0xea, 0x57, 0xeb, 0x4b, 0x04, 0x63,
0xae, 0xe7, 0xce, 0xa1, 0xe4, 0x4d, 0x58, 0xc9, 0x68, 0x2e, 0xc2, 0x4a, 0xad, 0x8d, 0x6a, 0xb3,
0xa0, 0x74, 0x68, 0x30, 0x1e, 0x0d, 0xed, 0x25, 0x74, 0x16, 0x7e, 0x13, 0x07, 0xfa, 0xf5, 0x5a,
0xa3, 0xa1, 0xbd, 0x8c, 0xb2, 0x19, 0x8c, 0x6c, 0x82, 0x55, 0x2d, 0x34, 0x1a, 0xda, 0x1d, 0x54,
0x69, 0x42, 0xd2, 0x39, 0xaa, 0x16, 0xd9, 0xdd, 0x4d, 0x63, 0xab, 0xef, 0xea, 0x11, 0x79, 0x00,
0x37, 0x4e, 0xc3, 0x5c, 0x14, 0x34, 0xd2, 0xf1, 0x29, 0xcf, 0xc1, 0xed, 0x1e, 0x7a, 0x70, 0x91,
0x88, 0xec, 0xc0, 0x5a, 0x76, 0x32, 0xe5, 0xa1, 0x3f, 0x37, 0x05, 0x70, 0xca, 0x42, 0x99, 0xf3,
0x27, 0x03, 0x5e, 0x19, 0xe6, 0x69, 0xf6, 0x99, 0x70, 0x45, 0x49, 0x72, 0xfb, 0x02, 0x92, 0x97,
0xce, 0x92, 0xec, 0xfc, 0xbc, 0x05, 0x37, 0x55, 0x44, 0x1d, 0x96, 0xc4, 0xfe, 0x0b, 0xac, 0xf8,
0x22, 0x5c, 0xab, 0x77, 0x55, 0x0a, 0x8b, 0xcd, 0xf8, 0x3c, 0xac, 0x56, 0x0e, 0x56, 0x7a, 0xff,
0xde, 0x90, 0x72, 0x7e, 0xd6, 0x82, 0x35, 0xe9, 0xd4, 0xff, 0xb3, 0x21, 0xd9, 0xf8, 0x43, 0x0b,
0x88, 0x8a, 0x8e, 0x51, 0x12, 0xb0, 0xe7, 0xff, 0x49, 0x2e, 0x5e, 0x03, 0x38, 0x0e, 0x59, 0x14,
0x34, 0x79, 0xe8, 0x21, 0xf2, 0x52, 0x1c, 0xd8, 0xd0, 0xc1, 0x45, 0x2a, 0xfb, 0xcb, 0xa1, 0xbc,
0x4d, 0x54, 0x67, 0xa1, 0x6f, 0x93, 0xee, 0xa5, 0x6f, 0x13, 0x9c, 0xa6, 0x6f, 0x93, 0xdf, 0x98,
0xb0, 0x32, 0x4a, 0x38, 0xcb, 0xc5, 0xff, 0x72, 0x20, 0x91, 0xdb, 0xd0, 0xe3, 0x6c, 0x12, 0xcb,
0x06, 0x67, 0x88, 0xc5, 0xda, 0x74, 0x6b, 0x40, 0x4a, 0x7d, 0x55, 0x59, 0x47, 0x43, 0xbb, 0xa7,
0x5c, 0x5b, 0x01, 0xe4, 0x0e, 0x80, 0x08, 0x63, 0xc6, 0x05, 0x8d, 0x33, 0x55, 0x91, 0xdb, 0x6e,
0x03, 0x91, 0xb7, 0x40, 0x9e, 0x3e, 0x1b, 0x0d, 0xb9, 0x6d, 0x6d, 0x9a, 0xb2, 0x1d, 0x50, 0x23,
0xf2, 0x55, 0xe8, 0xe6, 0xe9, 0x33, 0x2f, 0xa0, 0x82, 0xda, 0x7d, 0x74, 0xde, 0xfa, 0x42, 0xb2,
0x77, 0xa3, 0x74, 0xec, 0x76, 0xf2, 0xf4, 0xd9, 0x90, 0x0a, 0xea, 0xfc, 0xcd, 0x84, 0x95, 0x23,
0x46, 0x73, 0xff, 0xe4, 0xea, 0x0e, 0xfb, 0x12, 0x0c, 0x72, 0xc6, 0x8b, 0x48, 0x78, 0xb5, 0x59,
0xca, 0x73, 0xd7, 0x14, 0xbe, 0x57, 0x19, 0x57, 0x52, 0x6e, 0x5e, 0x40, 0x79, 0x7b, 0x01, 0xe5,
0x0e, 0xf4, 0x1b, 0xfc, 0x72, 0x7b, 0x09, 0x4d, 0x9f, 0xc1, 0xc8, 0x00, 0xcc, 0x80, 0x47, 0xe8,
0xb1, 0x9e, 0x2b, 0x3f, 0xc9, 0x3d, 0xb8, 0x9e, 0x45, 0xd4, 0x67, 0x27, 0x69, 0x14, 0xb0, 0xdc,
0x9b, 0xe4, 0x69, 0x91, 0xa1, 0xbb, 0xfa, 0xee, 0xa0, 0x21, 0x78, 0x24, 0x71, 0xf2, 0x0e, 0x74,
0x03, 0x1e, 0x79, 0x62, 0x9a, 0x31, 0x74, 0xd9, 0xea, 0x39, 0xb6, 0x0f, 0x79, 0xf4, 0x64, 0x9a,
0x31, 0xb7, 0x13, 0xa8, 0x0f, 0xf2, 0x00, 0xd6, 0x38, 0xcb, 0x43, 0x1a, 0x85, 0x9f, 0xb2, 0xc0,
0x63, 0xcf, 0xb3, 0xdc, 0xcb, 0x22, 0x9a, 0xa0, 0x67, 0xfb, 0x2e, 0xa9, 0x65, 0x1f, 0x3c, 0xcf,
0xf2, 0xc3, 0x88, 0x26, 0x64, 0x0b, 0x06, 0x69, 0x21, 0xb2, 0x42, 0x78, 0x98, 0x7d, 0xdc, 0x0b,
0x03, 0x74, 0xb4, 0xe9, 0xae, 0x2a, 0xfc, 0xdb, 0x08, 0x8f, 0x02, 0x49, 0xad, 0xc8, 0xe9, 0x29,
0x8b, 0xbc, 0x2a, 0x02, 0x6c, 0x6b, 0xd3, 0xd8, 0x6a, 0xbb, 0xd7, 0x14, 0xfe, 0xa4, 0x84, 0xc9,
0x36, 0xdc, 0x98, 0x14, 0x34, 0xa7, 0x89, 0x60, 0xac, 0xa1, 0xdd, 0x47, 0x6d, 0x52, 0x89, 0xaa,
0x09, 0xce, 0x2f, 0xdb, 0xb5, 0xeb, 0xa5, 0x97, 0xf8, 0x15, 0x5c, 0x7f, 0x95, 0xbe, 0x70, 0x61,
0xbc, 0x98, 0x8b, 0xe3, 0xe5, 0x2e, 0x58, 0x31, 0x13, 0x79, 0xe8, 0x2b, 0xbf, 0xa8, 0x34, 0x06,
0x05, 0x21, 0xf9, 0x77, 0xc1, 0x4a, 0x8a, 0xd8, 0xfb, 0xa4, 0x60, 0x79, 0xc8, 0xb8, 0x4e, 0x65,
0x48, 0x8a, 0xf8, 0x7b, 0x0a, 0x21, 0x37, 0x60, 0x49, 0xa4, 0x99, 0xf7, 0x54, 0x67, 0x72, 0x5b,
0xa4, 0xd9, 0x63, 0xf2, 0x4d, 0xd8, 0xe0, 0x8c, 0x46, 0x2c, 0xf0, 0xaa, 0xac, 0xe4, 0x1e, 0x47,
0x2e, 0x58, 0x60, 0x77, 0xd0, 0x15, 0xb6, 0xd2, 0x38, 0xaa, 0x14, 0x8e, 0xb4, 0x5c, 0x32, 0x5d,
0x1d, 0xbc, 0x31, 0xad, 0x8b, 0xcd, 0x13, 0xa9, 0x45, 0xd5, 0x84, 0x77, 0xc1, 0x9e, 0x44, 0xe9,
0x98, 0x46, 0xde, 0x99, 0x5d, 0xb1, 0x4b, 0x33, 0xdd, 0x9b, 0x4a, 0x7e, 0x34, 0xb7, 0xa5, 0x34,
0x8f, 0x47, 0xa1, 0xcf, 0x02, 0x6f, 0x1c, 0xa5, 0x63, 0x1b, 0x30, 0xa4, 0x40, 0x41, 0x32, 0x91,
0x65, 0x28, 0x69, 0x05, 0x49, 0x83, 0x9f, 0x16, 0x89, 0xc0, 0x00, 0x31, 0xdd, 0x55, 0x85, 0x1f,
0x14, 0xf1, 0x9e, 0x44, 0xc9, 0x1b, 0xb0, 0xa2, 0x35, 0xd3, 0xe3, 0x63, 0xce, 0x04, 0x46, 0x86,
0xe9, 0xf6, 0x15, 0xf8, 0x5d, 0xc4, 0x9c, 0x1f, 0x9b, 0x70, 0xcd, 0x95, 0xec, 0xb2, 0x53, 0xf6,
0x5f, 0x5f, 0x10, 0xce, 0x4b, 0xcc, 0xe5, 0x17, 0x4a, 0xcc, 0xce, 0xa5, 0x13, 0xb3, 0xfb, 0x42,
0x89, 0xd9, 0x3b, 0x37, 0x31, 0x7f, 0x37, 0xe3, 0x84, 0xcf, 0x6a, 0x6a, 0xbe, 0x05, 0x66, 0x18,
0x70, 0x74, 0x8e, 0xb5, 0x63, 0xcf, 0x2e, 0xae, 0x9f, 0x4c, 0x46, 0x43, 0xee, 0x4a, 0x25, 0xf2,
0x10, 0x2c, 0x4d, 0x28, 0x5e, 0x4f, 0x4b, 0x78, 0x3d, 0xdd, 0x59, 0x38, 0x07, 0x19, 0x96, 0x57,
0x93, 0xab, 0x1a, 0x20, 0x2e, 0xbf, 0xc9, 0xb7, 0xe0, 0xd6, 0xd9, 0x84, 0xcd, 0x35, 0x47, 0x81,
0xbd, 0x8c, 0x3e, 0x5a, 0x9f, 0xcf, 0xd8, 0x92, 0xc4, 0x80, 0x7c, 0x05, 0xd6, 0x1a, 0x29, 0x5b,
0x4f, 0xec, 0xa8, 0xdf, 0x48, 0xb5, 0xac, 0x9e, 0x72, 0x51, 0xd2, 0x76, 0x2f, 0x4a, 0x5a, 0xe7,
0x2f, 0x06, 0xac, 0x0c, 0x59, 0xc4, 0xc4, 0x4b, 0xa4, 0xd0, 0x82, 0x5e, 0xa7, 0xb5, 0xb0, 0xd7,
0x99, 0x69, 0x26, 0xcc, 0x8b, 0x9b, 0x89, 0xf6, 0x99, 0x66, 0xe2, 0x75, 0xe8, 0x67, 0x79, 0x18,
0xd3, 0x7c, 0xea, 0x3d, 0x65, 0xd3, 0x32, 0x8d, 0x2c, 0x8d, 0x3d, 0x66, 0x53, 0xee, 0x24, 0xb0,
0xf1, 0x61, 0x4a, 0x83, 0x5d, 0x1a, 0xd1, 0xc4, 0x67, 0xda, 0x4c, 0x7e, 0x75, 0xcb, 0xee, 0x00,
0x34, 0x98, 0x6c, 0xe1, 0x86, 0x0d, 0xc4, 0xf9, 0xbb, 0x01, 0x3d, 0xb9, 0x21, 0xb6, 0xe0, 0x57,
0x58, 0x7f, 0xa6, 0xf7, 0x6a, 0x2d, 0xe8, 0xbd, 0xaa, 0x2e, 0xba, 0xa4, 0xab, 0x6e, 0xab, 0x1b,
0xed, 0x71, 0x7b, 0xb6, 0x3d, 0xbe, 0x0b, 0x56, 0x28, 0x0f, 0xe4, 0x65, 0x54, 0x9c, 0x28, 0x9e,
0x7a, 0x2e, 0x20, 0x74, 0x28, 0x11, 0xd9, 0x3f, 0x97, 0x0a, 0xd8, 0x3f, 0x2f, 0x5f, 0xba, 0x7f,
0xd6, 0x8b, 0x60, 0xff, 0xfc, 0xc7, 0x16, 0xd8, 0x9a, 0xe2, 0xfa, 0x31, 0xea, 0xa3, 0x2c, 0xc0,
0x37, 0xb1, 0xdb, 0xd0, 0xab, 0xa2, 0x4c, 0xbf, 0x05, 0xd5, 0x80, 0xe4, 0x75, 0x9f, 0xc5, 0x69,
0x3e, 0x3d, 0x0a, 0x3f, 0x65, 0xda, 0xf0, 0x06, 0x22, 0x6d, 0x3b, 0x28, 0x62, 0x37, 0x7d, 0xc6,
0x75, 0xb1, 0x2d, 0x87, 0xd2, 0x36, 0x1f, 0x7f, 0xf5, 0x60, 0x75, 0x42, 0xcb, 0xdb, 0x2e, 0x28,
0x48, 0x56, 0x25, 0xb2, 0x0e, 0x5d, 0x96, 0x04, 0x4a, 0xba, 0x84, 0xd2, 0x0e, 0x4b, 0x02, 0x14,
0x8d, 0x60, 0x55, 0x3f, 0x42, 0xa5, 0x1c, 0x0b, 0x2f, 0x56, 0x57, 0x6b, 0xc7, 0x39, 0xe7, 0xe5,
0x6f, 0x9f, 0x4f, 0x0e, 0xb5, 0xa6, 0xbb, 0xa2, 0xde, 0xa1, 0xf4, 0x90, 0x7c, 0x00, 0x7d, 0xb9,
0x4b, 0xb5, 0x50, 0xe7, 0xd2, 0x0b, 0x59, 0x2c, 0x09, 0xca, 0x81, 0xf3, 0x2b, 0x03, 0xae, 0x9f,
0xa1, 0xf0, 0x0a, 0x71, 0xf4, 0x18, 0xba, 0x47, 0x6c, 0x22, 0x97, 0x28, 0x9f, 0xd6, 0xb6, 0xcf,
0x7b, 0xa9, 0x3d, 0xc7, 0x61, 0x6e, 0xb5, 0x80, 0xf3, 0x13, 0x03, 0x00, 0x03, 0x1a, 0x87, 0x67,
0x82, 0xc5, 0xb8, 0x4a, 0xb0, 0xc8, 0xfb, 0x4d, 0x5e, 0xfa, 0x39, 0x8b, 0xa8, 0xa8, 0xeb, 0x13,
0xd7, 0xbe, 0x27, 0x49, 0x11, 0xbb, 0x4a, 0x54, 0x26, 0xad, 0xf3, 0x0b, 0x03, 0x00, 0x0b, 0xac,
0x3a, 0xc6, 0xfc, 0x45, 0x6b, 0x5c, 0xfc, 0x8b, 0xb1, 0x35, 0x9b, 0x12, 0xbb, 0x65, 0x4a, 0x70,
0xe4, 0xc8, 0x5c, 0x64, 0x43, 0xc5, 0x51, 0x6d, 0xbc, 0xce, 0x1a, 0xc5, 0xcb, 0xaf, 0x0d, 0xe8,
0x37, 0xe8, 0xe3, 0xb3, 0xd9, 0x6b, 0xcc, 0x67, 0x2f, 0xb6, 0x83, 0x32, 0xa2, 0x3d, 0xde, 0x08,
0xf2, 0xb8, 0x0e, 0xf2, 0x75, 0xe8, 0x22, 0x25, 0x8d, 0x28, 0x4f, 0x74, 0x94, 0xdf, 0x83, 0xeb,
0x39, 0xf3, 0x59, 0x22, 0xa2, 0xa9, 0x17, 0xa7, 0x41, 0x78, 0x1c, 0xb2, 0x00, 0x63, 0xbd, 0xeb,
0x0e, 0x4a, 0xc1, 0xbe, 0xc6, 0x9d, 0x3f, 0x1b, 0xb0, 0x2a, 0x3b, 0xc8, 0xe9, 0x41, 0x1a, 0x30,
0x75, 0xb2, 0x17, 0x8f, 0xa0, 0xf7, 0xd0, 0x16, 0x4d, 0x8f, 0x0a, 0xa1, 0x37, 0xfe, 0x79, 0x08,
0x71, 0xb7, 0xcb, 0x75, 0xd8, 0x48, 0x8a, 0xd5, 0x2b, 0xc0, 0x65, 0x28, 0xae, 0x1d, 0xab, 0xaf,
0x4e, 0x45, 0xf1, 0x8f, 0x0c, 0xb0, 0x1a, 0xc9, 0x22, 0x4b, 0xbe, 0xbe, 0x1f, 0xd4, 0xb5, 0x62,
0x60, 0x11, 0xb4, 0xfc, 0xfa, 0xad, 0x8f, 0xac, 0xc1, 0x52, 0xcc, 0x27, 0xda, 0xe3, 0x7d, 0x57,
0x0d, 0xc8, 0x06, 0x74, 0x63, 0x3e, 0xc1, 0x1f, 0x4b, 0xba, 0x72, 0x56, 0x63, 0xe9, 0xb6, 0xba,
0xb3, 0x51, 0x05, 0xa4, 0x06, 0x9c, 0xdf, 0x1a, 0x40, 0x74, 0xe3, 0xf0, 0x52, 0x0f, 0xc2, 0x18,
0xb0, 0xcd, 0xf7, 0xca, 0x16, 0x96, 0xe1, 0x19, 0x6c, 0xee, 0xca, 0x33, 0xcf, 0x5c, 0x79, 0xf7,
0xe0, 0x7a, 0xc0, 0x8e, 0xa9, 0xec, 0x71, 0xe6, 0x8f, 0x3c, 0xd0, 0x82, 0xaa, 0x15, 0x7b, 0xeb,
0x5d, 0xe8, 0x55, 0xff, 0xc3, 0x90, 0x01, 0xf4, 0x47, 0x49, 0x28, 0xb0, 0x69, 0x0c, 0x93, 0xc9,
0xe0, 0x73, 0xc4, 0x82, 0xce, 0x77, 0x18, 0x8d, 0xc4, 0xc9, 0x74, 0x60, 0x90, 0x3e, 0x74, 0xdf,
0x1f, 0x27, 0x69, 0x1e, 0xd3, 0x68, 0xd0, 0xda, 0x7d, 0xe7, 0x07, 0x5f, 0x9b, 0x84, 0xe2, 0xa4,
0x18, 0x4b, 0x4b, 0xb6, 0x95, 0x69, 0x5f, 0x0e, 0x53, 0xfd, 0xb5, 0x5d, 0x7a, 0x6d, 0x1b, 0xad,
0xad, 0x86, 0xd9, 0x78, 0xbc, 0x8c, 0xc8, 0xdb, 0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0x99, 0x69,
0x35, 0xab, 0xad, 0x1a, 0x00, 0x00,
// 2003 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xdd, 0x6f, 0x24, 0x47,
0x11, 0x67, 0x76, 0xd6, 0xde, 0xdd, 0xda, 0xb5, 0x6f, 0xdd, 0xf6, 0x5d, 0xc6, 0xbe, 0xcb, 0x9d,
0x33, 0x09, 0x60, 0x72, 0xe2, 0x7c, 0x38, 0x40, 0x22, 0x84, 0xb8, 0x9c, 0xbd, 0xe1, 0x58, 0x5d,
0x6c, 0xcc, 0xf8, 0x12, 0x89, 0xbc, 0x8c, 0x7a, 0x67, 0xda, 0xeb, 0xe1, 0xe6, 0x2b, 0xd3, 0x3d,
0xbe, 0xdb, 0x3c, 0x21, 0x04, 0x2f, 0x20, 0x90, 0x40, 0xe2, 0xdf, 0xe0, 0x95, 0x27, 0x3e, 0xc4,
0x13, 0x12, 0x7f, 0x01, 0xff, 0x09, 0xe2, 0x09, 0x75, 0x75, 0xcf, 0xc7, 0xae, 0xd7, 0xc6, 0xe7,
0x13, 0x49, 0x10, 0xbc, 0x4d, 0x57, 0x55, 0x7f, 0xd4, 0xaf, 0x7e, 0xd5, 0x55, 0xdb, 0x0b, 0xcb,
0x41, 0x2c, 0x58, 0x16, 0xd3, 0xf0, 0x5e, 0x9a, 0x25, 0x22, 0x21, 0xd7, 0xa3, 0x20, 0x3c, 0xcd,
0xb9, 0x1a, 0xdd, 0x2b, 0x94, 0x1b, 0x3d, 0x2f, 0x89, 0xa2, 0x24, 0x56, 0xe2, 0x8d, 0x1e, 0xf7,
0x4e, 0x58, 0x44, 0xd5, 0xc8, 0xfe, 0xa3, 0x01, 0x4b, 0x7b, 0x49, 0x94, 0x26, 0x31, 0x8b, 0xc5,
0x30, 0x3e, 0x4e, 0xc8, 0x0d, 0x58, 0x8c, 0x13, 0x9f, 0x0d, 0x07, 0x96, 0xb1, 0x69, 0x6c, 0x99,
0x8e, 0x1e, 0x11, 0x02, 0xcd, 0x2c, 0x09, 0x99, 0xd5, 0xd8, 0x34, 0xb6, 0x3a, 0x0e, 0x7e, 0x93,
0x07, 0x00, 0x5c, 0x50, 0xc1, 0x5c, 0x2f, 0xf1, 0x99, 0x65, 0x6e, 0x1a, 0x5b, 0xcb, 0x3b, 0x9b,
0xf7, 0xe6, 0x9e, 0xe2, 0xde, 0x91, 0x34, 0xdc, 0x4b, 0x7c, 0xe6, 0x74, 0x78, 0xf1, 0x49, 0xde,
0x05, 0x60, 0xcf, 0x45, 0x46, 0xdd, 0x20, 0x3e, 0x4e, 0xac, 0xe6, 0xa6, 0xb9, 0xd5, 0xdd, 0x79,
0x6d, 0x7a, 0x01, 0x7d, 0xf8, 0xc7, 0x6c, 0xf2, 0x21, 0x0d, 0x73, 0x76, 0x48, 0x83, 0xcc, 0xe9,
0xe0, 0x24, 0x79, 0x5c, 0xfb, 0xef, 0x06, 0x5c, 0x2b, 0x1d, 0xc0, 0x3d, 0x38, 0xf9, 0x16, 0x2c,
0xe0, 0x16, 0xe8, 0x41, 0x77, 0xe7, 0x8d, 0x73, 0x4e, 0x34, 0xe5, 0xb7, 0xa3, 0xa6, 0x90, 0x0f,
0x60, 0x95, 0xe7, 0x23, 0xaf, 0x50, 0xb9, 0x28, 0xe5, 0x56, 0x03, 0x8f, 0x76, 0xb9, 0x95, 0x48,
0x7d, 0x01, 0x7d, 0xa4, 0xb7, 0x60, 0x51, 0xae, 0x94, 0x73, 0x44, 0xa9, 0xbb, 0x73, 0x73, 0xae,
0x93, 0x47, 0x68, 0xe2, 0x68, 0x53, 0xfb, 0x26, 0xac, 0x3f, 0x62, 0x62, 0xc6, 0x3b, 0x87, 0x7d,
0x9c, 0x33, 0x2e, 0xb4, 0xf2, 0x49, 0x10, 0xb1, 0x27, 0x81, 0xf7, 0x74, 0xef, 0x84, 0xc6, 0x31,
0x0b, 0x0b, 0xe5, 0xab, 0x70, 0xf3, 0x11, 0xc3, 0x09, 0x01, 0x17, 0x81, 0xc7, 0x67, 0xd4, 0xd7,
0x61, 0xf5, 0x11, 0x13, 0x03, 0x7f, 0x46, 0xfc, 0x21, 0xb4, 0x0f, 0x64, 0xb0, 0x25, 0x0d, 0xbe,
0x09, 0x2d, 0xea, 0xfb, 0x19, 0xe3, 0x5c, 0xa3, 0x78, 0x6b, 0xee, 0x89, 0x1f, 0x2a, 0x1b, 0xa7,
0x30, 0x9e, 0x47, 0x13, 0xfb, 0x47, 0x00, 0xc3, 0x38, 0x10, 0x87, 0x34, 0xa3, 0x11, 0x3f, 0x97,
0x60, 0x03, 0xe8, 0x71, 0x41, 0x33, 0xe1, 0xa6, 0x68, 0xa7, 0x21, 0xbf, 0x04, 0x1b, 0xba, 0x38,
0x4d, 0xad, 0x6e, 0xff, 0x10, 0xe0, 0x48, 0x64, 0x41, 0x3c, 0x7e, 0x3f, 0xe0, 0x42, 0xee, 0x75,
0x2a, 0xed, 0xa4, 0x13, 0xe6, 0x56, 0xc7, 0xd1, 0xa3, 0x5a, 0x38, 0x1a, 0x97, 0x0f, 0xc7, 0x03,
0xe8, 0x16, 0x70, 0xef, 0xf3, 0x31, 0xb9, 0x0f, 0xcd, 0x11, 0xe5, 0xec, 0x42, 0x78, 0xf6, 0xf9,
0x78, 0x97, 0x72, 0xe6, 0xa0, 0xa5, 0xfd, 0x73, 0x13, 0x5e, 0xd9, 0xcb, 0x18, 0x92, 0x3f, 0x0c,
0x99, 0x27, 0x82, 0x24, 0xd6, 0xd8, 0xbf, 0xf8, 0x6a, 0xe4, 0x15, 0x68, 0xf9, 0x23, 0x37, 0xa6,
0x51, 0x01, 0xf6, 0xa2, 0x3f, 0x3a, 0xa0, 0x11, 0x23, 0x5f, 0x82, 0x65, 0xaf, 0x5c, 0x5f, 0x4a,
0x90, 0x73, 0x1d, 0x67, 0x46, 0x4a, 0xde, 0x80, 0xa5, 0x94, 0x66, 0x22, 0x28, 0xcd, 0x9a, 0x68,
0x36, 0x2d, 0x94, 0x01, 0xf5, 0x47, 0xc3, 0x81, 0xb5, 0x80, 0xc1, 0xc2, 0x6f, 0x62, 0x43, 0xaf,
0x5a, 0x6b, 0x38, 0xb0, 0x16, 0x51, 0x37, 0x25, 0x23, 0x9b, 0xd0, 0x2d, 0x17, 0x1a, 0x0e, 0xac,
0x16, 0x9a, 0xd4, 0x45, 0x32, 0x38, 0xea, 0x2e, 0xb2, 0xda, 0x9b, 0xc6, 0x56, 0xcf, 0xd1, 0x23,
0x72, 0x1f, 0x56, 0x4f, 0x83, 0x4c, 0xe4, 0x34, 0xd4, 0xfc, 0x94, 0xe7, 0xe0, 0x56, 0x07, 0x23,
0x38, 0x4f, 0x45, 0x76, 0x60, 0x2d, 0x3d, 0x99, 0xf0, 0xc0, 0x9b, 0x99, 0x02, 0x38, 0x65, 0xae,
0xce, 0xfe, 0x8b, 0x01, 0xd7, 0x07, 0x59, 0x92, 0x7e, 0x2e, 0x42, 0x51, 0x80, 0xdc, 0xbc, 0x00,
0xe4, 0x85, 0xb3, 0x20, 0xdb, 0xbf, 0x6c, 0xc0, 0x0d, 0xc5, 0xa8, 0xc3, 0x02, 0xd8, 0xff, 0x80,
0x17, 0x5f, 0x86, 0x6b, 0xd5, 0xae, 0xca, 0x60, 0xbe, 0x1b, 0x5f, 0x84, 0xe5, 0x32, 0xc0, 0xca,
0xee, 0xd3, 0xa5, 0x94, 0xfd, 0x8b, 0x06, 0xac, 0xc9, 0xa0, 0xfe, 0x1f, 0x0d, 0x89, 0xc6, 0xcf,
0x0c, 0x20, 0x8a, 0x1d, 0x0f, 0xc3, 0x80, 0xf2, 0xab, 0x63, 0x31, 0xc7, 0xe5, 0xc6, 0x5c, 0x97,
0xd7, 0x60, 0x81, 0xca, 0xad, 0x34, 0x22, 0x6a, 0x60, 0x7f, 0x04, 0x7d, 0x19, 0x94, 0x97, 0x3c,
0x44, 0xb9, 0x76, 0xa3, 0xbe, 0xf6, 0x4f, 0x0d, 0x58, 0x79, 0x18, 0x0a, 0x96, 0x7d, 0xb6, 0x2e,
0xfe, 0xa9, 0x51, 0x40, 0x3d, 0x8c, 0x7d, 0xf6, 0xfc, 0xb3, 0xa4, 0xdd, 0xab, 0x00, 0xc7, 0x01,
0x0b, 0xfd, 0x3a, 0xe5, 0x3a, 0x28, 0x79, 0x29, 0xba, 0x59, 0xd0, 0xc2, 0x45, 0x4a, 0xaa, 0x15,
0x43, 0x59, 0xb8, 0x55, 0x13, 0xa7, 0x0b, 0x77, 0xfb, 0xd2, 0x85, 0x1b, 0xa7, 0xe9, 0xc2, 0xfd,
0x3b, 0x13, 0x96, 0x86, 0x31, 0x67, 0x99, 0xf8, 0x5f, 0xce, 0x59, 0x72, 0x0b, 0x3a, 0x9c, 0x8d,
0x23, 0xd9, 0x4b, 0x0e, 0xb0, 0x2e, 0x9a, 0x4e, 0x25, 0x90, 0x5a, 0x4f, 0x15, 0xb1, 0xe1, 0xc0,
0xea, 0xa8, 0xd0, 0x96, 0x02, 0x72, 0x1b, 0x40, 0x04, 0x11, 0xe3, 0x82, 0x46, 0xa9, 0x2a, 0x7e,
0x4d, 0xa7, 0x26, 0x91, 0x05, 0x37, 0x4b, 0x9e, 0x0d, 0x07, 0xdc, 0xea, 0x6e, 0x9a, 0xb2, 0xf3,
0x52, 0x23, 0xf2, 0x75, 0x68, 0x67, 0xc9, 0x33, 0xd7, 0xa7, 0x82, 0x5a, 0x3d, 0x0c, 0xde, 0xfa,
0x5c, 0xb0, 0x77, 0xc3, 0x64, 0xe4, 0xb4, 0xb2, 0xe4, 0xd9, 0x80, 0x0a, 0x6a, 0xff, 0xc3, 0x84,
0xa5, 0x23, 0x46, 0x33, 0xef, 0xe4, 0xea, 0x01, 0xfb, 0x0a, 0xf4, 0x33, 0xc6, 0xf3, 0x50, 0xb8,
0x95, 0x5b, 0x2a, 0x72, 0xd7, 0x94, 0x7c, 0xaf, 0x74, 0xae, 0x80, 0xdc, 0xbc, 0x00, 0xf2, 0xe6,
0x1c, 0xc8, 0x6d, 0xe8, 0xd5, 0xf0, 0xe5, 0xd6, 0x02, 0xba, 0x3e, 0x25, 0x23, 0x7d, 0x30, 0x7d,
0x1e, 0x62, 0xc4, 0x3a, 0x8e, 0xfc, 0x24, 0x77, 0x61, 0x25, 0x0d, 0xa9, 0xc7, 0x4e, 0x92, 0xd0,
0x67, 0x99, 0x3b, 0xce, 0x92, 0x3c, 0xc5, 0x70, 0xf5, 0x9c, 0x7e, 0x4d, 0xf1, 0x48, 0xca, 0xc9,
0xdb, 0xd0, 0xf6, 0x79, 0xe8, 0x8a, 0x49, 0xca, 0x30, 0x64, 0xcb, 0xe7, 0xf8, 0x3e, 0xe0, 0xe1,
0x93, 0x49, 0xca, 0x9c, 0x96, 0xaf, 0x3e, 0xc8, 0x7d, 0x58, 0xe3, 0x2c, 0x0b, 0x68, 0x18, 0x7c,
0xc2, 0x7c, 0x97, 0x3d, 0x4f, 0x33, 0x37, 0x0d, 0x69, 0x8c, 0x91, 0xed, 0x39, 0xa4, 0xd2, 0xbd,
0xf7, 0x3c, 0xcd, 0x0e, 0x43, 0x1a, 0x93, 0x2d, 0xe8, 0x27, 0xb9, 0x48, 0x73, 0xe1, 0x62, 0xf6,
0x71, 0x37, 0xf0, 0x31, 0xd0, 0xa6, 0xb3, 0xac, 0xe4, 0xdf, 0x45, 0xf1, 0xd0, 0x97, 0xd0, 0x8a,
0x8c, 0x9e, 0xb2, 0xd0, 0x2d, 0x19, 0x60, 0x75, 0x37, 0x8d, 0xad, 0xa6, 0x73, 0x4d, 0xc9, 0x9f,
0x14, 0x62, 0xb2, 0x0d, 0xab, 0xe3, 0x9c, 0x66, 0x34, 0x16, 0x8c, 0xd5, 0xac, 0x7b, 0x68, 0x4d,
0x4a, 0x55, 0x39, 0xc1, 0xfe, 0x75, 0xb3, 0x0a, 0xbd, 0x8c, 0x12, 0xbf, 0x42, 0xe8, 0xaf, 0xd2,
0x82, 0xcf, 0xe5, 0x8b, 0x39, 0x9f, 0x2f, 0x77, 0xa0, 0x1b, 0x31, 0x91, 0x05, 0x9e, 0x8a, 0x8b,
0x4a, 0x63, 0x50, 0x22, 0x04, 0xff, 0x0e, 0x74, 0xe3, 0x3c, 0x72, 0x3f, 0xce, 0x59, 0x16, 0x30,
0xae, 0x53, 0x19, 0xe2, 0x3c, 0xfa, 0x81, 0x92, 0x90, 0x55, 0x58, 0x10, 0x49, 0xea, 0x3e, 0xd5,
0x99, 0xdc, 0x14, 0x49, 0xfa, 0x98, 0x7c, 0x1b, 0x36, 0x38, 0xa3, 0x21, 0xf3, 0xdd, 0x32, 0x2b,
0xb9, 0xcb, 0x11, 0x0b, 0xe6, 0x5b, 0x2d, 0x0c, 0x85, 0xa5, 0x2c, 0x8e, 0x4a, 0x83, 0x23, 0xad,
0x97, 0x48, 0x97, 0x07, 0xaf, 0x4d, 0x6b, 0x63, 0x9f, 0x4a, 0x2a, 0x55, 0x39, 0xe1, 0x1d, 0xb0,
0xc6, 0x61, 0x32, 0xa2, 0xa1, 0x7b, 0x66, 0x57, 0x6c, 0x88, 0x4d, 0xe7, 0x86, 0xd2, 0x1f, 0xcd,
0x6c, 0x29, 0xdd, 0xe3, 0x61, 0xe0, 0x31, 0xdf, 0x1d, 0x85, 0xc9, 0xc8, 0x02, 0xa4, 0x14, 0x28,
0x91, 0x4c, 0x64, 0x49, 0x25, 0x6d, 0x20, 0x61, 0xf0, 0x92, 0x3c, 0x16, 0x48, 0x10, 0xd3, 0x59,
0x56, 0xf2, 0x83, 0x3c, 0xda, 0x93, 0x52, 0xf2, 0x3a, 0x2c, 0x69, 0xcb, 0xe4, 0xf8, 0x98, 0x33,
0x81, 0xcc, 0x30, 0x9d, 0x9e, 0x12, 0x7e, 0x1f, 0x65, 0xf6, 0x4f, 0x4c, 0xb8, 0xe6, 0x48, 0x74,
0xd9, 0x29, 0xfb, 0xaf, 0xbf, 0x10, 0xce, 0x4b, 0xcc, 0xc5, 0x17, 0x4a, 0xcc, 0xd6, 0xa5, 0x13,
0xb3, 0xfd, 0x42, 0x89, 0xd9, 0x39, 0x37, 0x31, 0xff, 0x30, 0x15, 0x84, 0xcf, 0x6b, 0x6a, 0xbe,
0x09, 0x66, 0xe0, 0x73, 0x0c, 0x4e, 0x77, 0xc7, 0x9a, 0x5e, 0x5c, 0xbf, 0x4e, 0x0d, 0x07, 0xdc,
0x91, 0x46, 0xe4, 0x01, 0x74, 0x35, 0xa0, 0x58, 0x9e, 0x16, 0xb0, 0x3c, 0xdd, 0x9e, 0x3b, 0x07,
0x11, 0x96, 0xa5, 0xc9, 0x51, 0x0d, 0x10, 0x97, 0xdf, 0xe4, 0x3b, 0x70, 0xf3, 0x6c, 0xc2, 0x66,
0x1a, 0x23, 0xdf, 0x5a, 0xc4, 0x18, 0xad, 0xcf, 0x66, 0x6c, 0x01, 0xa2, 0x4f, 0xbe, 0x06, 0x6b,
0xb5, 0x94, 0xad, 0x26, 0xb6, 0xd4, 0xcf, 0xd1, 0x4a, 0x57, 0x4d, 0xb9, 0x28, 0x69, 0xdb, 0x17,
0x25, 0xad, 0xfd, 0x37, 0x03, 0x96, 0x06, 0x2c, 0x64, 0x82, 0x7d, 0x0a, 0x9d, 0xec, 0x54, 0x33,
0x61, 0x5e, 0xdc, 0x4c, 0x34, 0xcf, 0x34, 0x13, 0xaf, 0x41, 0x2f, 0xcd, 0x82, 0x88, 0x66, 0x13,
0xf7, 0x29, 0x9b, 0x14, 0x69, 0xd4, 0xd5, 0xb2, 0xc7, 0x6c, 0xc2, 0xed, 0x18, 0x36, 0xde, 0x4f,
0xa8, 0xbf, 0x4b, 0x43, 0x1a, 0x7b, 0x4c, 0xbb, 0xf9, 0x12, 0x3d, 0xfa, 0x6d, 0x80, 0x1a, 0x92,
0x0d, 0xdc, 0xb0, 0x26, 0xb1, 0xff, 0x69, 0x40, 0x47, 0x6e, 0x88, 0x2d, 0xf8, 0x15, 0xd6, 0x9f,
0xea, 0xbd, 0x1a, 0x73, 0x7a, 0xaf, 0xb2, 0x8b, 0x2e, 0xe0, 0xaa, 0xda, 0xea, 0x5a, 0x7b, 0xdc,
0x9c, 0x6e, 0x8f, 0xef, 0x40, 0x37, 0x90, 0x07, 0x72, 0x53, 0x2a, 0x4e, 0x14, 0x4e, 0x1d, 0x07,
0x50, 0x74, 0x28, 0x25, 0xb2, 0x7f, 0x2e, 0x0c, 0xb0, 0x7f, 0x5e, 0xbc, 0x74, 0xff, 0xac, 0x17,
0xc1, 0xfe, 0xf9, 0xcf, 0x0d, 0xb0, 0x34, 0xc4, 0xd5, 0xbb, 0xdf, 0x07, 0xa9, 0x8f, 0xcf, 0x8f,
0xb7, 0xa0, 0x53, 0xb2, 0x4c, 0x3f, 0xbb, 0x55, 0x02, 0x89, 0xeb, 0x3e, 0x8b, 0x92, 0x6c, 0x72,
0x14, 0x7c, 0xc2, 0xb4, 0xe3, 0x35, 0x89, 0xf4, 0xed, 0x20, 0x8f, 0x9c, 0xe4, 0x19, 0xd7, 0x97,
0x6d, 0x31, 0x94, 0xbe, 0x79, 0xf8, 0xab, 0x07, 0x6f, 0x27, 0xf4, 0xbc, 0xe9, 0x80, 0x12, 0xc9,
0x5b, 0x89, 0xac, 0x43, 0x9b, 0xc5, 0xbe, 0xd2, 0x2e, 0xa0, 0xb6, 0xc5, 0x62, 0x1f, 0x55, 0x43,
0x58, 0xd6, 0xef, 0x7d, 0x09, 0xc7, 0x8b, 0x17, 0x6f, 0xd7, 0xee, 0x8e, 0x7d, 0xce, 0x23, 0xeb,
0x3e, 0x1f, 0x1f, 0x6a, 0x4b, 0x67, 0x49, 0x3d, 0xf9, 0xe9, 0x21, 0x79, 0x0f, 0x7a, 0x72, 0x97,
0x72, 0xa1, 0xd6, 0xa5, 0x17, 0xea, 0xb2, 0xd8, 0x2f, 0x06, 0xf6, 0x6f, 0x0c, 0x58, 0x39, 0x03,
0xe1, 0x15, 0x78, 0xf4, 0x18, 0xda, 0x47, 0x6c, 0x2c, 0x97, 0x28, 0x5e, 0x31, 0xb7, 0xcf, 0x7b,
0x14, 0x3f, 0x27, 0x60, 0x4e, 0xb9, 0x80, 0xfc, 0x81, 0x0b, 0x48, 0x68, 0x1c, 0x9e, 0x21, 0x8b,
0x71, 0x15, 0xb2, 0xc8, 0xfa, 0x26, 0x8b, 0x7e, 0xc6, 0x42, 0x2a, 0xaa, 0xfb, 0x89, 0xeb, 0xd8,
0x93, 0x38, 0x8f, 0x1c, 0xa5, 0x2a, 0x92, 0xd6, 0xfe, 0x95, 0x01, 0x80, 0x17, 0xac, 0x3a, 0xc6,
0x6c, 0xa1, 0x35, 0x2e, 0xfe, 0xc5, 0xd8, 0x98, 0x4e, 0x89, 0xdd, 0x22, 0x25, 0x38, 0x62, 0x64,
0xce, 0xf3, 0xa1, 0xc4, 0xa8, 0x72, 0x5e, 0x67, 0x8d, 0xc2, 0xe5, 0xb7, 0x06, 0xf4, 0x6a, 0xf0,
0xf1, 0xe9, 0xec, 0x35, 0x66, 0xb3, 0x17, 0xdb, 0x41, 0xc9, 0x68, 0x97, 0xd7, 0x48, 0x1e, 0x55,
0x24, 0x5f, 0x87, 0x36, 0x42, 0x52, 0x63, 0x79, 0xac, 0x59, 0x7e, 0x17, 0x56, 0x32, 0xe6, 0xb1,
0x58, 0x84, 0x13, 0x37, 0x4a, 0xfc, 0xe0, 0x38, 0x60, 0x3e, 0x72, 0xbd, 0xed, 0xf4, 0x0b, 0xc5,
0xbe, 0x96, 0xdb, 0x7f, 0x35, 0x60, 0x59, 0x76, 0x90, 0x93, 0x83, 0xc4, 0x67, 0xea, 0x64, 0x2f,
0xce, 0xa0, 0x77, 0xd1, 0x17, 0x0d, 0x8f, 0xa2, 0xd0, 0xeb, 0xff, 0x9e, 0x42, 0xdc, 0x69, 0x73,
0x4d, 0x1b, 0x09, 0xb1, 0x7a, 0x05, 0xb8, 0x0c, 0xc4, 0x55, 0x60, 0x75, 0xe9, 0x54, 0x10, 0xff,
0xd8, 0x80, 0x6e, 0x2d, 0x59, 0xe4, 0x95, 0xaf, 0xeb, 0x83, 0x2a, 0x2b, 0x06, 0x5e, 0x82, 0x5d,
0xaf, 0x7a, 0x56, 0x25, 0x6b, 0xb0, 0x10, 0xf1, 0xb1, 0x8e, 0x78, 0xcf, 0x51, 0x03, 0xb2, 0x01,
0xed, 0x88, 0x8f, 0xf1, 0xc7, 0x92, 0xbe, 0x39, 0xcb, 0xb1, 0x0c, 0x5b, 0xd5, 0xd9, 0xa8, 0x0b,
0xa4, 0x12, 0xd8, 0xbf, 0x37, 0x80, 0xe8, 0xc6, 0xe1, 0xa5, 0xde, 0xde, 0x91, 0xb0, 0xf5, 0xa7,
0xe1, 0x06, 0x5e, 0xc3, 0x53, 0xb2, 0x99, 0x92, 0x67, 0x9e, 0x29, 0x79, 0x77, 0x61, 0xc5, 0x67,
0xc7, 0x54, 0xf6, 0x38, 0xb3, 0x47, 0xee, 0x6b, 0x45, 0xd9, 0x8a, 0xbd, 0xf9, 0x0e, 0x74, 0xca,
0xbf, 0xbc, 0x48, 0x1f, 0x7a, 0xc3, 0x38, 0x10, 0xd8, 0x34, 0x06, 0xf1, 0xb8, 0xff, 0x05, 0xd2,
0x85, 0xd6, 0xf7, 0x18, 0x0d, 0xc5, 0xc9, 0xa4, 0x6f, 0x90, 0x1e, 0xb4, 0x1f, 0x8e, 0xe2, 0x24,
0x8b, 0x68, 0xd8, 0x6f, 0xec, 0xbe, 0xfd, 0xd1, 0x37, 0xc6, 0x81, 0x38, 0xc9, 0x47, 0xd2, 0x93,
0x6d, 0xe5, 0xda, 0x57, 0x83, 0x44, 0x7f, 0x6d, 0x17, 0x51, 0xdb, 0x46, 0x6f, 0xcb, 0x61, 0x3a,
0x1a, 0x2d, 0xa2, 0xe4, 0xad, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x40, 0x21, 0x2c, 0x18,
0x1c, 0x00, 0x00,
}

29
internal/proto/milvus.proto
View File

@ -24,6 +24,10 @@ service MilvusService {
rpc GetPartitionStatistics(GetPartitionStatisticsRequest) returns (GetPartitionStatisticsResponse) {}
rpc ShowPartitions(ShowPartitionsRequest) returns (ShowPartitionsResponse) {}
rpc CreateAlias(CreateAliasRequest) returns (common.Status) {}
rpc DropAlias(DropAliasRequest) returns (common.Status) {}
rpc AlterAlias(AlterAliasRequest) returns (common.Status) {}
rpc CreateIndex(CreateIndexRequest) returns (common.Status) {}
rpc DescribeIndex(DescribeIndexRequest) returns (DescribeIndexResponse) {}
rpc GetIndexState(GetIndexStateRequest) returns (GetIndexStateResponse) {}
@ -49,8 +53,25 @@ service MilvusService {
rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse) {}
}
message CreateAliasRequest {
common.MsgBase base = 1;
string collection_name = 2;
string alias = 3;
}
message DropAliasRequest {
common.MsgBase base = 1;
string alias = 2;
}
message AlterAliasRequest{
common.MsgBase base = 1;
string collection_name = 2;
string alias = 3;
}
/**
* Create collection in milvus
* Create collection in milvus
*/
message CreateCollectionRequest {
// Not useful for now
@ -138,7 +159,9 @@ message DescribeCollectionResponse {
// The utc timestamp calculated by created_timestamp
uint64 created_utc_timestamp = 7;
// The shards number you set.
int32 shards_num = 8;
int32 shards_num = 8;
// The aliases of this collection
repeated string aliases = 9;
}
/**
@ -563,4 +586,4 @@ message GetMetricsResponse {
service ProxyService {
rpc RegisterLink(RegisterLinkRequest) returns (RegisterLinkResponse) {}
}
}

792
internal/proto/milvuspb/milvus.pb.go
View File

File diff suppressed because it is too large Load Diff

4
internal/proto/root_coord.proto
View File

@ -49,6 +49,10 @@ service RootCoord {
*/
rpc DescribeCollection(milvus.DescribeCollectionRequest) returns (milvus.DescribeCollectionResponse) {}
rpc CreateAlias(milvus.CreateAliasRequest) returns (common.Status) {}
rpc DropAlias(milvus.DropAliasRequest) returns (common.Status) {}
rpc AlterAlias(milvus.AlterAliasRequest) returns (common.Status) {}
/**
* @brief This method is used to list all collections.
*

212
internal/proto/rootcoordpb/root_coord.pb.go
View File

@ -243,57 +243,59 @@ func init() {
func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) }
var fileDescriptor_4513485a144f6b06 = []byte{
// 787 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x5d, 0x4f, 0xdb, 0x3e,
0x14, 0xc6, 0x69, 0xe1, 0xcf, 0x5f, 0x1c, 0xda, 0x82, 0x2c, 0x60, 0xa8, 0xe3, 0x82, 0x75, 0x1a,
0xb4, 0xbc, 0xa4, 0x08, 0xa4, 0x69, 0xb7, 0xa3, 0xd5, 0xa0, 0xd2, 0x2a, 0x8d, 0x14, 0xa4, 0xbd,
0xa1, 0xca, 0x4d, 0x8f, 0xda, 0x88, 0x24, 0x0e, 0xb1, 0x3b, 0xd8, 0xe5, 0xbe, 0xd9, 0x3e, 0xda,
0x94, 0x17, 0xa7, 0x49, 0x9a, 0x94, 0xa0, 0xed, 0xae, 0x8e, 0x7f, 0x7e, 0x1e, 0x1f, 0x3f, 0xa7,
0xb2, 0x61, 0xdd, 0x61, 0x4c, 0xf4, 0x35, 0xc6, 0x9c, 0xa1, 0x62, 0x3b, 0x4c, 0x30, 0xb2, 0x65,
0xea, 0xc6, 0x8f, 0x09, 0xf7, 0x47, 0x8a, 0x3b, 0xed, 0xcd, 0x56, 0x4b, 0x1a, 0x33, 0x4d, 0x66,
0xf9, 0xdf, 0xab, 0xa5, 0x28, 0x55, 0xad, 0xe8, 0x96, 0x40, 0xc7, 0xa2, 0x46, 0x30, 0x5e, 0xb5,
0x1d, 0xf6, 0xf8, 0x33, 0x18, 0xac, 0x0f, 0xa9, 0xa0, 0x51, 0x8b, 0x5a, 0x1f, 0x36, 0xdf, 0x1b,
0x06, 0xd3, 0xae, 0x75, 0x13, 0xb9, 0xa0, 0xa6, 0xad, 0xe2, 0xfd, 0x04, 0xb9, 0x20, 0x27, 0xb0,
0x34, 0xa0, 0x1c, 0xb7, 0x0b, 0xbb, 0x85, 0xfa, 0xea, 0xe9, 0x8e, 0x12, 0xdb, 0x4a, 0xe0, 0xdf,
0xe5, 0xa3, 0x73, 0xca, 0x51, 0xf5, 0x48, 0xb2, 0x01, 0xff, 0x69, 0x6c, 0x62, 0x89, 0xed, 0xc5,
0xdd, 0x42, 0xbd, 0xac, 0xfa, 0x83, 0xda, 0xaf, 0x02, 0x6c, 0x25, 0x1d, 0xb8, 0xcd, 0x2c, 0x8e,
0xe4, 0x0c, 0x96, 0xb9, 0xa0, 0x62, 0xc2, 0x03, 0x93, 0x97, 0xa9, 0x26, 0x3d, 0x0f, 0x51, 0x03,
0x94, 0xec, 0xc0, 0x8a, 0x90, 0x4a, 0xdb, 0xc5, 0xdd, 0x42, 0x7d, 0x49, 0x9d, 0x7e, 0xc8, 0xd8,
0xc3, 0x67, 0xa8, 0x78, 0x5b, 0xe8, 0xb4, 0xff, 0x41, 0x75, 0xc5, 0xa8, 0xb2, 0x01, 0x6b, 0xa1,
0xf2, 0xdf, 0x54, 0x55, 0x81, 0x62, 0xa7, 0xed, 0x49, 0x2f, 0xaa, 0xc5, 0x4e, 0x3b, 0xbd, 0x8e,
0xd3, 0xdf, 0x04, 0x56, 0x54, 0xc6, 0x44, 0xcb, 0x0d, 0x90, 0xd8, 0x40, 0x2e, 0x50, 0xb4, 0x98,
0x69, 0x33, 0x0b, 0x2d, 0xe1, 0x2a, 0x22, 0x27, 0x27, 0x71, 0xbb, 0xb0, 0x1b, 0x66, 0xd1, 0xe0,
0x2c, 0xaa, 0x7b, 0x19, 0x2b, 0x12, 0x78, 0x6d, 0x81, 0x98, 0x9e, 0xa3, 0x1b, 0xe4, 0xb5, 0xae,
0xdd, 0xb5, 0xc6, 0xd4, 0xb2, 0xd0, 0x98, 0xe7, 0x98, 0x40, 0xa5, 0xe3, 0xeb, 0xf8, 0x8a, 0x60,
0xd0, 0x13, 0x8e, 0x6e, 0x8d, 0xe4, 0x39, 0xd6, 0x16, 0xc8, 0x3d, 0x6c, 0x5c, 0xa0, 0xe7, 0xae,
0x73, 0xa1, 0x6b, 0x5c, 0x1a, 0x9e, 0x66, 0x1b, 0xce, 0xc0, 0xcf, 0xb4, 0xec, 0xc3, 0x7a, 0xcb,
0x41, 0x2a, 0xb0, 0xc5, 0x0c, 0x03, 0x35, 0xa1, 0x33, 0x8b, 0x1c, 0xa5, 0x2e, 0x4d, 0x62, 0xd2,
0x68, 0x5e, 0xdc, 0xb5, 0x05, 0xf2, 0x0d, 0x2a, 0x6d, 0x87, 0xd9, 0x11, 0xf9, 0x83, 0x54, 0xf9,
0x38, 0x94, 0x53, 0xbc, 0x0f, 0xe5, 0x4b, 0xca, 0x23, 0xda, 0x8d, 0x54, 0xed, 0x18, 0x23, 0xa5,
0x5f, 0xa5, 0xa2, 0xe7, 0x8c, 0x19, 0x91, 0xe3, 0x79, 0x00, 0xd2, 0x46, 0xae, 0x39, 0xfa, 0x20,
0x7a, 0x40, 0x4a, 0x7a, 0x05, 0x33, 0xa0, 0xb4, 0x6a, 0xe6, 0xe6, 0x43, 0x63, 0x0b, 0xd6, 0x7a,
0x63, 0xf6, 0x30, 0x9d, 0xe3, 0xe4, 0x30, 0x3d, 0xd1, 0x38, 0x25, 0x2d, 0x8f, 0xf2, 0xc1, 0xa1,
0xdf, 0x2d, 0xac, 0xf9, 0x01, 0x7f, 0xa2, 0x8e, 0xd0, 0xbd, 0x2a, 0x0f, 0xe7, 0xb4, 0x41, 0x48,
0xe5, 0x0c, 0xea, 0x0b, 0x94, 0xdd, 0x80, 0xa7, 0xe2, 0x8d, 0xcc, 0x26, 0x78, 0xae, 0xf4, 0x2d,
0x94, 0x2e, 0x29, 0x9f, 0x2a, 0xd7, 0xb3, 0x5a, 0x60, 0x46, 0x38, 0x57, 0x07, 0xdc, 0x41, 0xc5,
0x3d, 0xb5, 0x70, 0x31, 0xcf, 0xe8, 0xdf, 0x38, 0x24, 0x2d, 0x0e, 0x73, 0xb1, 0xd1, 0xd4, 0x65,
0x57, 0xf4, 0x70, 0x64, 0xa2, 0x25, 0x32, 0x52, 0x48, 0x50, 0xf3, 0x53, 0x9f, 0x81, 0x43, 0x3f,
0x84, 0x92, 0xbb, 0x97, 0x60, 0x82, 0x67, 0x9c, 0x5d, 0x14, 0x91, 0x4e, 0x8d, 0x1c, 0x64, 0x68,
0x73, 0x03, 0xab, 0x7e, 0xdb, 0x74, 0xac, 0x21, 0x3e, 0x92, 0xfd, 0x39, 0x8d, 0xe5, 0x11, 0x39,
0x93, 0x1f, 0x43, 0x59, 0x96, 0xe6, 0x0b, 0x37, 0xe6, 0x96, 0x1f, 0x93, 0x3e, 0xc8, 0x83, 0x86,
0x05, 0x5c, 0xc1, 0x8a, 0xdb, 0x9a, 0xbe, 0xcb, 0x9b, 0xcc, 0xd6, 0x7d, 0xce, 0xe6, 0xef, 0x83,
0x2b, 0x3a, 0x7c, 0x25, 0x90, 0x63, 0x25, 0xfd, 0xf5, 0xa3, 0xa4, 0xbe, 0x57, 0xaa, 0x4a, 0x5e,
0x3c, 0xac, 0xe2, 0x3b, 0xfc, 0x1f, 0xdc, 0xdd, 0x64, 0x6f, 0xee, 0xe2, 0xf0, 0xd9, 0x50, 0xdd,
0x7f, 0x92, 0x0b, 0xd5, 0x29, 0x6c, 0xde, 0xd8, 0x43, 0xf7, 0x8a, 0xf0, 0x2f, 0x22, 0x79, 0x15,
0x26, 0x53, 0x99, 0x5e, 0xb7, 0x71, 0xae, 0xcb, 0x47, 0x4f, 0x9d, 0x99, 0x01, 0x2f, 0x54, 0x34,
0x90, 0x72, 0x6c, 0x5f, 0x7d, 0xec, 0x22, 0xe7, 0x74, 0x84, 0x3d, 0xe1, 0x20, 0x35, 0x93, 0x57,
0xa4, 0xff, 0x06, 0xcc, 0x80, 0x73, 0x26, 0xa4, 0xc1, 0x66, 0xd0, 0xcb, 0x1f, 0x8c, 0x09, 0x1f,
0xbb, 0xaf, 0x03, 0x03, 0x05, 0x0e, 0x93, 0x7f, 0x49, 0xf7, 0x89, 0xa9, 0xa4, 0x92, 0x39, 0x4a,
0xea, 0x03, 0x5c, 0xa0, 0xe8, 0xa2, 0x70, 0x74, 0x8d, 0x27, 0x63, 0x09, 0x06, 0x53, 0x20, 0x23,
0x96, 0x14, 0x4e, 0xc6, 0x72, 0xfe, 0xee, 0xeb, 0xdb, 0x91, 0x2e, 0xc6, 0x93, 0x81, 0x6b, 0xdd,
0xf4, 0xc9, 0x63, 0x9d, 0x05, 0xbf, 0x9a, 0x32, 0x8d, 0xa6, 0xa7, 0xd4, 0x0c, 0x03, 0xb6, 0x07,
0x83, 0x65, 0xef, 0xd3, 0xd9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x2e, 0x6c, 0xa3, 0xa7,
0x0b, 0x00, 0x00,
// 826 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xdb, 0x4f, 0xe3, 0x46,
0x14, 0xc6, 0x49, 0xa0, 0x54, 0x1c, 0x72, 0x41, 0x23, 0xa0, 0x28, 0xe5, 0x81, 0xa6, 0x2a, 0x24,
0x5c, 0x1c, 0x04, 0x52, 0xd5, 0x57, 0x48, 0x54, 0x88, 0xd4, 0x48, 0xc5, 0x01, 0x69, 0x6f, 0x28,
0x9a, 0x38, 0x47, 0x89, 0x85, 0xed, 0x31, 0x9e, 0xc9, 0xc2, 0x3e, 0xee, 0x5f, 0xb6, 0xff, 0xda,
0xca, 0x97, 0x71, 0x6c, 0xc7, 0x0e, 0x8e, 0x76, 0xdf, 0xe2, 0xf8, 0x37, 0xdf, 0x37, 0xe7, 0x3b,
0x1e, 0xfb, 0xc0, 0x96, 0xc3, 0x98, 0x18, 0x68, 0x8c, 0x39, 0x23, 0xc5, 0x76, 0x98, 0x60, 0x64,
0xd7, 0xd4, 0x8d, 0xcf, 0x53, 0xee, 0x5f, 0x29, 0xee, 0x6d, 0xef, 0x6e, 0xad, 0xa4, 0x31, 0xd3,
0x64, 0x96, 0xff, 0x7f, 0xad, 0x14, 0xa5, 0x6a, 0x15, 0xdd, 0x12, 0xe8, 0x58, 0xd4, 0x08, 0xae,
0x37, 0x6d, 0x87, 0xbd, 0x7e, 0x09, 0x2e, 0xb6, 0x46, 0x54, 0xd0, 0xa8, 0x45, 0x7d, 0x00, 0x3b,
0x57, 0x86, 0xc1, 0xb4, 0x7b, 0xdd, 0x44, 0x2e, 0xa8, 0x69, 0xab, 0xf8, 0x3c, 0x45, 0x2e, 0xc8,
0x39, 0xac, 0x0d, 0x29, 0xc7, 0xbd, 0xc2, 0x41, 0xa1, 0xb1, 0x79, 0xb1, 0xaf, 0xc4, 0xb6, 0x12,
0xf8, 0xf7, 0xf8, 0xf8, 0x9a, 0x72, 0x54, 0x3d, 0x92, 0x6c, 0xc3, 0x2f, 0x1a, 0x9b, 0x5a, 0x62,
0x6f, 0xf5, 0xa0, 0xd0, 0x28, 0xab, 0xfe, 0x45, 0xfd, 0x6b, 0x01, 0x76, 0x93, 0x0e, 0xdc, 0x66,
0x16, 0x47, 0x72, 0x09, 0xeb, 0x5c, 0x50, 0x31, 0xe5, 0x81, 0xc9, 0xef, 0xa9, 0x26, 0x7d, 0x0f,
0x51, 0x03, 0x94, 0xec, 0xc3, 0x86, 0x90, 0x4a, 0x7b, 0xc5, 0x83, 0x42, 0x63, 0x4d, 0x9d, 0xfd,
0x91, 0xb1, 0x87, 0x77, 0x50, 0xf1, 0xb6, 0xd0, 0xed, 0xfc, 0x84, 0xea, 0x8a, 0x51, 0x65, 0x03,
0xaa, 0xa1, 0xf2, 0x8f, 0x54, 0x55, 0x81, 0x62, 0xb7, 0xe3, 0x49, 0xaf, 0xaa, 0xc5, 0x6e, 0x27,
0xbd, 0x8e, 0x8b, 0x6f, 0xdb, 0xb0, 0xa1, 0x32, 0x26, 0xda, 0x6e, 0x03, 0x89, 0x0d, 0xe4, 0x06,
0x45, 0x9b, 0x99, 0x36, 0xb3, 0xd0, 0x12, 0xae, 0x22, 0x72, 0x72, 0x1e, 0xb7, 0x0b, 0x9f, 0x86,
0x79, 0x34, 0xc8, 0xa2, 0x76, 0x98, 0xb1, 0x22, 0x81, 0xd7, 0x57, 0x88, 0xe9, 0x39, 0xba, 0x8d,
0xbc, 0xd7, 0xb5, 0xa7, 0xf6, 0x84, 0x5a, 0x16, 0x1a, 0x8b, 0x1c, 0x13, 0xa8, 0x74, 0xfc, 0x33,
0xbe, 0x22, 0xb8, 0xe8, 0x0b, 0x47, 0xb7, 0xc6, 0x32, 0xc7, 0xfa, 0x0a, 0x79, 0x86, 0xed, 0x1b,
0xf4, 0xdc, 0x75, 0x2e, 0x74, 0x8d, 0x4b, 0xc3, 0x8b, 0x6c, 0xc3, 0x39, 0x78, 0x49, 0xcb, 0x01,
0x6c, 0xb5, 0x1d, 0xa4, 0x02, 0xdb, 0xcc, 0x30, 0x50, 0x13, 0x3a, 0xb3, 0xc8, 0x69, 0xea, 0xd2,
0x24, 0x26, 0x8d, 0x16, 0xb5, 0xbb, 0xbe, 0x42, 0x3e, 0x42, 0xa5, 0xe3, 0x30, 0x3b, 0x22, 0x7f,
0x9c, 0x2a, 0x1f, 0x87, 0x72, 0x8a, 0x0f, 0xa0, 0x7c, 0x4b, 0x79, 0x44, 0xbb, 0x99, 0xaa, 0x1d,
0x63, 0xa4, 0xf4, 0x1f, 0xa9, 0xe8, 0x35, 0x63, 0x46, 0x24, 0x9e, 0x17, 0x20, 0x1d, 0xe4, 0x9a,
0xa3, 0x0f, 0xa3, 0x01, 0x29, 0xe9, 0x15, 0xcc, 0x81, 0xd2, 0xaa, 0x95, 0x9b, 0x0f, 0x8d, 0x1f,
0x60, 0xd3, 0x0f, 0xfc, 0xca, 0xd0, 0x29, 0x27, 0x47, 0x0b, 0x5a, 0xe2, 0x11, 0x39, 0x03, 0xbb,
0x83, 0x0d, 0x37, 0x68, 0x5f, 0xf4, 0xaf, 0xcc, 0x46, 0x2c, 0x23, 0xd9, 0x07, 0xb8, 0x32, 0x04,
0x3a, 0xbe, 0xe6, 0x61, 0xaa, 0xe6, 0x0c, 0xc8, 0x29, 0x6a, 0x41, 0xb5, 0x3f, 0x61, 0x2f, 0xb3,
0x68, 0x38, 0x39, 0x49, 0x7f, 0xa0, 0xe3, 0x94, 0x94, 0x3f, 0xcd, 0x07, 0x87, 0x71, 0x3f, 0x42,
0xd5, 0x0f, 0xf3, 0x7f, 0xea, 0x08, 0xdd, 0x6b, 0xf2, 0xc9, 0x82, 0xc8, 0x43, 0x2a, 0x67, 0x39,
0xef, 0xa1, 0xec, 0xc6, 0x3a, 0x13, 0x6f, 0x66, 0x46, 0xbf, 0xac, 0xf4, 0x23, 0x94, 0x6e, 0x29,
0x9f, 0x29, 0x37, 0xb2, 0x4e, 0xc0, 0x9c, 0x70, 0xae, 0x03, 0xf0, 0x04, 0x15, 0x37, 0xb5, 0x70,
0x31, 0xcf, 0x38, 0xbe, 0x71, 0x48, 0x5a, 0x9c, 0xe4, 0x62, 0x43, 0x33, 0x0b, 0xaa, 0xf2, 0x50,
0xf4, 0x71, 0x6c, 0xa2, 0x25, 0x32, 0xba, 0x90, 0xa0, 0x16, 0x77, 0x7d, 0x0e, 0x0e, 0xfd, 0x10,
0x4a, 0xee, 0x5e, 0x82, 0x1b, 0x3c, 0x23, 0xbb, 0x28, 0x22, 0x9d, 0x9a, 0x39, 0xc8, 0xf9, 0xb3,
0xdc, 0xb5, 0x46, 0xf8, 0xba, 0xf0, 0x2c, 0x7b, 0x44, 0xce, 0xce, 0x4f, 0xa0, 0x2c, 0x4b, 0xf3,
0x85, 0x9b, 0x0b, 0xcb, 0x8f, 0x49, 0x1f, 0xe7, 0x41, 0xc3, 0x02, 0x82, 0xb7, 0x86, 0xef, 0x92,
0xfd, 0xd6, 0x58, 0x66, 0xf3, 0xcf, 0xc1, 0x84, 0x12, 0x0e, 0x49, 0xe4, 0x4c, 0x49, 0x1f, 0xfe,
0x94, 0xd4, 0x71, 0xad, 0xa6, 0xe4, 0xc5, 0xc3, 0x2a, 0x3e, 0xc1, 0xaf, 0xc1, 0xe8, 0x92, 0x7c,
0x4b, 0x25, 0x16, 0x87, 0x53, 0x53, 0xed, 0xe8, 0x4d, 0x2e, 0x54, 0xa7, 0xb0, 0xf3, 0x60, 0x8f,
0xdc, 0x2f, 0xa4, 0xff, 0x1d, 0x96, 0x93, 0x40, 0xb2, 0x2b, 0xb3, 0x69, 0x23, 0xce, 0xf5, 0xf8,
0xf8, 0xad, 0xcc, 0x0c, 0xf8, 0x4d, 0x45, 0x03, 0x29, 0xc7, 0xce, 0xdd, 0x7f, 0x3d, 0xe4, 0x9c,
0x8e, 0xb1, 0x2f, 0x1c, 0xa4, 0x66, 0x72, 0x42, 0xf0, 0x47, 0xe0, 0x0c, 0x38, 0x67, 0x87, 0x34,
0xd8, 0x09, 0x9e, 0xe5, 0x7f, 0x8d, 0x29, 0x9f, 0xb8, 0xc3, 0x91, 0x81, 0x02, 0x47, 0xc9, 0x23,
0xe9, 0x4e, 0xd8, 0x4a, 0x2a, 0x99, 0xa3, 0xa4, 0x01, 0xc0, 0x0d, 0x8a, 0x1e, 0x0a, 0x47, 0xd7,
0xb2, 0x3e, 0x1e, 0x33, 0x20, 0xa3, 0x2d, 0x29, 0x9c, 0x6c, 0xcb, 0xf5, 0x3f, 0x1f, 0xfe, 0x1e,
0xeb, 0x62, 0x32, 0x1d, 0xba, 0xd6, 0x2d, 0x9f, 0x3c, 0xd3, 0x59, 0xf0, 0xab, 0x25, 0xbb, 0xd1,
0xf2, 0x94, 0x5a, 0x61, 0x83, 0xed, 0xe1, 0x70, 0xdd, 0xfb, 0xeb, 0xf2, 0x7b, 0x00, 0x00, 0x00,
0xff, 0xff, 0x27, 0xad, 0x32, 0xbe, 0xa6, 0x0c, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -339,6 +341,9 @@ type RootCoordClient interface {
//
// @return CollectionSchema
DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error)
CreateAlias(ctx context.Context, in *milvuspb.CreateAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
DropAlias(ctx context.Context, in *milvuspb.DropAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
AlterAlias(ctx context.Context, in *milvuspb.AlterAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
//*
// @brief This method is used to list all collections.
//
@ -451,6 +456,33 @@ func (c *rootCoordClient) DescribeCollection(ctx context.Context, in *milvuspb.D
return out, nil
}
func (c *rootCoordClient) CreateAlias(ctx context.Context, in *milvuspb.CreateAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/CreateAlias", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *rootCoordClient) DropAlias(ctx context.Context, in *milvuspb.DropAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/DropAlias", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *rootCoordClient) AlterAlias(ctx context.Context, in *milvuspb.AlterAliasRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/AlterAlias", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *rootCoordClient) ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowCollectionsResponse, error) {
out := new(milvuspb.ShowCollectionsResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/ShowCollections", in, out, opts...)
@ -628,6 +660,9 @@ type RootCoordServer interface {
//
// @return CollectionSchema
DescribeCollection(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
CreateAlias(context.Context, *milvuspb.CreateAliasRequest) (*commonpb.Status, error)
DropAlias(context.Context, *milvuspb.DropAliasRequest) (*commonpb.Status, error)
AlterAlias(context.Context, *milvuspb.AlterAliasRequest) (*commonpb.Status, error)
//*
// @brief This method is used to list all collections.
//
@ -694,6 +729,15 @@ func (*UnimplementedRootCoordServer) HasCollection(ctx context.Context, req *mil
func (*UnimplementedRootCoordServer) DescribeCollection(ctx context.Context, req *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DescribeCollection not implemented")
}
func (*UnimplementedRootCoordServer) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateAlias not implemented")
}
func (*UnimplementedRootCoordServer) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method DropAlias not implemented")
}
func (*UnimplementedRootCoordServer) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method AlterAlias not implemented")
}
func (*UnimplementedRootCoordServer) ShowCollections(ctx context.Context, req *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ShowCollections not implemented")
}
@ -873,6 +917,60 @@ func _RootCoord_DescribeCollection_Handler(srv interface{}, ctx context.Context,
return interceptor(ctx, in, info, handler)
}
func _RootCoord_CreateAlias_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.CreateAliasRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).CreateAlias(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/CreateAlias",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).CreateAlias(ctx, req.(*milvuspb.CreateAliasRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RootCoord_DropAlias_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.DropAliasRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).DropAlias(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/DropAlias",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).DropAlias(ctx, req.(*milvuspb.DropAliasRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RootCoord_AlterAlias_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.AlterAliasRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).AlterAlias(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/AlterAlias",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).AlterAlias(ctx, req.(*milvuspb.AlterAliasRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RootCoord_ShowCollections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.ShowCollectionsRequest)
if err := dec(in); err != nil {
@ -1193,6 +1291,18 @@ var _RootCoord_serviceDesc = grpc.ServiceDesc{
MethodName: "DescribeCollection",
Handler: _RootCoord_DescribeCollection_Handler,
},
{
MethodName: "CreateAlias",
Handler: _RootCoord_CreateAlias_Handler,
},
{
MethodName: "DropAlias",
Handler: _RootCoord_DropAlias_Handler,
},
{
MethodName: "AlterAlias",
Handler: _RootCoord_AlterAlias_Handler,
},
{
MethodName: "ShowCollections",
Handler: _RootCoord_ShowCollections_Handler,

136
internal/proxy/impl.go
View File

@ -1630,6 +1630,142 @@ func (node *Proxy) Query(ctx context.Context, request *milvuspb.QueryRequest) (*
}, nil
}
func (node *Proxy) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
return unhealthyStatus(), nil
}
cat := &CreateAliasTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
CreateAliasRequest: request,
rootCoord: node.rootCoord,
}
err := node.sched.ddQueue.Enqueue(cat)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug("CreateAlias",
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias),
zap.String("collection", request.CollectionName))
defer func() {
log.Debug("CreateAlias Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias),
zap.String("collection", request.CollectionName))
}()
err = cat.WaitToFinish()
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
return cat.result, nil
}
func (node *Proxy) DropAlias(ctx context.Context, request *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
return unhealthyStatus(), nil
}
dat := &DropAliasTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
DropAliasRequest: request,
rootCoord: node.rootCoord,
}
err := node.sched.ddQueue.Enqueue(dat)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug("DropAlias",
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias))
defer func() {
log.Debug("DropAlias Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias))
}()
err = dat.WaitToFinish()
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
return dat.result, nil
}
func (node *Proxy) AlterAlias(ctx context.Context, request *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
return unhealthyStatus(), nil
}
aat := &AlterAliasTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
AlterAliasRequest: request,
rootCoord: node.rootCoord,
}
err := node.sched.ddQueue.Enqueue(aat)
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug("AlterAlias",
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias),
zap.String("collection", request.CollectionName))
defer func() {
log.Debug("AlterAlias Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", request.Base.MsgID),
zap.Uint64("timestamp", request.Base.Timestamp),
zap.String("alias", request.Alias),
zap.String("collection", request.CollectionName))
}()
err = aat.WaitToFinish()
if err != nil {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
return aat.result, nil
}
func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error) {
param, _ := GetAttrByKeyFromRepeatedKV("metric", request.GetParams())
metric, err := distance.ValidateMetricType(param)

75
internal/proxy/proxy_test.go
View File

@ -2035,5 +2035,80 @@ func TestProxy(t *testing.T) {
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
})
t.Run("create alias", func(t *testing.T) {
req := createCollectionReq
resp, err := proxy.CreateCollection(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.ErrorCode)
// create alias
aliasReq := &milvuspb.CreateAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias",
}
resp, err = proxy.CreateAlias(ctx, aliasReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.ErrorCode)
sameAliasReq := &milvuspb.CreateAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias",
}
resp, err = proxy.CreateAlias(ctx, sameAliasReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.ErrorCode)
})
t.Run("alter alias", func(t *testing.T) {
// alter alias
alterReq := &milvuspb.AlterAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias",
}
resp, err := proxy.AlterAlias(ctx, alterReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.ErrorCode)
nonExistingCollName := "coll_name_random_zarathustra"
faultyAlterReq := &milvuspb.AlterAliasRequest{
Base: nil,
CollectionName: nonExistingCollName,
Alias: "alias",
}
resp, err = proxy.AlterAlias(ctx, faultyAlterReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.ErrorCode)
})
t.Run("drop alias", func(t *testing.T) {
// drop alias
resp, err := proxy.DropAlias(ctx, &milvuspb.DropAliasRequest{
Base: nil,
Alias: "alias",
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.ErrorCode)
sameDropReq := &milvuspb.DropAliasRequest{
Base: nil,
Alias: "alias",
}
// Can't drop non-existing alias
resp, err = proxy.DropAlias(ctx, sameDropReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.ErrorCode)
dropReq := &milvuspb.DropCollectionRequest{
DbName: dbName,
CollectionName: collectionName,
}
resp, err = proxy.DropCollection(ctx, dropReq)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.ErrorCode)
})
cancel()
}

99
internal/proxy/rootcoord_mock_test.go
View File

@ -80,9 +80,10 @@ type RootCoordMock struct {
timeTickChannel string
// naive inverted index
collName2ID map[string]typeutil.UniqueID
collID2Meta map[typeutil.UniqueID]collectionMeta
collMtx sync.RWMutex
collName2ID map[string]typeutil.UniqueID
collID2Meta map[typeutil.UniqueID]collectionMeta
collAlias2ID map[string]typeutil.UniqueID
collMtx sync.RWMutex
// TODO(dragondriver): need default partition?
collID2Partitions map[typeutil.UniqueID]partitionMap
@ -102,6 +103,98 @@ type RootCoordMock struct {
lastTsMtx sync.Mutex
}
func (coord *RootCoordMock) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
defer coord.collMtx.Unlock()
_, exist := coord.collAlias2ID[req.Alias]
if exist {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("duplicate collection alias, alias = %s", req.Alias),
}, nil
}
collID, exist := coord.collName2ID[req.CollectionName]
if !exist {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("aliased collection name does not exist, name = %s", req.CollectionName),
}, nil
}
coord.collAlias2ID[req.Alias] = collID
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}
func (coord *RootCoordMock) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
defer coord.collMtx.Unlock()
_, exist := coord.collAlias2ID[req.Alias]
if !exist {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("alias does not exist, alias = %s", req.Alias),
}, nil
}
delete(coord.collAlias2ID, req.Alias)
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}
func (coord *RootCoordMock) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
defer coord.collMtx.Unlock()
_, exist := coord.collAlias2ID[req.Alias]
if !exist {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_CollectionNotExists,
Reason: fmt.Sprintf("alias does not exist, alias = %s", req.Alias),
}, nil
}
collID, exist := coord.collName2ID[req.CollectionName]
if !exist {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_CollectionNotExists,
Reason: fmt.Sprintf("aliased collection name does not exist, name = %s", req.CollectionName),
}, nil
}
coord.collAlias2ID[req.Alias] = collID
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}
func (coord *RootCoordMock) updateState(state internalpb.StateCode) {
coord.state.Store(state)
}

213
internal/proxy/task.go
View File

@ -80,6 +80,9 @@ const (
LoadPartitionTaskName = "LoadPartitionsTask"
ReleasePartitionTaskName = "ReleasePartitionsTask"
deleteTaskName = "DeleteTask"
CreateAliasTaskName = "CreateAliasTask"
DropAliasTaskName = "DropAliasTask"
AlterAliasTaskName = "AlterAliasTask"
)
type task interface {
@ -4632,3 +4635,213 @@ func (dt *deleteTask) Execute(ctx context.Context) (err error) {
func (dt *deleteTask) PostExecute(ctx context.Context) error {
return nil
}
type CreateAliasTask struct {
Condition
*milvuspb.CreateAliasRequest
ctx context.Context
rootCoord types.RootCoord
result *commonpb.Status
}
func (c *CreateAliasTask) TraceCtx() context.Context {
return c.ctx
}
func (c *CreateAliasTask) ID() UniqueID {
return c.Base.MsgID
}
func (c *CreateAliasTask) SetID(uid UniqueID) {
c.Base.MsgID = uid
}
func (c *CreateAliasTask) Name() string {
return CreateAliasTaskName
}
func (c *CreateAliasTask) Type() commonpb.MsgType {
return c.Base.MsgType
}
func (c *CreateAliasTask) BeginTs() Timestamp {
return c.Base.Timestamp
}
func (c *CreateAliasTask) EndTs() Timestamp {
return c.Base.Timestamp
}
func (c *CreateAliasTask) SetTs(ts Timestamp) {
c.Base.Timestamp = ts
}
func (c *CreateAliasTask) OnEnqueue() error {
c.Base = &commonpb.MsgBase{}
return nil
}
func (c *CreateAliasTask) PreExecute(ctx context.Context) error {
c.Base.MsgType = commonpb.MsgType_CreateAlias
c.Base.SourceID = Params.ProxyID
collAlias := c.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := c.CollectionName
if err := ValidateCollectionName(collName); err != nil {
return err
}
return nil
}
func (c *CreateAliasTask) Execute(ctx context.Context) error {
var err error
c.result, err = c.rootCoord.CreateAlias(ctx, c.CreateAliasRequest)
return err
}
func (c *CreateAliasTask) PostExecute(ctx context.Context) error {
return nil
}
type DropAliasTask struct {
Condition
*milvuspb.DropAliasRequest
ctx context.Context
rootCoord types.RootCoord
result *commonpb.Status
}
func (d *DropAliasTask) TraceCtx() context.Context {
return d.ctx
}
func (d *DropAliasTask) ID() UniqueID {
return d.Base.MsgID
}
func (d *DropAliasTask) SetID(uid UniqueID) {
d.Base.MsgID = uid
}
func (d *DropAliasTask) Name() string {
return DropAliasTaskName
}
func (d *DropAliasTask) Type() commonpb.MsgType {
return d.Base.MsgType
}
func (d *DropAliasTask) BeginTs() Timestamp {
return d.Base.Timestamp
}
func (d *DropAliasTask) EndTs() Timestamp {
return d.Base.Timestamp
}
func (d *DropAliasTask) SetTs(ts Timestamp) {
d.Base.Timestamp = ts
}
func (d *DropAliasTask) OnEnqueue() error {
d.Base = &commonpb.MsgBase{}
return nil
}
func (d *DropAliasTask) PreExecute(ctx context.Context) error {
d.Base.MsgType = commonpb.MsgType_DropAlias
d.Base.SourceID = Params.ProxyID
collAlias := d.Alias
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
return nil
}
func (d *DropAliasTask) Execute(ctx context.Context) error {
var err error
d.result, err = d.rootCoord.DropAlias(ctx, d.DropAliasRequest)
return err
}
func (d *DropAliasTask) PostExecute(ctx context.Context) error {
return nil
}
type AlterAliasTask struct {
Condition
*milvuspb.AlterAliasRequest
ctx context.Context
rootCoord types.RootCoord
result *commonpb.Status
}
func (a *AlterAliasTask) TraceCtx() context.Context {
return a.ctx
}
func (a *AlterAliasTask) ID() UniqueID {
return a.Base.MsgID
}
func (a *AlterAliasTask) SetID(uid UniqueID) {
a.Base.MsgID = uid
}
func (a *AlterAliasTask) Name() string {
return AlterAliasTaskName
}
func (a *AlterAliasTask) Type() commonpb.MsgType {
return a.Base.MsgType
}
func (a *AlterAliasTask) BeginTs() Timestamp {
return a.Base.Timestamp
}
func (a *AlterAliasTask) EndTs() Timestamp {
return a.Base.Timestamp
}
func (a *AlterAliasTask) SetTs(ts Timestamp) {
a.Base.Timestamp = ts
}
func (a *AlterAliasTask) OnEnqueue() error {
a.Base = &commonpb.MsgBase{}
return nil
}
func (a *AlterAliasTask) PreExecute(ctx context.Context) error {
a.Base.MsgType = commonpb.MsgType_AlterAlias
a.Base.SourceID = Params.ProxyID
collAlias := a.Alias
// collection alias uses the same format as collection name
if err := ValidateCollectionAlias(collAlias); err != nil {
return err
}
collName := a.CollectionName
if err := ValidateCollectionName(collName); err != nil {
return err
}
return nil
}
func (a *AlterAliasTask) Execute(ctx context.Context) error {
var err error
a.result, err = a.rootCoord.AlterAlias(ctx, a.AlterAliasRequest)
return err
}
func (a *AlterAliasTask) PostExecute(ctx context.Context) error {
return nil
}

123
internal/proxy/task_test.go
View File

@ -3077,3 +3077,126 @@ func TestDeleteTask_PreExecute(t *testing.T) {
assert.Error(t, task.PreExecute(ctx))
task.DeleteRequest.PartitionName = partitionName
}
func TestCreateAlias_all(t *testing.T) {
Params.Init()
rc := NewRootCoordMock()
rc.Start()
defer rc.Stop()
ctx := context.Background()
prefix := "TestCreateAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &CreateAliasTask{
Condition: NewTaskCondition(ctx),
CreateAliasRequest: &milvuspb.CreateAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_CreateAlias
assert.Equal(t, commonpb.MsgType_CreateAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestDropAlias_all(t *testing.T) {
Params.Init()
rc := NewRootCoordMock()
rc.Start()
defer rc.Stop()
ctx := context.Background()
task := &DropAliasTask{
Condition: NewTaskCondition(ctx),
DropAliasRequest: &milvuspb.DropAliasRequest{
Base: nil,
Alias: "alias1",
},
ctx: ctx,
result: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_DropAlias
assert.Equal(t, commonpb.MsgType_DropAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}
func TestAlterAlias_all(t *testing.T) {
Params.Init()
rc := NewRootCoordMock()
rc.Start()
defer rc.Stop()
ctx := context.Background()
prefix := "TestAlterAlias_all"
collectionName := prefix + funcutil.GenRandomStr()
task := &AlterAliasTask{
Condition: NewTaskCondition(ctx),
AlterAliasRequest: &milvuspb.AlterAliasRequest{
Base: nil,
CollectionName: collectionName,
Alias: "alias1",
},
ctx: ctx,
result: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
rootCoord: rc,
}
assert.NoError(t, task.OnEnqueue())
assert.NotNil(t, task.TraceCtx())
id := UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt())
task.SetID(id)
assert.Equal(t, id, task.ID())
task.Base.MsgType = commonpb.MsgType_AlterAlias
assert.Equal(t, commonpb.MsgType_AlterAlias, task.Type())
ts := Timestamp(time.Now().UnixNano())
task.SetTs(ts)
assert.Equal(t, ts, task.BeginTs())
assert.Equal(t, ts, task.EndTs())
assert.NoError(t, task.PreExecute(ctx))
assert.NoError(t, task.Execute(ctx))
assert.NoError(t, task.PostExecute(ctx))
}

32
internal/proxy/validate_util.go
View File

@ -35,36 +35,44 @@ func isNumber(c uint8) bool {
return true
}
func ValidateCollectionName(collName string) error {
collName = strings.TrimSpace(collName)
func validateCollectionNameOrAlias(entity, entityType string) error {
entity = strings.TrimSpace(entity)
if collName == "" {
return errors.New("Collection name should not be empty")
if entity == "" {
return fmt.Errorf("Collection %s should not be empty", entityType)
}
invalidMsg := "Invalid collection name: " + collName + ". "
if int64(len(collName)) > Params.MaxNameLength {
msg := invalidMsg + "The length of a collection name must be less than " +
invalidMsg := fmt.Sprintf("Invalid collection %s: %s. ", entityType, entity)
if int64(len(entity)) > Params.MaxNameLength {
msg := invalidMsg + fmt.Sprintf("The length of a collection %s must be less than ", entityType) +
strconv.FormatInt(Params.MaxNameLength, 10) + " characters."
return errors.New(msg)
}
firstChar := collName[0]
firstChar := entity[0]
if firstChar != '_' && !isAlpha(firstChar) {
msg := invalidMsg + "The first character of a collection name must be an underscore or letter."
msg := invalidMsg + fmt.Sprintf("The first character of a collection %s must be an underscore or letter.", entityType)
return errors.New(msg)
}
for i := 1; i < len(collName); i++ {
c := collName[i]
for i := 1; i < len(entity); i++ {
c := entity[i]
if c != '_' && c != '$' && !isAlpha(c) && !isNumber(c) {
msg := invalidMsg + "Collection name can only contain numbers, letters, dollars and underscores."
msg := invalidMsg + fmt.Sprintf("Collection %s can only contain numbers, letters, dollars and underscores.", entityType)
return errors.New(msg)
}
}
return nil
}
func ValidateCollectionAlias(collAlias string) error {
return validateCollectionNameOrAlias(collAlias, "alias")
}
func ValidateCollectionName(collName string) error {
return validateCollectionNameOrAlias(collName, "name")
}
func ValidatePartitionTag(partitionTag string, strictCheck bool) error {
partitionTag = strings.TrimSpace(partitionTag)

2
internal/proxy/validate_util_test.go
View File

@ -40,6 +40,8 @@ func TestValidateCollectionName(t *testing.T) {
for _, name := range invalidNames {
assert.NotNil(t, ValidateCollectionName(name))
assert.NotNil(t, validateCollectionNameOrAlias(name, "name"))
assert.NotNil(t, validateCollectionNameOrAlias(name, "alias"))
}
}

12
internal/querynode/mock_components_test.go
View File

@ -31,6 +31,18 @@ type mockRootCoord struct {
returnError bool // TODO: add error tests
}
func (m *mockRootCoord) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoord) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoord) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}
func newMockRootCoord() *mockRootCoord {
return &mockRootCoord{
state: internalpb.StateCode_Healthy,

134
internal/rootcoord/meta_table.go
View File

@ -29,12 +29,13 @@ import (
)
const (
ComponentPrefix = "root-coord"
TenantMetaPrefix = ComponentPrefix + "/tenant"
ProxyMetaPrefix = ComponentPrefix + "/proxy"
CollectionMetaPrefix = ComponentPrefix + "/collection"
SegmentIndexMetaPrefix = ComponentPrefix + "/segment-index"
IndexMetaPrefix = ComponentPrefix + "/index"
ComponentPrefix = "root-coord"
TenantMetaPrefix = ComponentPrefix + "/tenant"
ProxyMetaPrefix = ComponentPrefix + "/proxy"
CollectionMetaPrefix = ComponentPrefix + "/collection"
SegmentIndexMetaPrefix = ComponentPrefix + "/segment-index"
IndexMetaPrefix = ComponentPrefix + "/index"
CollectionAliasMetaPrefix = ComponentPrefix + "/collection-alias"
TimestampPrefix = ComponentPrefix + "/timestamp"
@ -45,6 +46,9 @@ const (
DropCollectionDDType = "DropCollection"
CreatePartitionDDType = "CreatePartition"
DropPartitionDDType = "DropPartition"
CreateAliasDDType = "CreateAlias"
DropAliasDDType = "DropAlias"
AlterAliasDDType = "AlterAlias"
)
type metaTable struct {
@ -53,6 +57,7 @@ type metaTable struct {
proxyID2Meta map[typeutil.UniqueID]pb.ProxyMeta // proxy id to proxy meta
collID2Meta map[typeutil.UniqueID]pb.CollectionInfo // collection_id -> meta
collName2ID map[string]typeutil.UniqueID // collection name to collection id
collAlias2ID map[string]typeutil.UniqueID // collection alias to collection id
partID2SegID map[typeutil.UniqueID]map[typeutil.UniqueID]bool // partition_id -> segment_id -> bool
segID2IndexMeta map[typeutil.UniqueID]map[typeutil.UniqueID]pb.SegmentIndexInfo // collection_id/index_id/partition_id/segment_id -> meta
indexID2Meta map[typeutil.UniqueID]pb.IndexInfo // collection_id/index_id -> meta
@ -82,6 +87,7 @@ func (mt *metaTable) reloadFromKV() error {
mt.proxyID2Meta = make(map[typeutil.UniqueID]pb.ProxyMeta)
mt.collID2Meta = make(map[typeutil.UniqueID]pb.CollectionInfo)
mt.collName2ID = make(map[string]typeutil.UniqueID)
mt.collAlias2ID = make(map[string]typeutil.UniqueID)
mt.partID2SegID = make(map[typeutil.UniqueID]map[typeutil.UniqueID]bool)
mt.segID2IndexMeta = make(map[typeutil.UniqueID]map[typeutil.UniqueID]pb.SegmentIndexInfo)
mt.indexID2Meta = make(map[typeutil.UniqueID]pb.IndexInfo)
@ -174,6 +180,19 @@ func (mt *metaTable) reloadFromKV() error {
mt.indexID2Meta[meta.IndexID] = meta
}
_, values, err = mt.client.LoadWithPrefix(CollectionAliasMetaPrefix, 0)
if err != nil {
return err
}
for _, value := range values {
aliasInfo := pb.CollectionInfo{}
err = proto.UnmarshalText(value, &aliasInfo)
if err != nil {
return fmt.Errorf("RootCoord UnmarshalText pb.AliasInfo err:%w", err)
}
mt.collAlias2ID[aliasInfo.Schema.Name] = aliasInfo.ID
}
log.Debug("reload meta table from KV successfully")
return nil
}
@ -310,6 +329,13 @@ func (mt *metaTable) DeleteCollection(collID typeutil.UniqueID, ts typeutil.Time
}
delete(mt.indexID2Meta, idxInfo.IndexID)
}
var aliases []string
// delete collection aliases
for alias, cid := range mt.collAlias2ID {
if cid == collID {
aliases = append(aliases, alias)
}
}
delMetakeys := []string{
fmt.Sprintf("%s/%d", CollectionMetaPrefix, collID),
@ -317,6 +343,13 @@ func (mt *metaTable) DeleteCollection(collID typeutil.UniqueID, ts typeutil.Time
fmt.Sprintf("%s/%d", IndexMetaPrefix, collID),
}
for _, alias := range aliases {
delete(mt.collAlias2ID, alias)
delMetakeys = append(delMetakeys,
fmt.Sprintf("%s/%s", CollectionAliasMetaPrefix, alias),
)
}
// save ddOpStr into etcd
var saveMeta = map[string]string{}
addition := mt.getAdditionKV(ddOpStr, saveMeta)
@ -373,7 +406,9 @@ func (mt *metaTable) GetCollectionByName(collectionName string, ts typeutil.Time
if ts == 0 {
vid, ok := mt.collName2ID[collectionName]
if !ok {
return nil, fmt.Errorf("can't find collection: " + collectionName)
if vid, ok = mt.collAlias2ID[collectionName]; !ok {
return nil, fmt.Errorf("can't find collection: " + collectionName)
}
}
col, ok := mt.collID2Meta[vid]
if !ok {
@ -1046,3 +1081,88 @@ func (mt *metaTable) dupMeta() (
}
return collID2Meta, segID2IndexMeta, indexID2Meta
}
func (mt *metaTable) AddAlias(collectionAlias string, collectionName string,
ts typeutil.Timestamp, ddOpStr func(ts typeutil.Timestamp) (string, error)) error {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if _, ok := mt.collAlias2ID[collectionAlias]; ok {
return fmt.Errorf("duplicate collection alias, alias = %s", collectionAlias)
}
if _, ok := mt.collName2ID[collectionAlias]; ok {
return fmt.Errorf("collection alias collides with existing collection name. collection = %s, alias = %s", collectionAlias, collectionAlias)
}
id, ok := mt.collName2ID[collectionName]
if !ok {
return fmt.Errorf("aliased collection name does not exist, name = %s", collectionName)
}
mt.collAlias2ID[collectionAlias] = id
meta := make(map[string]string)
addition := mt.getAdditionKV(ddOpStr, meta)
saveAlias := func(ts typeutil.Timestamp) (string, string, error) {
k1 := fmt.Sprintf("%s/%s", CollectionAliasMetaPrefix, collectionAlias)
v1 := proto.MarshalTextString(&pb.CollectionInfo{ID: id, Schema: &schemapb.CollectionSchema{Name: collectionAlias}})
meta[k1] = v1
return k1, v1, nil
}
err := mt.client.MultiSave(meta, ts, addition, saveAlias)
if err != nil {
log.Error("SnapShotKV MultiSave fail", zap.Error(err))
panic("SnapShotKV MultiSave fail")
}
return nil
}
func (mt *metaTable) DeleteAlias(collectionAlias string, ts typeutil.Timestamp, ddOpStr func(ts typeutil.Timestamp) (string, error)) error {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if _, ok := mt.collAlias2ID[collectionAlias]; !ok {
return fmt.Errorf("alias does not exist, alias = %s", collectionAlias)
}
delete(mt.collAlias2ID, collectionAlias)
delMetakeys := []string{
fmt.Sprintf("%s/%s", CollectionAliasMetaPrefix, collectionAlias),
}
meta := make(map[string]string)
addition := mt.getAdditionKV(ddOpStr, meta)
err := mt.client.MultiSaveAndRemoveWithPrefix(meta, delMetakeys, ts, addition)
if err != nil {
log.Error("SnapShotKV MultiSave fail", zap.Error(err))
panic("SnapShotKV MultiSave fail")
}
return nil
}
func (mt *metaTable) AlterAlias(collectionAlias string, collectionName string, ts typeutil.Timestamp, ddOpStr func(ts typeutil.Timestamp) (string, error)) error {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if _, ok := mt.collAlias2ID[collectionAlias]; !ok {
return fmt.Errorf("alias does not exist, alias = %s", collectionAlias)
}
id, ok := mt.collName2ID[collectionName]
if !ok {
return fmt.Errorf("aliased collection name does not exist, name = %s", collectionName)
}
mt.collAlias2ID[collectionAlias] = id
meta := make(map[string]string)
addition := mt.getAdditionKV(ddOpStr, meta)
alterAlias := func(ts typeutil.Timestamp) (string, string, error) {
k1 := fmt.Sprintf("%s/%s", CollectionAliasMetaPrefix, collectionAlias)
v1 := proto.MarshalTextString(&pb.CollectionInfo{ID: id, Schema: &schemapb.CollectionSchema{Name: collectionAlias}})
meta[k1] = v1
return k1, v1, nil
}
err := mt.client.MultiSave(meta, ts, addition, alterAlias)
if err != nil {
log.Error("SnapShotKV MultiSave fail", zap.Error(err))
panic("SnapShotKV MultiSave fail")
}
return nil
}

30
internal/rootcoord/meta_table_test.go
View File

@ -116,7 +116,9 @@ func Test_MockKV(t *testing.T) {
prefix[IndexMetaPrefix] = []string{proto.MarshalTextString(&pb.IndexInfo{})}
m1, err := NewMetaTable(k1)
assert.Nil(t, err)
assert.NotNil(t, err)
assert.EqualError(t, err, "load prefix error")
prefix[CollectionAliasMetaPrefix] = []string{"alias-meta"}
k1.save = func(key string, value string, ts typeutil.Timestamp) error {
return fmt.Errorf("save tenant error")
@ -269,11 +271,29 @@ func TestMetaTable(t *testing.T) {
assert.Equal(t, "false", flag)
})
t.Run("add alias", func(t *testing.T) {
ts := ftso()
err = mt.AddAlias("alias1", "testColl", ts, ddOp)
assert.Nil(t, err)
})
t.Run("alter alias", func(t *testing.T) {
ts := ftso()
err = mt.AlterAlias("alias1", "testColl", ts, ddOp)
assert.Nil(t, err)
})
t.Run("delete alias", func(t *testing.T) {
ts := ftso()
err = mt.DeleteAlias("alias1", ts, ddOp)
assert.Nil(t, err)
})
t.Run("add partition", func(t *testing.T) {
ts := ftso()
err = mt.AddPartition(collID, partName, partID, ts, ddOp)
assert.Nil(t, err)
assert.Equal(t, ts, uint64(2))
//assert.Equal(t, ts, uint64(2))
collMeta, ok := mt.collID2Meta[collID]
assert.True(t, ok)
@ -441,8 +461,14 @@ func TestMetaTable(t *testing.T) {
ts := ftso()
err = mt.DeleteCollection(collIDInvalid, ts, nil)
assert.NotNil(t, err)
ts2 := ftso()
err = mt.AddAlias("alias1", "testColl", ts2, ddOp)
assert.Nil(t, err)
err = mt.DeleteCollection(collID, ts, nil)
assert.Nil(t, err)
ts3 := ftso()
err = mt.DeleteAlias("alias1", ts3, ddOp)
assert.NotNil(t, err)
// check DD operation flag
flag, err := mt.client.Load(DDMsgSendPrefix, 0)

93
internal/rootcoord/root_coord.go
View File

@ -2003,3 +2003,96 @@ func (c *Core) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest)
Response: "",
}, nil
}
func (c *Core) CreateAlias(ctx context.Context, in *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
code := c.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
log.Debug("CreateAlias ", zap.String("alias", in.Alias), zap.String("name", in.CollectionName))
t := &CreateAliasReqTask{
baseReqTask: baseReqTask{
ctx: ctx,
core: c,
},
Req: in,
}
err := executeTask(t)
if err != nil {
log.Debug("CreateAlias failed", zap.String("alias", in.Alias), zap.String("name", in.CollectionName), zap.Error(err))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "Create alias failed: " + err.Error(),
}, nil
}
log.Debug("CreateAlias Success", zap.String("alias", in.Alias), zap.String("name", in.CollectionName))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}
func (c *Core) DropAlias(ctx context.Context, in *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
code := c.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
log.Debug("DropAlias ", zap.String("alias", in.Alias))
t := &DropAliasReqTask{
baseReqTask: baseReqTask{
ctx: ctx,
core: c,
},
Req: in,
}
err := executeTask(t)
if err != nil {
log.Debug("DropAlias failed", zap.String("alias", in.Alias), zap.Error(err))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "Drop alias failed: " + err.Error(),
}, nil
}
log.Debug("DropAlias Success", zap.String("alias", in.Alias))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}
func (c *Core) AlterAlias(ctx context.Context, in *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
code := c.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
}, nil
}
log.Debug("AlterAlias ", zap.String("alias", in.Alias), zap.String("name", in.CollectionName))
t := &AlterAliasReqTask{
baseReqTask: baseReqTask{
ctx: ctx,
core: c,
},
Req: in,
}
err := executeTask(t)
if err != nil {
log.Debug("AlterAlias failed", zap.String("alias", in.Alias), zap.String("name", in.CollectionName), zap.Error(err))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "Alter alias failed: " + err.Error(),
}, nil
}
log.Debug("AlterAlias Success", zap.String("alias", in.Alias), zap.String("name", in.CollectionName))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
}, nil
}

125
internal/rootcoord/root_coord_test.go
View File

@ -505,10 +505,12 @@ func TestRootCoordInit(t *testing.T) {
func TestRootCoord(t *testing.T) {
const (
dbName = "testDb"
collName = "testColl"
partName = "testPartition"
segID = 1001
dbName = "testDb"
collName = "testColl"
collName2 = "testColl2"
aliasName = "alias1"
partName = "testPartition"
segID = 1001
)
ctx, cancel := context.WithCancel(context.Background())
@ -1775,6 +1777,120 @@ func TestRootCoord(t *testing.T) {
assert.Nil(t, err)
})
schema := schemapb.CollectionSchema{
Name: collName,
}
sbf, err := proto.Marshal(&schema)
assert.Nil(t, err)
req := &milvuspb.CreateCollectionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_CreateCollection,
MsgID: 3011,
Timestamp: 3011,
SourceID: 3011,
},
DbName: dbName,
CollectionName: collName,
Schema: sbf,
}
status, err := core.CreateCollection(ctx, req)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
t.Run("create alias", func(t *testing.T) {
req := &milvuspb.CreateAliasRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_CreateAlias,
MsgID: 3012,
Timestamp: 3012,
SourceID: 3012,
},
CollectionName: collName,
Alias: aliasName,
}
rsp, err := core.CreateAlias(ctx, req)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.ErrorCode)
})
// temporarily create collName2
schema = schemapb.CollectionSchema{
Name: collName2,
}
sbf, err = proto.Marshal(&schema)
assert.Nil(t, err)
req2 := &milvuspb.CreateCollectionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_CreateCollection,
MsgID: 3013,
Timestamp: 3013,
SourceID: 3013,
},
DbName: dbName,
CollectionName: collName2,
Schema: sbf,
}
status, err = core.CreateCollection(ctx, req2)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
t.Run("alter alias", func(t *testing.T) {
req := &milvuspb.AlterAliasRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_AlterAlias,
MsgID: 3014,
Timestamp: 3014,
SourceID: 3014,
},
CollectionName: collName2,
Alias: aliasName,
}
rsp, err := core.AlterAlias(ctx, req)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.ErrorCode)
})
t.Run("drop alias", func(t *testing.T) {
req := &milvuspb.DropAliasRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_DropAlias,
MsgID: 3015,
Timestamp: 3015,
SourceID: 3015,
},
Alias: aliasName,
}
rsp, err := core.DropAlias(ctx, req)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.ErrorCode)
})
status, err = core.DropCollection(ctx, &milvuspb.DropCollectionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_DropCollection,
MsgID: 3016,
Timestamp: 3016,
SourceID: 3016,
},
DbName: dbName,
CollectionName: collName,
})
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
status, err = core.DropCollection(ctx, &milvuspb.DropCollectionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_DropCollection,
MsgID: 3017,
Timestamp: 3017,
SourceID: 3017,
},
DbName: dbName,
CollectionName: collName2,
})
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
t.Run("get metrics", func(t *testing.T) {
// not healthy
stateSave := core.stateCode.Load().(internalpb.StateCode)
@ -2021,6 +2137,7 @@ func TestRootCoord(t *testing.T) {
})
err = core.Stop()
assert.Nil(t, err)
}
func TestRootCoord2(t *testing.T) {

200
internal/rootcoord/task.go
View File

@ -889,3 +889,203 @@ func (t *DropIndexReqTask) Execute(ctx context.Context) error {
_, _, err = t.core.MetaTable.DropIndex(t.Req.CollectionName, t.Req.FieldName, t.Req.IndexName, ts)
return err
}
type CreateAliasReqTask struct {
baseReqTask
Req *milvuspb.CreateAliasRequest
}
func (t *CreateAliasReqTask) Type() commonpb.MsgType {
return t.Req.Base.MsgType
}
func (t *CreateAliasReqTask) Execute(ctx context.Context) error {
if t.Type() != commonpb.MsgType_CreateAlias {
return fmt.Errorf("create alias, msg type = %s", commonpb.MsgType_name[int32(t.Type())])
}
ddReq := internalpb.CreateAliasRequest{
Base: t.Req.Base,
CollectionName: t.Req.CollectionName,
Alias: t.Req.Alias,
}
// build DdOperation and save it into etcd, when ddmsg send fail,
// system can restore ddmsg from etcd and re-send
ddOp := func(ts typeutil.Timestamp) (string, error) {
ddReq.Base.Timestamp = ts
return EncodeDdOperation(&ddReq, CreateAliasDDType)
}
reason := fmt.Sprintf("create alias %s", t.Req.Alias)
ts, err := t.core.TSOAllocator(1)
if err != nil {
return fmt.Errorf("TSO alloc fail, error = %w", err)
}
// use lambda function here to guarantee all resources to be released
createAliasFn := func() error {
// lock for ddl operation
t.core.ddlLock.Lock()
defer t.core.ddlLock.Unlock()
t.core.chanTimeTick.AddDdlTimeTick(ts, reason)
// clear ddl timetick in all conditions
defer t.core.chanTimeTick.RemoveDdlTimeTick(ts, reason)
err = t.core.MetaTable.AddAlias(t.Req.Alias, t.Req.CollectionName, ts, ddOp)
if err != nil {
return err
}
return t.core.SendTimeTick(ts, reason)
}
err = createAliasFn()
if err != nil {
return err
}
// Update DDOperation in etcd
return t.core.setDdMsgSendFlag(true)
}
type DropAliasReqTask struct {
baseReqTask
Req *milvuspb.DropAliasRequest
}
func (t *DropAliasReqTask) Type() commonpb.MsgType {
return t.Req.Base.MsgType
}
func (t *DropAliasReqTask) Execute(ctx context.Context) error {
if t.Type() != commonpb.MsgType_DropAlias {
return fmt.Errorf("create alias, msg type = %s", commonpb.MsgType_name[int32(t.Type())])
}
ddReq := internalpb.DropAliasRequest{
Base: t.Req.Base,
Alias: t.Req.Alias,
}
// build DdOperation and save it into etcd, when ddmsg send fail,
// system can restore ddmsg from etcd and re-send
ddOp := func(ts typeutil.Timestamp) (string, error) {
ddReq.Base.Timestamp = ts
return EncodeDdOperation(&ddReq, DropAliasDDType)
}
reason := fmt.Sprintf("create alias %s", t.Req.Alias)
ts, err := t.core.TSOAllocator(1)
if err != nil {
return fmt.Errorf("TSO alloc fail, error = %w", err)
}
// use lambda function here to guarantee all resources to be released
dropAliasFn := func() error {
// lock for ddl operation
t.core.ddlLock.Lock()
defer t.core.ddlLock.Unlock()
t.core.chanTimeTick.AddDdlTimeTick(ts, reason)
// clear ddl timetick in all conditions
defer t.core.chanTimeTick.RemoveDdlTimeTick(ts, reason)
err = t.core.MetaTable.DeleteAlias(t.Req.Alias, ts, ddOp)
if err != nil {
return err
}
t.core.SendTimeTick(ts, reason)
return nil
}
err = dropAliasFn()
if err != nil {
return err
}
req := proxypb.InvalidateCollMetaCacheRequest{
Base: &commonpb.MsgBase{
MsgType: 0, //TODO, msg type
MsgID: 0, //TODO, msg id
Timestamp: ts,
SourceID: t.core.session.ServerID,
},
CollectionName: t.Req.Alias,
}
// error doesn't matter here
t.core.proxyClientManager.InvalidateCollectionMetaCache(ctx, &req)
// Update DDOperation in etcd
return t.core.setDdMsgSendFlag(true)
}
type AlterAliasReqTask struct {
baseReqTask
Req *milvuspb.AlterAliasRequest
}
func (t *AlterAliasReqTask) Type() commonpb.MsgType {
return t.Req.Base.MsgType
}
func (t *AlterAliasReqTask) Execute(ctx context.Context) error {
if t.Type() != commonpb.MsgType_AlterAlias {
return fmt.Errorf("alter alias, msg type = %s", commonpb.MsgType_name[int32(t.Type())])
}
ddReq := internalpb.DropAliasRequest{
Base: t.Req.Base,
Alias: t.Req.Alias,
}
// build DdOperation and save it into etcd, when ddmsg send fail,
// system can restore ddmsg from etcd and re-send
ddOp := func(ts typeutil.Timestamp) (string, error) {
ddReq.Base.Timestamp = ts
return EncodeDdOperation(&ddReq, AlterAliasDDType)
}
reason := fmt.Sprintf("alter alias %s", t.Req.Alias)
ts, err := t.core.TSOAllocator(1)
if err != nil {
return fmt.Errorf("TSO alloc fail, error = %w", err)
}
// use lambda function here to guarantee all resources to be released
alterAliasFn := func() error {
// lock for ddl operation
t.core.ddlLock.Lock()
defer t.core.ddlLock.Unlock()
t.core.chanTimeTick.AddDdlTimeTick(ts, reason)
// clear ddl timetick in all conditions
defer t.core.chanTimeTick.RemoveDdlTimeTick(ts, reason)
err = t.core.MetaTable.AlterAlias(t.Req.Alias, t.Req.CollectionName, ts, ddOp)
if err != nil {
return err
}
t.core.SendTimeTick(ts, reason)
return nil
}
err = alterAliasFn()
if err != nil {
return err
}
req := proxypb.InvalidateCollMetaCacheRequest{
Base: &commonpb.MsgBase{
MsgType: 0, //TODO, msg type
MsgID: 0, //TODO, msg id
Timestamp: ts,
SourceID: t.core.session.ServerID,
},
CollectionName: t.Req.Alias,
}
// error doesn't matter here
t.core.proxyClientManager.InvalidateCollectionMetaCache(ctx, &req)
// Update DDOperation in etcd
return t.core.setDdMsgSendFlag(true)
}

5
internal/types/types.go
View File

@ -106,6 +106,11 @@ type RootCoord interface {
DescribeIndex(ctx context.Context, req *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
DropIndex(ctx context.Context, req *milvuspb.DropIndexRequest) (*commonpb.Status, error)
// collection alias
CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error)
DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error)
AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error)
//global timestamp allocator
AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error)
AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)