mirror of https://github.com/milvus-io/milvus.git
Add support for loading multiple indexes (#16138)
Signed-off-by: dragondriver <jiquan.long@zilliz.com>pull/16235/head^2
Jiquan Long
GitHub
parent
0f53989f17
commit
ba37531456
|
|
@ -285,7 +285,7 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
|
|||
"\006Failed\020\004*s\n\014SegmentState\022\024\n\020SegmentStat"
|
||||
"eNone\020\000\022\014\n\010NotExist\020\001\022\013\n\007Growing\020\002\022\n\n\006Se"
|
||||
"aled\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005\022\013\n\007Dro"
|
||||
"pped\020\006*\251\t\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cre"
|
||||
"pped\020\006*\300\t\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cre"
|
||||
"ateCollection\020d\022\022\n\016DropCollection\020e\022\021\n\rH"
|
||||
"asCollection\020f\022\026\n\022DescribeCollection\020g\022\023"
|
||||
"\n\017ShowCollections\020h\022\024\n\020GetSystemConfigs\020"
|
||||
|
|
@ -298,35 +298,35 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
|
|||
"\020\316\001\022\021\n\014ShowSegments\020\372\001\022\024\n\017DescribeSegmen"
|
||||
"t\020\373\001\022\021\n\014LoadSegments\020\374\001\022\024\n\017ReleaseSegmen"
|
||||
"ts\020\375\001\022\024\n\017HandoffSegments\020\376\001\022\030\n\023LoadBalan"
|
||||
"ceSegments\020\377\001\022\020\n\013CreateIndex\020\254\002\022\022\n\rDescr"
|
||||
"ibeIndex\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"
|
||||
"\025GetIndexBuildProgress\020\367\003\022\034\n\027GetCollecti"
|
||||
"onStatistics\020\370\003\022\033\n\026GetPartitionStatistic"
|
||||
"s\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\020RemoveDmChanne"
|
||||
"ls\020\375\003\022\027\n\022WatchQueryChannels\020\376\003\022\030\n\023Remove"
|
||||
"QueryChannels\020\377\003\022\035\n\030SealedSegmentsChange"
|
||||
"Info\020\200\004\022\027\n\022WatchDeltaChannels\020\201\004\022\020\n\013Segm"
|
||||
"entInfo\020\330\004\022\017\n\nSystemInfo\020\331\004\022\024\n\017GetRecove"
|
||||
"ryInfo\020\332\004\022\024\n\017GetSegmentState\020\333\004\022\r\n\010TimeT"
|
||||
"ick\020\260\t\022\023\n\016QueryNodeStats\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\017"
|
||||
"AllocateSegment\020\265\t\022\026\n\021SegmentStatistics\020"
|
||||
"\266\t\022\025\n\020SegmentFlushDone\020\267\t\022\017\n\nDataNodeTt\020"
|
||||
"\270\t*\"\n\007DslType\022\007\n\003Dsl\020\000\022\016\n\nBoolExprV1\020\001*B"
|
||||
"\n\017CompactionState\022\021\n\rUndefiedState\020\000\022\r\n\t"
|
||||
"Executing\020\001\022\r\n\tCompleted\020\002*X\n\020Consistenc"
|
||||
"yLevel\022\n\n\006Strong\020\000\022\013\n\007Session\020\001\022\013\n\007Bound"
|
||||
"ed\020\002\022\016\n\nEventually\020\003\022\016\n\nCustomized\020\004*\227\001\n"
|
||||
"\013ImportState\022\021\n\rImportPending\020\000\022\020\n\014Impor"
|
||||
"tFailed\020\001\022\021\n\rImportStarted\020\002\022\024\n\020ImportDo"
|
||||
"wnloaded\020\003\022\020\n\014ImportParsed\020\004\022\023\n\017ImportPe"
|
||||
"rsisted\020\005\022\023\n\017ImportCompleted\020\006BW\n\016io.mil"
|
||||
"vus.grpcB\013CommonProtoP\001Z3github.com/milv"
|
||||
"us-io/milvus/internal/proto/commonpb\240\001\001b"
|
||||
"\006proto3"
|
||||
"ceSegments\020\377\001\022\025\n\020DescribeSegments\020\200\002\022\020\n\013"
|
||||
"CreateIndex\020\254\002\022\022\n\rDescribeIndex\020\255\002\022\016\n\tDr"
|
||||
"opIndex\020\256\002\022\013\n\006Insert\020\220\003\022\013\n\006Delete\020\221\003\022\n\n\005"
|
||||
"Flush\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\025GetIndexBuildPro"
|
||||
"gress\020\367\003\022\034\n\027GetCollectionStatistics\020\370\003\022\033"
|
||||
"\n\026GetPartitionStatistics\020\371\003\022\r\n\010Retrieve\020"
|
||||
"\372\003\022\023\n\016RetrieveResult\020\373\003\022\024\n\017WatchDmChanne"
|
||||
"ls\020\374\003\022\025\n\020RemoveDmChannels\020\375\003\022\027\n\022WatchQue"
|
||||
"ryChannels\020\376\003\022\030\n\023RemoveQueryChannels\020\377\003\022"
|
||||
"\035\n\030SealedSegmentsChangeInfo\020\200\004\022\027\n\022WatchD"
|
||||
"eltaChannels\020\201\004\022\020\n\013SegmentInfo\020\330\004\022\017\n\nSys"
|
||||
"temInfo\020\331\004\022\024\n\017GetRecoveryInfo\020\332\004\022\024\n\017GetS"
|
||||
"egmentState\020\333\004\022\r\n\010TimeTick\020\260\t\022\023\n\016QueryNo"
|
||||
"deStats\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\020SegmentFlus"
|
||||
"hDone\020\267\t\022\017\n\nDataNodeTt\020\270\t*\"\n\007DslType\022\007\n\003"
|
||||
"Dsl\020\000\022\016\n\nBoolExprV1\020\001*B\n\017CompactionState"
|
||||
"\022\021\n\rUndefiedState\020\000\022\r\n\tExecuting\020\001\022\r\n\tCo"
|
||||
"mpleted\020\002*X\n\020ConsistencyLevel\022\n\n\006Strong\020"
|
||||
"\000\022\013\n\007Session\020\001\022\013\n\007Bounded\020\002\022\016\n\nEventuall"
|
||||
"y\020\003\022\016\n\nCustomized\020\004*\227\001\n\013ImportState\022\021\n\rI"
|
||||
"mportPending\020\000\022\020\n\014ImportFailed\020\001\022\021\n\rImpo"
|
||||
"rtStarted\020\002\022\024\n\020ImportDownloaded\020\003\022\020\n\014Imp"
|
||||
"ortParsed\020\004\022\023\n\017ImportPersisted\020\005\022\023\n\017Impo"
|
||||
"rtCompleted\020\006BW\n\016io.milvus.grpcB\013CommonP"
|
||||
"rotoP\001Z3github.com/milvus-io/milvus/inte"
|
||||
"rnal/proto/commonpb\240\001\001b\006proto3"
|
||||
;
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
|
||||
};
|
||||
|
|
@ -343,7 +343,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", 2927,
|
||||
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2950,
|
||||
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 8, 0,
|
||||
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
|
||||
file_level_metadata_common_2eproto, 8, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
|
||||
|
|
@ -460,6 +460,7 @@ bool MsgType_IsValid(int value) {
|
|||
case 253:
|
||||
case 254:
|
||||
case 255:
|
||||
case 256:
|
||||
case 300:
|
||||
case 301:
|
||||
case 302:
|
||||
|
|
|
|||
|
|
@ -233,6 +233,7 @@ enum MsgType : int {
|
|||
ReleaseSegments = 253,
|
||||
HandoffSegments = 254,
|
||||
LoadBalanceSegments = 255,
|
||||
DescribeSegments = 256,
|
||||
CreateIndex = 300,
|
||||
DescribeIndex = 301,
|
||||
DropIndex = 302,
|
||||
|
|
|
|||
|
|
@ -383,6 +383,10 @@ func (m *mockRootCoordService) ShowSegments(ctx context.Context, req *milvuspb.S
|
|||
panic("not implemented") // TODO: Implement
|
||||
}
|
||||
|
||||
func (m *mockRootCoordService) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
panic("implement me")
|
||||
}
|
||||
|
||||
func (m *mockRootCoordService) GetDdChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
|
||||
return &milvuspb.StringResponse{
|
||||
Status: &commonpb.Status{
|
||||
|
|
|
|||
|
|
@ -186,6 +186,10 @@ func (m *MockRootCoord) ShowSegments(ctx context.Context, req *milvuspb.ShowSegm
|
|||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *MockRootCoord) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *MockRootCoord) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -392,6 +392,19 @@ func (c *Client) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequ
|
|||
return ret.(*milvuspb.ShowSegmentsResponse), err
|
||||
}
|
||||
|
||||
func (c *Client) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
|
||||
if !funcutil.CheckCtxValid(ctx) {
|
||||
return nil, ctx.Err()
|
||||
}
|
||||
return client.(rootcoordpb.RootCoordClient).DescribeSegments(ctx, in)
|
||||
})
|
||||
if err != nil || ret == nil {
|
||||
return nil, err
|
||||
}
|
||||
return ret.(*rootcoordpb.DescribeSegmentsResponse), err
|
||||
}
|
||||
|
||||
// ReleaseDQLMessageStream release DQL msgstream
|
||||
func (c *Client) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
|
||||
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
|
||||
|
|
|
|||
|
|
@ -419,6 +419,10 @@ func (s *Server) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequ
|
|||
return s.rootCoord.ShowSegments(ctx, in)
|
||||
}
|
||||
|
||||
func (s *Server) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
return s.rootCoord.DescribeSegments(ctx, in)
|
||||
}
|
||||
|
||||
// ReleaseDQLMessageStream notifies RootCoord to release and close the search message stream of specific collection.
|
||||
func (s *Server) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
|
||||
return s.rootCoord.ReleaseDQLMessageStream(ctx, in)
|
||||
|
|
|
|||
|
|
@ -144,6 +144,15 @@ var (
|
|||
Help: "Counter of show segments",
|
||||
}, []string{statusLabelName})
|
||||
|
||||
// RootCoordDescribeSegmentsCounter counts the num of calls of DescribeSegments
|
||||
RootCoordDescribeSegmentsCounter = prometheus.NewCounterVec(
|
||||
prometheus.CounterOpts{
|
||||
Namespace: milvusNamespace,
|
||||
Subsystem: typeutil.RootCoordRole,
|
||||
Name: "describe_segments_total",
|
||||
Help: "Counter of describe segments",
|
||||
}, []string{statusLabelName})
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// for time tick
|
||||
|
||||
|
|
@ -284,6 +293,7 @@ func RegisterRootCoord(registry *prometheus.Registry) {
|
|||
registry.MustRegister(RootCoordDescribeIndexCounter)
|
||||
registry.MustRegister(RootCoordDescribeSegmentCounter)
|
||||
registry.MustRegister(RootCoordShowSegmentsCounter)
|
||||
registry.MustRegister(RootCoordDescribeSegmentsCounter)
|
||||
|
||||
// for time tick
|
||||
registry.MustRegister(RootCoordInsertChannelTimeTick)
|
||||
|
|
|
|||
|
|
@ -114,6 +114,7 @@ enum MsgType {
|
|||
ReleaseSegments = 253;
|
||||
HandoffSegments = 254;
|
||||
LoadBalanceSegments = 255;
|
||||
DescribeSegments = 256;
|
||||
|
||||
/* DEFINITION REQUESTS: INDEX */
|
||||
CreateIndex = 300;
|
||||
|
|
|
|||
|
|
@ -226,6 +226,7 @@ const (
|
|||
MsgType_ReleaseSegments MsgType = 253
|
||||
MsgType_HandoffSegments MsgType = 254
|
||||
MsgType_LoadBalanceSegments MsgType = 255
|
||||
MsgType_DescribeSegments MsgType = 256
|
||||
// DEFINITION REQUESTS: INDEX
|
||||
MsgType_CreateIndex MsgType = 300
|
||||
MsgType_DescribeIndex MsgType = 301
|
||||
|
|
@ -292,6 +293,7 @@ var MsgType_name = map[int32]string{
|
|||
253: "ReleaseSegments",
|
||||
254: "HandoffSegments",
|
||||
255: "LoadBalanceSegments",
|
||||
256: "DescribeSegments",
|
||||
300: "CreateIndex",
|
||||
301: "DescribeIndex",
|
||||
302: "DropIndex",
|
||||
|
|
@ -353,6 +355,7 @@ var MsgType_value = map[string]int32{
|
|||
"ReleaseSegments": 253,
|
||||
"HandoffSegments": 254,
|
||||
"LoadBalanceSegments": 255,
|
||||
"DescribeSegments": 256,
|
||||
"CreateIndex": 300,
|
||||
"DescribeIndex": 301,
|
||||
"DropIndex": 302,
|
||||
|
|
@ -923,105 +926,106 @@ func init() {
|
|||
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
|
||||
|
||||
var fileDescriptor_555bd8c177793206 = []byte{
|
||||
// 1594 bytes of a gzipped FileDescriptorProto
|
||||
// 1602 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4b, 0x73, 0x1b, 0xb9,
|
||||
0x11, 0xd6, 0x70, 0x28, 0x51, 0x04, 0x29, 0x0a, 0x86, 0x1e, 0xd6, 0x3a, 0x4e, 0xca, 0xa5, 0x93,
|
||||
0x4b, 0x55, 0x6b, 0x27, 0x71, 0x55, 0x72, 0xda, 0x83, 0xc8, 0x91, 0x64, 0x96, 0x2d, 0x99, 0x21,
|
||||
0x65, 0xef, 0x56, 0x0e, 0x71, 0x41, 0x33, 0x2d, 0x12, 0x31, 0x06, 0x60, 0x00, 0x8c, 0x24, 0xe6,
|
||||
0x94, 0xfc, 0x83, 0x64, 0x2f, 0xb9, 0xe6, 0x9a, 0xaa, 0x24, 0x95, 0x77, 0x52, 0xf9, 0x05, 0x79,
|
||||
0x9f, 0xf3, 0xf8, 0x03, 0xf9, 0x01, 0x79, 0xee, 0x33, 0xd5, 0x98, 0xe1, 0xcc, 0x6c, 0xd5, 0xee,
|
||||
0x29, 0x37, 0xf4, 0x87, 0xee, 0xaf, 0x1b, 0xdd, 0x8d, 0x06, 0x48, 0x37, 0xd6, 0x69, 0xaa, 0xd5,
|
||||
0x83, 0xb9, 0xd1, 0x4e, 0xb3, 0xad, 0x54, 0xc8, 0xab, 0xcc, 0xe6, 0xd2, 0x83, 0x7c, 0x6b, 0xff,
|
||||
0x25, 0x59, 0x9b, 0x38, 0xee, 0x32, 0xcb, 0xde, 0x20, 0x04, 0x8c, 0xd1, 0xe6, 0x65, 0xac, 0x13,
|
||||
0xd8, 0x0b, 0xee, 0x05, 0xf7, 0x7b, 0x9f, 0xff, 0xcc, 0x83, 0x8f, 0xb1, 0x79, 0x70, 0x84, 0x6a,
|
||||
0x03, 0x9d, 0xc0, 0xb8, 0x0d, 0xcb, 0x25, 0xdb, 0x25, 0x6b, 0x06, 0xb8, 0xd5, 0x6a, 0xaf, 0x71,
|
||||
0x2f, 0xb8, 0xdf, 0x1e, 0x17, 0xd2, 0xfe, 0x17, 0x48, 0xf7, 0x09, 0x2c, 0x5e, 0x70, 0x99, 0xc1,
|
||||
0x88, 0x0b, 0xc3, 0x28, 0x09, 0x5f, 0xc1, 0xc2, 0xf3, 0xb7, 0xc7, 0xb8, 0x64, 0xdb, 0x64, 0xf5,
|
||||
0x0a, 0xb7, 0x0b, 0xc3, 0x5c, 0xd8, 0x7f, 0x44, 0x3a, 0x4f, 0x60, 0x11, 0x71, 0xc7, 0x3f, 0xc1,
|
||||
0x8c, 0x91, 0x66, 0xc2, 0x1d, 0xf7, 0x56, 0xdd, 0xb1, 0x5f, 0xef, 0xdf, 0x25, 0xcd, 0xbe, 0xd4,
|
||||
0x17, 0x15, 0x65, 0xe0, 0x37, 0x0b, 0xca, 0xd7, 0x49, 0xeb, 0x30, 0x49, 0x0c, 0x58, 0xcb, 0x7a,
|
||||
0xa4, 0x21, 0xe6, 0x05, 0x5b, 0x43, 0xcc, 0x91, 0x6c, 0xae, 0x8d, 0xf3, 0x64, 0xe1, 0xd8, 0xaf,
|
||||
0xf7, 0xdf, 0x0e, 0x48, 0xeb, 0xd4, 0x4e, 0xfb, 0xdc, 0x02, 0xfb, 0x22, 0x59, 0x4f, 0xed, 0xf4,
|
||||
0xa5, 0x5b, 0xcc, 0x97, 0xa9, 0xb9, 0xfb, 0xb1, 0xa9, 0x39, 0xb5, 0xd3, 0xf3, 0xc5, 0x1c, 0xc6,
|
||||
0xad, 0x34, 0x5f, 0x60, 0x24, 0xa9, 0x9d, 0x0e, 0xa3, 0x82, 0x39, 0x17, 0xd8, 0x5d, 0xd2, 0x76,
|
||||
0x22, 0x05, 0xeb, 0x78, 0x3a, 0xdf, 0x0b, 0xef, 0x05, 0xf7, 0x9b, 0xe3, 0x0a, 0x60, 0x77, 0xc8,
|
||||
0xba, 0xd5, 0x99, 0x89, 0x61, 0x18, 0xed, 0x35, 0xbd, 0x59, 0x29, 0xef, 0xbf, 0x41, 0xda, 0xa7,
|
||||
0x76, 0xfa, 0x18, 0x78, 0x02, 0x86, 0x7d, 0x96, 0x34, 0x2f, 0xb8, 0xcd, 0x23, 0xea, 0x7c, 0x72,
|
||||
0x44, 0x78, 0x82, 0xb1, 0xd7, 0xdc, 0xff, 0x0a, 0xe9, 0x46, 0xa7, 0x4f, 0xff, 0x0f, 0x06, 0x0c,
|
||||
0xdd, 0xce, 0xb8, 0x49, 0xce, 0x78, 0xba, 0xac, 0x58, 0x05, 0x1c, 0xfc, 0xba, 0x49, 0xda, 0x65,
|
||||
0x7b, 0xb0, 0x0e, 0x69, 0x4d, 0xb2, 0x38, 0x06, 0x6b, 0xe9, 0x0a, 0xdb, 0x22, 0x9b, 0xcf, 0x15,
|
||||
0xdc, 0xcc, 0x21, 0x76, 0x90, 0x78, 0x1d, 0x1a, 0xb0, 0x5b, 0x64, 0x63, 0xa0, 0x95, 0x82, 0xd8,
|
||||
0x1d, 0x73, 0x21, 0x21, 0xa1, 0x0d, 0xb6, 0x4d, 0xe8, 0x08, 0x4c, 0x2a, 0xac, 0x15, 0x5a, 0x45,
|
||||
0xa0, 0x04, 0x24, 0x34, 0x64, 0xb7, 0xc9, 0xd6, 0x40, 0x4b, 0x09, 0xb1, 0x13, 0x5a, 0x9d, 0x69,
|
||||
0x77, 0x74, 0x23, 0xac, 0xb3, 0xb4, 0x89, 0xb4, 0x43, 0x29, 0x61, 0xca, 0xe5, 0xa1, 0x99, 0x66,
|
||||
0x29, 0x28, 0x47, 0x57, 0x91, 0xa3, 0x00, 0x23, 0x91, 0x82, 0x42, 0x26, 0xda, 0xaa, 0xa1, 0x43,
|
||||
0x95, 0xc0, 0x0d, 0xd6, 0x87, 0xae, 0xb3, 0xd7, 0xc8, 0x4e, 0x81, 0xd6, 0x1c, 0xf0, 0x14, 0x68,
|
||||
0x9b, 0x6d, 0x92, 0x4e, 0xb1, 0x75, 0xfe, 0x6c, 0xf4, 0x84, 0x92, 0x1a, 0xc3, 0x58, 0x5f, 0x8f,
|
||||
0x21, 0xd6, 0x26, 0xa1, 0x9d, 0x5a, 0x08, 0x2f, 0x20, 0x76, 0xda, 0x0c, 0x23, 0xda, 0xc5, 0x80,
|
||||
0x0b, 0x70, 0x02, 0xdc, 0xc4, 0xb3, 0x31, 0xd8, 0x4c, 0x3a, 0xba, 0xc1, 0x28, 0xe9, 0x1e, 0x0b,
|
||||
0x09, 0x67, 0xda, 0x1d, 0xeb, 0x4c, 0x25, 0xb4, 0xc7, 0x7a, 0x84, 0x9c, 0x82, 0xe3, 0x45, 0x06,
|
||||
0x36, 0xd1, 0xed, 0x80, 0xc7, 0x33, 0x28, 0x00, 0xca, 0x76, 0x09, 0x1b, 0x70, 0xa5, 0xb4, 0x1b,
|
||||
0x18, 0xe0, 0x0e, 0x8e, 0xb5, 0x4c, 0xc0, 0xd0, 0x5b, 0x18, 0xce, 0x47, 0x70, 0x21, 0x81, 0xb2,
|
||||
0x4a, 0x3b, 0x02, 0x09, 0xa5, 0xf6, 0x56, 0xa5, 0x5d, 0xe0, 0xa8, 0xbd, 0x8d, 0xc1, 0xf7, 0x33,
|
||||
0x21, 0x13, 0x9f, 0x92, 0xbc, 0x2c, 0x3b, 0x18, 0x63, 0x11, 0xfc, 0xd9, 0xd3, 0xe1, 0xe4, 0x9c,
|
||||
0xee, 0xb2, 0x1d, 0x72, 0xab, 0x40, 0x4e, 0xc1, 0x19, 0x11, 0xfb, 0xe4, 0xdd, 0xc6, 0x50, 0x9f,
|
||||
0x65, 0xee, 0xd9, 0xe5, 0x29, 0xa4, 0xda, 0x2c, 0xe8, 0x1e, 0x16, 0xd4, 0x33, 0x2d, 0x4b, 0x44,
|
||||
0x5f, 0x43, 0x0f, 0x47, 0xe9, 0xdc, 0x2d, 0xaa, 0xf4, 0xd2, 0x3b, 0x8c, 0x91, 0x8d, 0x28, 0x1a,
|
||||
0xc3, 0xd7, 0x32, 0xb0, 0x6e, 0xcc, 0x63, 0xa0, 0x7f, 0x6f, 0x1d, 0xbc, 0x45, 0x88, 0xb7, 0xc5,
|
||||
0x81, 0x04, 0x8c, 0x91, 0x5e, 0x25, 0x9d, 0x69, 0x05, 0x74, 0x85, 0x75, 0xc9, 0xfa, 0x73, 0x25,
|
||||
0xac, 0xcd, 0x20, 0xa1, 0x01, 0xe6, 0x6d, 0xa8, 0x46, 0x46, 0x4f, 0xf1, 0x4a, 0xd3, 0x06, 0xee,
|
||||
0x1e, 0x0b, 0x25, 0xec, 0xcc, 0x77, 0x0c, 0x21, 0x6b, 0x45, 0x02, 0x9b, 0x07, 0x96, 0x74, 0x27,
|
||||
0x30, 0xc5, 0xe6, 0xc8, 0xb9, 0xb7, 0x09, 0xad, 0xcb, 0x15, 0x7b, 0x19, 0x76, 0x80, 0xcd, 0x7b,
|
||||
0x62, 0xf4, 0xb5, 0x50, 0x53, 0xda, 0x40, 0xb2, 0x09, 0x70, 0xe9, 0x89, 0x3b, 0xa4, 0x75, 0x2c,
|
||||
0x33, 0xef, 0xa5, 0xe9, 0x7d, 0xa2, 0x80, 0x6a, 0xab, 0xb8, 0x15, 0x19, 0x3d, 0x9f, 0x43, 0x42,
|
||||
0xd7, 0x0e, 0xbe, 0xd7, 0xf6, 0xf3, 0xc3, 0x8f, 0x81, 0x0d, 0xd2, 0x7e, 0xae, 0x12, 0xb8, 0x14,
|
||||
0x0a, 0x12, 0xba, 0xe2, 0x4b, 0xe1, 0x4b, 0x56, 0xcb, 0x49, 0x82, 0x27, 0x46, 0xeb, 0x1a, 0x06,
|
||||
0x98, 0xcf, 0xc7, 0xdc, 0xd6, 0xa0, 0x4b, 0xac, 0x6f, 0x04, 0x36, 0x36, 0xe2, 0xa2, 0x6e, 0x3e,
|
||||
0xc5, 0x3c, 0x4f, 0x66, 0xfa, 0xba, 0xc2, 0x2c, 0x9d, 0xa1, 0xa7, 0x13, 0x70, 0x93, 0x85, 0x75,
|
||||
0x90, 0x0e, 0xb4, 0xba, 0x14, 0x53, 0x4b, 0x05, 0x7a, 0x7a, 0xaa, 0x79, 0x52, 0x33, 0xff, 0x2a,
|
||||
0x56, 0x78, 0x0c, 0x12, 0xb8, 0xad, 0xb3, 0xbe, 0xf2, 0xcd, 0xe8, 0x43, 0x3d, 0x94, 0x82, 0x5b,
|
||||
0x2a, 0xf1, 0x28, 0x18, 0x65, 0x2e, 0xa6, 0x58, 0x84, 0x43, 0xe9, 0xc0, 0xe4, 0xb2, 0x62, 0xdb,
|
||||
0x64, 0x33, 0xd7, 0x1f, 0x71, 0xe3, 0x84, 0x27, 0xf9, 0x4d, 0xe0, 0xcb, 0x6d, 0xf4, 0xbc, 0xc2,
|
||||
0x7e, 0x8b, 0x77, 0xbf, 0xfb, 0x98, 0xdb, 0x0a, 0xfa, 0x5d, 0xc0, 0x76, 0xc9, 0xad, 0xe5, 0xd1,
|
||||
0x2a, 0xfc, 0xf7, 0x01, 0xdb, 0x22, 0x3d, 0x3c, 0x5a, 0x89, 0x59, 0xfa, 0x07, 0x0f, 0xe2, 0x21,
|
||||
0x6a, 0xe0, 0x1f, 0x3d, 0x43, 0x71, 0x8a, 0x1a, 0xfe, 0x27, 0xef, 0x0c, 0x19, 0x8a, 0xaa, 0x5b,
|
||||
0xfa, 0x4e, 0x80, 0x91, 0x2e, 0x9d, 0x15, 0x30, 0x7d, 0xd7, 0x2b, 0x22, 0x6b, 0xa9, 0xf8, 0x9e,
|
||||
0x57, 0x2c, 0x38, 0x4b, 0xf4, 0x7d, 0x8f, 0x3e, 0xe6, 0x2a, 0xd1, 0x97, 0x97, 0x25, 0xfa, 0x41,
|
||||
0xc0, 0xf6, 0xc8, 0x16, 0x9a, 0xf7, 0xb9, 0xe4, 0x2a, 0xae, 0xf4, 0x3f, 0x0c, 0x18, 0x5d, 0x26,
|
||||
0xd2, 0x77, 0x35, 0xfd, 0x7e, 0xc3, 0x27, 0xa5, 0x08, 0x20, 0xc7, 0x7e, 0xd0, 0x60, 0xbd, 0x3c,
|
||||
0xbb, 0xb9, 0xfc, 0xc3, 0x06, 0xeb, 0x90, 0xb5, 0xa1, 0xb2, 0x60, 0x1c, 0xfd, 0x16, 0x76, 0xde,
|
||||
0x5a, 0x7e, 0x77, 0xe9, 0xb7, 0xb1, 0xbf, 0x57, 0x7d, 0xe7, 0xd1, 0xb7, 0xfd, 0x46, 0x3e, 0x65,
|
||||
0xe8, 0x3f, 0x42, 0x7f, 0xd4, 0xfa, 0xc8, 0xf9, 0x67, 0x88, 0x9e, 0x4e, 0xc0, 0x55, 0xd7, 0x89,
|
||||
0xfe, 0x2b, 0x64, 0x77, 0xc8, 0xce, 0x12, 0xf3, 0x03, 0xa0, 0xbc, 0x48, 0xff, 0x0e, 0xd9, 0x5d,
|
||||
0x72, 0xfb, 0x04, 0x5c, 0xd5, 0x07, 0x68, 0x24, 0xac, 0x13, 0xb1, 0xa5, 0xff, 0x09, 0xd9, 0xa7,
|
||||
0xc8, 0xee, 0x09, 0xb8, 0x32, 0xbf, 0xb5, 0xcd, 0xff, 0x86, 0x6c, 0x83, 0xac, 0x8f, 0x71, 0x42,
|
||||
0xc0, 0x15, 0xd0, 0x77, 0x42, 0x2c, 0xd2, 0x52, 0x2c, 0xc2, 0x79, 0x37, 0xc4, 0xd4, 0xbd, 0xc9,
|
||||
0x5d, 0x3c, 0x8b, 0xd2, 0xc1, 0x8c, 0x2b, 0x05, 0xd2, 0xd2, 0xf7, 0x42, 0xb6, 0x43, 0xe8, 0x18,
|
||||
0x52, 0x7d, 0x05, 0x35, 0xf8, 0x7d, 0x9c, 0xfc, 0xcc, 0x2b, 0x7f, 0x29, 0x03, 0xb3, 0x28, 0x37,
|
||||
0x3e, 0x08, 0x31, 0xd5, 0xb9, 0xfe, 0x47, 0x77, 0x3e, 0x0c, 0xd9, 0xa7, 0xc9, 0x5e, 0x7e, 0x5b,
|
||||
0x97, 0xf9, 0xc7, 0xcd, 0x29, 0x0c, 0xd5, 0xa5, 0xa6, 0xdf, 0x68, 0x96, 0x8c, 0x11, 0x48, 0xc7,
|
||||
0x4b, 0xbb, 0x6f, 0x36, 0xb1, 0x44, 0x85, 0x85, 0x57, 0xfd, 0x73, 0x93, 0x6d, 0x12, 0x92, 0xdf,
|
||||
0x1d, 0x0f, 0xfc, 0xa5, 0x89, 0xa1, 0x9f, 0x80, 0xc3, 0xd1, 0x7f, 0x05, 0x66, 0xe1, 0xd1, 0xbf,
|
||||
0x2e, 0xd1, 0xfa, 0x48, 0xa1, 0x7f, 0x6b, 0x62, 0x2a, 0xce, 0x45, 0x0a, 0xe7, 0x22, 0x7e, 0x45,
|
||||
0x7f, 0xd4, 0xc6, 0x54, 0xf8, 0x48, 0xcf, 0x74, 0x02, 0xa8, 0x63, 0xe9, 0x8f, 0xdb, 0x58, 0x6f,
|
||||
0xec, 0x97, 0xbc, 0xde, 0x3f, 0xf1, 0x72, 0x31, 0x15, 0x87, 0x11, 0xfd, 0x29, 0x3e, 0x41, 0xa4,
|
||||
0x90, 0xcf, 0x27, 0xcf, 0xe8, 0xcf, 0xda, 0xe8, 0xea, 0x50, 0x4a, 0x1d, 0x73, 0x57, 0x76, 0xed,
|
||||
0xcf, 0xdb, 0xd8, 0xf6, 0x35, 0xef, 0x45, 0x35, 0x7e, 0xd1, 0xc6, 0x9c, 0x16, 0xb8, 0xef, 0x95,
|
||||
0x08, 0x07, 0xdd, 0x2f, 0x3d, 0x2b, 0xfe, 0xac, 0x30, 0x92, 0x73, 0x47, 0x7f, 0xd5, 0x3e, 0xd8,
|
||||
0x27, 0xad, 0xc8, 0x4a, 0x3f, 0xaa, 0x5a, 0x24, 0x8c, 0xac, 0xa4, 0x2b, 0x78, 0xb3, 0xfb, 0x5a,
|
||||
0xcb, 0xa3, 0x9b, 0xb9, 0x79, 0xf1, 0x39, 0x1a, 0x1c, 0xf4, 0xc9, 0xe6, 0x40, 0xa7, 0x73, 0x5e,
|
||||
0x76, 0x84, 0x9f, 0x4e, 0xf9, 0x58, 0x83, 0x24, 0x3f, 0xf5, 0x0a, 0x8e, 0x87, 0xa3, 0x1b, 0x88,
|
||||
0x33, 0x87, 0x13, 0x31, 0x40, 0x11, 0x8d, 0xb0, 0x69, 0x13, 0xda, 0x38, 0x78, 0x8b, 0xd0, 0x81,
|
||||
0x56, 0x56, 0x58, 0x07, 0x2a, 0x5e, 0x3c, 0x85, 0x2b, 0x90, 0x7e, 0xb6, 0x3a, 0xa3, 0xd5, 0x94,
|
||||
0xae, 0xf8, 0x1f, 0x03, 0xf8, 0x97, 0x3f, 0x9f, 0xc0, 0x7d, 0x7c, 0x22, 0xfd, 0xb7, 0xa0, 0x47,
|
||||
0xc8, 0xd1, 0x15, 0x28, 0x97, 0x71, 0x29, 0x17, 0x34, 0x44, 0x79, 0x90, 0x59, 0xa7, 0x53, 0xf1,
|
||||
0x75, 0x3f, 0xe2, 0xbf, 0x13, 0x90, 0xce, 0x30, 0xc5, 0x8f, 0x5b, 0x19, 0x5a, 0x2e, 0x8e, 0x40,
|
||||
0x25, 0xc2, 0x93, 0xe3, 0xab, 0xe6, 0xa1, 0xe2, 0x5d, 0x08, 0x2a, 0xa5, 0x89, 0xe3, 0xc6, 0x2d,
|
||||
0xbf, 0x1f, 0x39, 0x14, 0xe9, 0x6b, 0x25, 0x35, 0x4f, 0xfc, 0xcc, 0x2f, 0x4d, 0x47, 0xdc, 0x58,
|
||||
0x3f, 0xf8, 0xf1, 0xd1, 0x2f, 0xf8, 0x8d, 0x3f, 0x4f, 0x42, 0x57, 0x2b, 0xb0, 0x3a, 0xf3, 0x5a,
|
||||
0xff, 0x4d, 0xd2, 0x13, 0x7a, 0xf9, 0xb3, 0x9a, 0x9a, 0x79, 0xdc, 0xef, 0x0c, 0xfc, 0xcf, 0x6a,
|
||||
0x84, 0xbf, 0xac, 0x51, 0xf0, 0xe5, 0x47, 0x53, 0xe1, 0x66, 0xd9, 0x05, 0xfe, 0xb7, 0x1e, 0xe6,
|
||||
0x6a, 0xaf, 0x0b, 0x5d, 0xac, 0x1e, 0x0a, 0xe5, 0xc0, 0x28, 0x2e, 0x1f, 0xfa, 0x3f, 0xd9, 0xc3,
|
||||
0xfc, 0x4f, 0x36, 0xbf, 0xf8, 0x6e, 0x10, 0x5c, 0xac, 0x79, 0xe8, 0xd1, 0xff, 0x02, 0x00, 0x00,
|
||||
0xff, 0xff, 0x13, 0x8a, 0x26, 0xfd, 0xe7, 0x0b, 0x00, 0x00,
|
||||
0x65, 0xef, 0x56, 0x0e, 0x71, 0x41, 0x33, 0x2d, 0x12, 0x31, 0x06, 0x60, 0x00, 0x8c, 0x2c, 0xe6,
|
||||
0xb4, 0xf9, 0x07, 0xc9, 0x5e, 0x72, 0xcd, 0x0f, 0x48, 0x52, 0x79, 0x27, 0x95, 0x53, 0x8e, 0x79,
|
||||
0x9f, 0xf3, 0xf8, 0x03, 0xf9, 0x01, 0x79, 0xee, 0x33, 0xd5, 0x98, 0xe1, 0xcc, 0x6c, 0x6a, 0x7d,
|
||||
0xca, 0x0d, 0xfd, 0xa1, 0xfb, 0x43, 0xa3, 0xbb, 0xd1, 0x68, 0xd2, 0x8d, 0x75, 0x9a, 0x6a, 0x75,
|
||||
0x6f, 0x6e, 0xb4, 0xd3, 0x6c, 0x2b, 0x15, 0xf2, 0x2a, 0xb3, 0xb9, 0x74, 0x2f, 0xdf, 0xda, 0x7f,
|
||||
0x4e, 0xd6, 0x26, 0x8e, 0xbb, 0xcc, 0xb2, 0x37, 0x08, 0x01, 0x63, 0xb4, 0x79, 0x1e, 0xeb, 0x04,
|
||||
0xf6, 0x82, 0x3b, 0xc1, 0xdd, 0xde, 0xe7, 0x3f, 0x73, 0xef, 0x13, 0x6c, 0xee, 0x1d, 0xa1, 0xda,
|
||||
0x40, 0x27, 0x30, 0x6e, 0xc3, 0x72, 0xc9, 0x76, 0xc9, 0x9a, 0x01, 0x6e, 0xb5, 0xda, 0x6b, 0xdc,
|
||||
0x09, 0xee, 0xb6, 0xc7, 0x85, 0xb4, 0xff, 0x05, 0xd2, 0x7d, 0x04, 0x8b, 0x67, 0x5c, 0x66, 0x30,
|
||||
0xe2, 0xc2, 0x30, 0x4a, 0xc2, 0x17, 0xb0, 0xf0, 0xfc, 0xed, 0x31, 0x2e, 0xd9, 0x36, 0x59, 0xbd,
|
||||
0xc2, 0xed, 0xc2, 0x30, 0x17, 0xf6, 0x1f, 0x90, 0xce, 0x23, 0x58, 0x44, 0xdc, 0xf1, 0x57, 0x98,
|
||||
0x31, 0xd2, 0x4c, 0xb8, 0xe3, 0xde, 0xaa, 0x3b, 0xf6, 0xeb, 0xfd, 0xdb, 0xa4, 0xd9, 0x97, 0xfa,
|
||||
0xa2, 0xa2, 0x0c, 0xfc, 0x66, 0x41, 0xf9, 0x3a, 0x69, 0x1d, 0x26, 0x89, 0x01, 0x6b, 0x59, 0x8f,
|
||||
0x34, 0xc4, 0xbc, 0x60, 0x6b, 0x88, 0x39, 0x92, 0xcd, 0xb5, 0x71, 0x9e, 0x2c, 0x1c, 0xfb, 0xf5,
|
||||
0xfe, 0x3b, 0x01, 0x69, 0x9d, 0xda, 0x69, 0x9f, 0x5b, 0x60, 0x5f, 0x24, 0xeb, 0xa9, 0x9d, 0x3e,
|
||||
0x77, 0x8b, 0xf9, 0x32, 0x34, 0xb7, 0x3f, 0x31, 0x34, 0xa7, 0x76, 0x7a, 0xbe, 0x98, 0xc3, 0xb8,
|
||||
0x95, 0xe6, 0x0b, 0xf4, 0x24, 0xb5, 0xd3, 0x61, 0x54, 0x30, 0xe7, 0x02, 0xbb, 0x4d, 0xda, 0x4e,
|
||||
0xa4, 0x60, 0x1d, 0x4f, 0xe7, 0x7b, 0xe1, 0x9d, 0xe0, 0x6e, 0x73, 0x5c, 0x01, 0xec, 0x16, 0x59,
|
||||
0xb7, 0x3a, 0x33, 0x31, 0x0c, 0xa3, 0xbd, 0xa6, 0x37, 0x2b, 0xe5, 0xfd, 0x37, 0x48, 0xfb, 0xd4,
|
||||
0x4e, 0x1f, 0x02, 0x4f, 0xc0, 0xb0, 0xcf, 0x92, 0xe6, 0x05, 0xb7, 0xb9, 0x47, 0x9d, 0x57, 0x7b,
|
||||
0x84, 0x37, 0x18, 0x7b, 0xcd, 0xfd, 0xaf, 0x90, 0x6e, 0x74, 0xfa, 0xf8, 0xff, 0x60, 0x40, 0xd7,
|
||||
0xed, 0x8c, 0x9b, 0xe4, 0x8c, 0xa7, 0xcb, 0x8c, 0x55, 0xc0, 0xc1, 0x2f, 0x9b, 0xa4, 0x5d, 0x96,
|
||||
0x07, 0xeb, 0x90, 0xd6, 0x24, 0x8b, 0x63, 0xb0, 0x96, 0xae, 0xb0, 0x2d, 0xb2, 0xf9, 0x54, 0xc1,
|
||||
0xf5, 0x1c, 0x62, 0x07, 0x89, 0xd7, 0xa1, 0x01, 0xbb, 0x41, 0x36, 0x06, 0x5a, 0x29, 0x88, 0xdd,
|
||||
0x31, 0x17, 0x12, 0x12, 0xda, 0x60, 0xdb, 0x84, 0x8e, 0xc0, 0xa4, 0xc2, 0x5a, 0xa1, 0x55, 0x04,
|
||||
0x4a, 0x40, 0x42, 0x43, 0x76, 0x93, 0x6c, 0x0d, 0xb4, 0x94, 0x10, 0x3b, 0xa1, 0xd5, 0x99, 0x76,
|
||||
0x47, 0xd7, 0xc2, 0x3a, 0x4b, 0x9b, 0x48, 0x3b, 0x94, 0x12, 0xa6, 0x5c, 0x1e, 0x9a, 0x69, 0x96,
|
||||
0x82, 0x72, 0x74, 0x15, 0x39, 0x0a, 0x30, 0x12, 0x29, 0x28, 0x64, 0xa2, 0xad, 0x1a, 0x3a, 0x54,
|
||||
0x09, 0x5c, 0x63, 0x7e, 0xe8, 0x3a, 0x7b, 0x8d, 0xec, 0x14, 0x68, 0xed, 0x00, 0x9e, 0x02, 0x6d,
|
||||
0xb3, 0x4d, 0xd2, 0x29, 0xb6, 0xce, 0x9f, 0x8c, 0x1e, 0x51, 0x52, 0x63, 0x18, 0xeb, 0x97, 0x63,
|
||||
0x88, 0xb5, 0x49, 0x68, 0xa7, 0xe6, 0xc2, 0x33, 0x88, 0x9d, 0x36, 0xc3, 0x88, 0x76, 0xd1, 0xe1,
|
||||
0x02, 0x9c, 0x00, 0x37, 0xf1, 0x6c, 0x0c, 0x36, 0x93, 0x8e, 0x6e, 0x30, 0x4a, 0xba, 0xc7, 0x42,
|
||||
0xc2, 0x99, 0x76, 0xc7, 0x3a, 0x53, 0x09, 0xed, 0xb1, 0x1e, 0x21, 0xa7, 0xe0, 0x78, 0x11, 0x81,
|
||||
0x4d, 0x3c, 0x76, 0xc0, 0xe3, 0x19, 0x14, 0x00, 0x65, 0xbb, 0x84, 0x0d, 0xb8, 0x52, 0xda, 0x0d,
|
||||
0x0c, 0x70, 0x07, 0xc7, 0x5a, 0x26, 0x60, 0xe8, 0x0d, 0x74, 0xe7, 0x63, 0xb8, 0x90, 0x40, 0x59,
|
||||
0xa5, 0x1d, 0x81, 0x84, 0x52, 0x7b, 0xab, 0xd2, 0x2e, 0x70, 0xd4, 0xde, 0x46, 0xe7, 0xfb, 0x99,
|
||||
0x90, 0x89, 0x0f, 0x49, 0x9e, 0x96, 0x1d, 0xf4, 0xb1, 0x70, 0xfe, 0xec, 0xf1, 0x70, 0x72, 0x4e,
|
||||
0x77, 0xd9, 0x0e, 0xb9, 0x51, 0x20, 0xa7, 0xe0, 0x8c, 0x88, 0x7d, 0xf0, 0x6e, 0xa2, 0xab, 0x4f,
|
||||
0x32, 0xf7, 0xe4, 0xf2, 0x14, 0x52, 0x6d, 0x16, 0x74, 0x0f, 0x13, 0xea, 0x99, 0x96, 0x29, 0xa2,
|
||||
0xaf, 0xe1, 0x09, 0x47, 0xe9, 0xdc, 0x2d, 0xaa, 0xf0, 0xd2, 0x5b, 0x8c, 0x91, 0x8d, 0x28, 0x1a,
|
||||
0xc3, 0xd7, 0x32, 0xb0, 0x6e, 0xcc, 0x63, 0xa0, 0x7f, 0x6b, 0x1d, 0xbc, 0x45, 0x88, 0xb7, 0xc5,
|
||||
0x86, 0x04, 0x8c, 0x91, 0x5e, 0x25, 0x9d, 0x69, 0x05, 0x74, 0x85, 0x75, 0xc9, 0xfa, 0x53, 0x25,
|
||||
0xac, 0xcd, 0x20, 0xa1, 0x01, 0xc6, 0x6d, 0xa8, 0x46, 0x46, 0x4f, 0xf1, 0x49, 0xd3, 0x06, 0xee,
|
||||
0x1e, 0x0b, 0x25, 0xec, 0xcc, 0x57, 0x0c, 0x21, 0x6b, 0x45, 0x00, 0x9b, 0x07, 0x96, 0x74, 0x27,
|
||||
0x30, 0xc5, 0xe2, 0xc8, 0xb9, 0xb7, 0x09, 0xad, 0xcb, 0x15, 0x7b, 0xe9, 0x76, 0x80, 0xc5, 0x7b,
|
||||
0x62, 0xf4, 0x4b, 0xa1, 0xa6, 0xb4, 0x81, 0x64, 0x13, 0xe0, 0xd2, 0x13, 0x77, 0x48, 0xeb, 0x58,
|
||||
0x66, 0xfe, 0x94, 0xa6, 0x3f, 0x13, 0x05, 0x54, 0x5b, 0xc5, 0xad, 0xc8, 0xe8, 0xf9, 0x1c, 0x12,
|
||||
0xba, 0x76, 0xf0, 0xab, 0xb6, 0xef, 0x1f, 0xbe, 0x0d, 0x6c, 0x90, 0xf6, 0x53, 0x95, 0xc0, 0xa5,
|
||||
0x50, 0x90, 0xd0, 0x15, 0x9f, 0x0a, 0x9f, 0xb2, 0x5a, 0x4c, 0x12, 0xbc, 0x31, 0x5a, 0xd7, 0x30,
|
||||
0xc0, 0x78, 0x3e, 0xe4, 0xb6, 0x06, 0x5d, 0x62, 0x7e, 0x23, 0xb0, 0xb1, 0x11, 0x17, 0x75, 0xf3,
|
||||
0x29, 0xc6, 0x79, 0x32, 0xd3, 0x2f, 0x2b, 0xcc, 0xd2, 0x19, 0x9e, 0x74, 0x02, 0x6e, 0xb2, 0xb0,
|
||||
0x0e, 0xd2, 0x81, 0x56, 0x97, 0x62, 0x6a, 0xa9, 0xc0, 0x93, 0x1e, 0x6b, 0x9e, 0xd4, 0xcc, 0xbf,
|
||||
0x8a, 0x19, 0x1e, 0x83, 0x04, 0x6e, 0xeb, 0xac, 0x2f, 0x7c, 0x31, 0x7a, 0x57, 0x0f, 0xa5, 0xe0,
|
||||
0x96, 0x4a, 0xbc, 0x0a, 0x7a, 0x99, 0x8b, 0x29, 0x26, 0xe1, 0x50, 0x3a, 0x30, 0xb9, 0xac, 0xd8,
|
||||
0x36, 0xd9, 0xcc, 0xf5, 0x47, 0xdc, 0x38, 0xe1, 0x49, 0x7e, 0x1d, 0xf8, 0x74, 0x1b, 0x3d, 0xaf,
|
||||
0xb0, 0xdf, 0xe0, 0xdb, 0xef, 0x3e, 0xe4, 0xb6, 0x82, 0x7e, 0x1b, 0xb0, 0x5d, 0x72, 0x63, 0x79,
|
||||
0xb5, 0x0a, 0xff, 0x5d, 0xc0, 0xb6, 0x48, 0x0f, 0xaf, 0x56, 0x62, 0x96, 0xfe, 0xde, 0x83, 0x78,
|
||||
0x89, 0x1a, 0xf8, 0x07, 0xcf, 0x50, 0xdc, 0xa2, 0x86, 0xff, 0xd1, 0x1f, 0x86, 0x0c, 0x45, 0xd6,
|
||||
0x2d, 0x7d, 0x37, 0x40, 0x4f, 0x97, 0x87, 0x15, 0x30, 0x7d, 0xcf, 0x2b, 0x22, 0x6b, 0xa9, 0xf8,
|
||||
0xbe, 0x57, 0x2c, 0x38, 0x4b, 0xf4, 0x03, 0x8f, 0x3e, 0xe4, 0x2a, 0xd1, 0x97, 0x97, 0x25, 0xfa,
|
||||
0x61, 0xc0, 0xf6, 0xc8, 0x16, 0x9a, 0xf7, 0xb9, 0xe4, 0x2a, 0xae, 0xf4, 0x3f, 0x0a, 0xd8, 0x0e,
|
||||
0xa1, 0xff, 0x73, 0x9c, 0xa5, 0x6f, 0x37, 0x18, 0x5d, 0xc6, 0xd7, 0x17, 0x3b, 0xfd, 0x6e, 0xc3,
|
||||
0xc7, 0xaa, 0x50, 0xcc, 0xb1, 0xef, 0x35, 0x58, 0x2f, 0x0f, 0x7a, 0x2e, 0x7f, 0xbf, 0xc1, 0x3a,
|
||||
0x64, 0x6d, 0xa8, 0x2c, 0x18, 0x47, 0xbf, 0x89, 0x05, 0xb9, 0x96, 0x3f, 0x69, 0xfa, 0x2d, 0x2c,
|
||||
0xfb, 0x55, 0x5f, 0x90, 0xf4, 0x1d, 0xbf, 0x91, 0x37, 0x1f, 0xfa, 0xf7, 0xd0, 0x47, 0xa0, 0xde,
|
||||
0x89, 0xfe, 0x11, 0xe2, 0x49, 0x27, 0xe0, 0xaa, 0x57, 0x46, 0xff, 0x19, 0xb2, 0x5b, 0x64, 0x67,
|
||||
0x89, 0xf9, 0xbe, 0x50, 0xbe, 0xaf, 0x7f, 0x85, 0xec, 0x36, 0xb9, 0x79, 0x02, 0xae, 0x2a, 0x0f,
|
||||
0x34, 0x12, 0xd6, 0x89, 0xd8, 0xd2, 0x7f, 0x87, 0xec, 0x53, 0x64, 0xf7, 0x04, 0x5c, 0x19, 0xf6,
|
||||
0xda, 0xe6, 0x7f, 0x42, 0xb6, 0x41, 0xd6, 0xc7, 0xd8, 0x38, 0xe0, 0x0a, 0xe8, 0xbb, 0x21, 0xe6,
|
||||
0x6e, 0x29, 0x16, 0xee, 0xbc, 0x17, 0x62, 0x44, 0xdf, 0xe4, 0x2e, 0x9e, 0x45, 0xe9, 0x60, 0xc6,
|
||||
0x95, 0x02, 0x69, 0xe9, 0xfb, 0x21, 0xc6, 0x6d, 0x0c, 0xa9, 0xbe, 0x82, 0x1a, 0xfc, 0x01, 0x7e,
|
||||
0x08, 0xcc, 0x2b, 0x7f, 0x29, 0x03, 0xb3, 0x28, 0x37, 0x3e, 0x0c, 0x31, 0x03, 0xb9, 0xfe, 0xc7,
|
||||
0x77, 0x3e, 0x0a, 0xd9, 0xa7, 0xc9, 0x5e, 0xfe, 0x88, 0x97, 0xf1, 0xc7, 0xcd, 0x29, 0x0c, 0xd5,
|
||||
0xa5, 0xa6, 0x6f, 0x37, 0x4b, 0xc6, 0x08, 0xa4, 0xe3, 0xa5, 0xdd, 0x37, 0x9a, 0x98, 0xa2, 0xc2,
|
||||
0xc2, 0xab, 0xfe, 0xa9, 0xc9, 0x36, 0x09, 0xc9, 0x9f, 0x94, 0x07, 0xfe, 0xdc, 0x44, 0xd7, 0x4f,
|
||||
0xc0, 0xe1, 0x8f, 0x70, 0x05, 0x66, 0xe1, 0xd1, 0xbf, 0x2c, 0xd1, 0x7a, 0xa7, 0xa1, 0x7f, 0x6d,
|
||||
0x62, 0x28, 0xce, 0x45, 0x0a, 0xe7, 0x22, 0x7e, 0x41, 0x7f, 0xd0, 0xc6, 0x50, 0x78, 0x4f, 0xcf,
|
||||
0x74, 0x02, 0xa8, 0x63, 0xe9, 0x0f, 0xdb, 0x98, 0x6f, 0x2c, 0xa3, 0x3c, 0xdf, 0x3f, 0xf2, 0x72,
|
||||
0xd1, 0x2c, 0x87, 0x11, 0xfd, 0x31, 0xfe, 0x4c, 0xa4, 0x90, 0xcf, 0x27, 0x4f, 0xe8, 0x4f, 0xda,
|
||||
0x78, 0xd4, 0xa1, 0x94, 0x3a, 0xe6, 0xae, 0x2c, 0xe6, 0x9f, 0xb6, 0xf1, 0x35, 0xd4, 0x4e, 0x2f,
|
||||
0xb2, 0xf1, 0xb3, 0x36, 0xc6, 0xb4, 0xc0, 0x7d, 0xad, 0x44, 0xd8, 0xff, 0x7e, 0xee, 0x59, 0x71,
|
||||
0xe0, 0x42, 0x4f, 0xce, 0x1d, 0xfd, 0x45, 0xfb, 0x60, 0x9f, 0xb4, 0x22, 0x2b, 0x7d, 0x07, 0x6b,
|
||||
0x91, 0x30, 0xb2, 0x92, 0xae, 0xe0, 0x83, 0xef, 0x6b, 0x2d, 0x8f, 0xae, 0xe7, 0xe6, 0xd9, 0xe7,
|
||||
0x68, 0x70, 0xd0, 0x27, 0x9b, 0x03, 0x9d, 0xce, 0x79, 0x59, 0x11, 0xbe, 0x69, 0xe5, 0xdd, 0x0e,
|
||||
0x92, 0xfc, 0xd6, 0x2b, 0xd8, 0x35, 0x8e, 0xae, 0x21, 0xce, 0x1c, 0x36, 0xca, 0x00, 0x45, 0x34,
|
||||
0xc2, 0xa2, 0x4d, 0x68, 0xe3, 0xe0, 0x2d, 0x42, 0x07, 0x5a, 0x59, 0x61, 0x1d, 0xa8, 0x78, 0xf1,
|
||||
0x18, 0xae, 0x40, 0xfa, 0x96, 0xeb, 0x8c, 0x56, 0x53, 0xba, 0xe2, 0x07, 0x09, 0xf0, 0x03, 0x41,
|
||||
0xde, 0x98, 0xfb, 0xf8, 0x73, 0xfa, 0x69, 0xa1, 0x47, 0xc8, 0xd1, 0x15, 0x28, 0x97, 0x71, 0x29,
|
||||
0x17, 0x34, 0x44, 0x79, 0x90, 0x59, 0xa7, 0x53, 0xf1, 0x75, 0xdf, 0xf9, 0xbf, 0x1d, 0x90, 0xce,
|
||||
0x30, 0xc5, 0x79, 0xae, 0x74, 0x2d, 0x17, 0x47, 0xa0, 0x12, 0xe1, 0xc9, 0xf1, 0xb3, 0xf3, 0x50,
|
||||
0xf1, 0x5d, 0x04, 0x95, 0xd2, 0xc4, 0x71, 0xe3, 0x96, 0x53, 0x49, 0x0e, 0x45, 0xfa, 0xa5, 0x92,
|
||||
0x9a, 0x27, 0xfe, 0x2b, 0x28, 0x4d, 0x47, 0xdc, 0x58, 0xff, 0x1f, 0xe0, 0x2c, 0x50, 0xf0, 0x1b,
|
||||
0x7f, 0x9f, 0x84, 0xae, 0x56, 0x60, 0x75, 0xe7, 0xb5, 0xfe, 0x9b, 0xa4, 0x27, 0xf4, 0x72, 0xe0,
|
||||
0x9a, 0x9a, 0x79, 0xdc, 0xef, 0x0c, 0xfc, 0xc0, 0x35, 0xc2, 0xe1, 0x6b, 0x14, 0x7c, 0xf9, 0xc1,
|
||||
0x54, 0xb8, 0x59, 0x76, 0x81, 0x63, 0xd8, 0xfd, 0x5c, 0xed, 0x75, 0xa1, 0x8b, 0xd5, 0x7d, 0xa1,
|
||||
0x1c, 0x18, 0xc5, 0xe5, 0x7d, 0x3f, 0xaa, 0xdd, 0xcf, 0x47, 0xb5, 0xf9, 0xc5, 0x77, 0x82, 0xe0,
|
||||
0x62, 0xcd, 0x43, 0x0f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x5a, 0x7d, 0x9d, 0x36, 0xfe, 0x0b,
|
||||
0x00, 0x00,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -202,11 +202,11 @@ message SegmentLoadInfo {
|
|||
repeated data.FieldBinlog statslogs = 8;
|
||||
repeated data.FieldBinlog deltalogs = 9;
|
||||
repeated int64 compactionFrom = 10; // segmentIDs compacted from
|
||||
repeated VecFieldIndexInfo index_infos = 11;
|
||||
repeated FieldIndexInfo index_infos = 11;
|
||||
int64 segment_size = 12;
|
||||
}
|
||||
|
||||
message VecFieldIndexInfo {
|
||||
message FieldIndexInfo {
|
||||
int64 fieldID =1;
|
||||
bool enable_index = 2;
|
||||
string index_name = 3;
|
||||
|
|
@ -321,7 +321,7 @@ message SegmentInfo {
|
|||
repeated int64 compactionFrom = 10;
|
||||
bool createdByCompaction = 11;
|
||||
common.SegmentState segment_state = 12;
|
||||
repeated VecFieldIndexInfo index_infos = 13;
|
||||
repeated FieldIndexInfo index_infos = 13;
|
||||
repeated int64 replica_ids = 14;
|
||||
repeated int64 node_ids = 15;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1351,7 +1351,7 @@ type SegmentLoadInfo struct {
|
|||
Statslogs []*datapb.FieldBinlog `protobuf:"bytes,8,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
|
||||
Deltalogs []*datapb.FieldBinlog `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
|
||||
CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
|
||||
IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,11,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
|
||||
IndexInfos []*FieldIndexInfo `protobuf:"bytes,11,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
|
||||
SegmentSize int64 `protobuf:"varint,12,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
|
|
@ -1453,7 +1453,7 @@ func (m *SegmentLoadInfo) GetCompactionFrom() []int64 {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (m *SegmentLoadInfo) GetIndexInfos() []*VecFieldIndexInfo {
|
||||
func (m *SegmentLoadInfo) GetIndexInfos() []*FieldIndexInfo {
|
||||
if m != nil {
|
||||
return m.IndexInfos
|
||||
}
|
||||
|
|
@ -1467,7 +1467,7 @@ func (m *SegmentLoadInfo) GetSegmentSize() int64 {
|
|||
return 0
|
||||
}
|
||||
|
||||
type VecFieldIndexInfo struct {
|
||||
type FieldIndexInfo struct {
|
||||
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
|
||||
EnableIndex bool `protobuf:"varint,2,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"`
|
||||
IndexName string `protobuf:"bytes,3,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
|
||||
|
|
@ -1481,81 +1481,81 @@ type VecFieldIndexInfo struct {
|
|||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) Reset() { *m = VecFieldIndexInfo{} }
|
||||
func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*VecFieldIndexInfo) ProtoMessage() {}
|
||||
func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) {
|
||||
func (m *FieldIndexInfo) Reset() { *m = FieldIndexInfo{} }
|
||||
func (m *FieldIndexInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*FieldIndexInfo) ProtoMessage() {}
|
||||
func (*FieldIndexInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_aab7cc9a69ed26e8, []int{20}
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_VecFieldIndexInfo.Unmarshal(m, b)
|
||||
func (m *FieldIndexInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_FieldIndexInfo.Unmarshal(m, b)
|
||||
}
|
||||
func (m *VecFieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_VecFieldIndexInfo.Marshal(b, m, deterministic)
|
||||
func (m *FieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_FieldIndexInfo.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *VecFieldIndexInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_VecFieldIndexInfo.Merge(m, src)
|
||||
func (m *FieldIndexInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_FieldIndexInfo.Merge(m, src)
|
||||
}
|
||||
func (m *VecFieldIndexInfo) XXX_Size() int {
|
||||
return xxx_messageInfo_VecFieldIndexInfo.Size(m)
|
||||
func (m *FieldIndexInfo) XXX_Size() int {
|
||||
return xxx_messageInfo_FieldIndexInfo.Size(m)
|
||||
}
|
||||
func (m *VecFieldIndexInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_VecFieldIndexInfo.DiscardUnknown(m)
|
||||
func (m *FieldIndexInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_FieldIndexInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_VecFieldIndexInfo proto.InternalMessageInfo
|
||||
var xxx_messageInfo_FieldIndexInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *VecFieldIndexInfo) GetFieldID() int64 {
|
||||
func (m *FieldIndexInfo) GetFieldID() int64 {
|
||||
if m != nil {
|
||||
return m.FieldID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetEnableIndex() bool {
|
||||
func (m *FieldIndexInfo) GetEnableIndex() bool {
|
||||
if m != nil {
|
||||
return m.EnableIndex
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetIndexName() string {
|
||||
func (m *FieldIndexInfo) GetIndexName() string {
|
||||
if m != nil {
|
||||
return m.IndexName
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetIndexID() int64 {
|
||||
func (m *FieldIndexInfo) GetIndexID() int64 {
|
||||
if m != nil {
|
||||
return m.IndexID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetBuildID() int64 {
|
||||
func (m *FieldIndexInfo) GetBuildID() int64 {
|
||||
if m != nil {
|
||||
return m.BuildID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair {
|
||||
func (m *FieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair {
|
||||
if m != nil {
|
||||
return m.IndexParams
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetIndexFilePaths() []string {
|
||||
func (m *FieldIndexInfo) GetIndexFilePaths() []string {
|
||||
if m != nil {
|
||||
return m.IndexFilePaths
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *VecFieldIndexInfo) GetIndexSize() int64 {
|
||||
func (m *FieldIndexInfo) GetIndexSize() int64 {
|
||||
if m != nil {
|
||||
return m.IndexSize
|
||||
}
|
||||
|
|
@ -2152,7 +2152,7 @@ type SegmentInfo struct {
|
|||
CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
|
||||
CreatedByCompaction bool `protobuf:"varint,11,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"`
|
||||
SegmentState commonpb.SegmentState `protobuf:"varint,12,opt,name=segment_state,json=segmentState,proto3,enum=milvus.proto.common.SegmentState" json:"segment_state,omitempty"`
|
||||
IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,13,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
|
||||
IndexInfos []*FieldIndexInfo `protobuf:"bytes,13,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
|
||||
ReplicaIds []int64 `protobuf:"varint,14,rep,packed,name=replica_ids,json=replicaIds,proto3" json:"replica_ids,omitempty"`
|
||||
NodeIds []int64 `protobuf:"varint,15,rep,packed,name=node_ids,json=nodeIds,proto3" json:"node_ids,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
|
|
@ -2269,7 +2269,7 @@ func (m *SegmentInfo) GetSegmentState() commonpb.SegmentState {
|
|||
return commonpb.SegmentState_SegmentStateNone
|
||||
}
|
||||
|
||||
func (m *SegmentInfo) GetIndexInfos() []*VecFieldIndexInfo {
|
||||
func (m *SegmentInfo) GetIndexInfos() []*FieldIndexInfo {
|
||||
if m != nil {
|
||||
return m.IndexInfos
|
||||
}
|
||||
|
|
@ -2732,7 +2732,7 @@ func init() {
|
|||
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
|
||||
proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest")
|
||||
proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo")
|
||||
proto.RegisterType((*VecFieldIndexInfo)(nil), "milvus.proto.query.VecFieldIndexInfo")
|
||||
proto.RegisterType((*FieldIndexInfo)(nil), "milvus.proto.query.FieldIndexInfo")
|
||||
proto.RegisterType((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest")
|
||||
proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest")
|
||||
proto.RegisterType((*SearchRequest)(nil), "milvus.proto.query.SearchRequest")
|
||||
|
|
@ -2755,174 +2755,174 @@ func init() {
|
|||
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
|
||||
|
||||
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
|
||||
// 2667 bytes of a gzipped FileDescriptorProto
|
||||
// 2664 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x1a, 0x4d, 0x6f, 0x1c, 0x49,
|
||||
0xd5, 0x3d, 0x5f, 0xf6, 0xbc, 0xf9, 0x74, 0x39, 0x31, 0x93, 0x61, 0x77, 0xe3, 0x74, 0xd6, 0x49,
|
||||
0xc8, 0xb2, 0x4e, 0x70, 0x16, 0x89, 0x15, 0x70, 0x58, 0xdb, 0xc4, 0x6b, 0xb2, 0xf1, 0x3a, 0x6d,
|
||||
0x27, 0x40, 0x14, 0x69, 0xe8, 0x99, 0x2e, 0x8f, 0x5b, 0xe9, 0x8f, 0x49, 0x57, 0xcf, 0x26, 0x0e,
|
||||
0xd7, 0x15, 0xe2, 0x43, 0x08, 0x71, 0x45, 0x88, 0x13, 0x08, 0xf6, 0xb0, 0x17, 0xce, 0x1c, 0xb8,
|
||||
0x70, 0xe3, 0x17, 0x70, 0x40, 0xdc, 0xe0, 0x0f, 0x70, 0x44, 0xa0, 0xfa, 0xea, 0xe9, 0x8f, 0x1a,
|
||||
0xbb, 0x6d, 0x6f, 0x36, 0x11, 0xe2, 0x36, 0xf5, 0xfa, 0xd5, 0x7b, 0xaf, 0xde, 0x77, 0xd5, 0x1b,
|
||||
0x98, 0x7f, 0x32, 0xc6, 0xc1, 0x61, 0x6f, 0xe0, 0xfb, 0x81, 0xb5, 0x32, 0x0a, 0xfc, 0xd0, 0x47,
|
||||
0xc8, 0xb5, 0x9d, 0x8f, 0xc6, 0x84, 0xaf, 0x56, 0xd8, 0xf7, 0x6e, 0x7d, 0xe0, 0xbb, 0xae, 0xef,
|
||||
0x71, 0x58, 0xb7, 0x1e, 0xc7, 0xe8, 0x36, 0x6d, 0x2f, 0xc4, 0x81, 0x67, 0x3a, 0xf2, 0x2b, 0x19,
|
||||
0x1c, 0x60, 0xd7, 0x14, 0xab, 0xb6, 0x65, 0x86, 0x66, 0x9c, 0xbe, 0xfe, 0xb1, 0x06, 0x8b, 0xbb,
|
||||
0x07, 0xfe, 0xd3, 0x75, 0xdf, 0x71, 0xf0, 0x20, 0xb4, 0x7d, 0x8f, 0x18, 0xf8, 0xc9, 0x18, 0x93,
|
||||
0x10, 0xdd, 0x84, 0x52, 0xdf, 0x24, 0xb8, 0xa3, 0x2d, 0x69, 0xd7, 0x6a, 0xab, 0xaf, 0xad, 0x24,
|
||||
0x24, 0x11, 0x22, 0xdc, 0x25, 0xc3, 0x35, 0x93, 0x60, 0x83, 0x61, 0x22, 0x04, 0x25, 0xab, 0xbf,
|
||||
0xb5, 0xd1, 0x29, 0x2c, 0x69, 0xd7, 0x8a, 0x06, 0xfb, 0x8d, 0xde, 0x84, 0xc6, 0x20, 0xa2, 0xbd,
|
||||
0xb5, 0x41, 0x3a, 0xc5, 0xa5, 0xe2, 0xb5, 0xa2, 0x91, 0x04, 0xea, 0xbf, 0xd3, 0xe0, 0x0b, 0x19,
|
||||
0x31, 0xc8, 0xc8, 0xf7, 0x08, 0x46, 0xb7, 0xa0, 0x42, 0x42, 0x33, 0x1c, 0x13, 0x21, 0xc9, 0x17,
|
||||
0x95, 0x92, 0xec, 0x32, 0x14, 0x43, 0xa0, 0x66, 0xd9, 0x16, 0x14, 0x6c, 0xd1, 0x57, 0xe0, 0x9c,
|
||||
0xed, 0xdd, 0xc5, 0xae, 0x1f, 0x1c, 0xf6, 0x46, 0x38, 0x18, 0x60, 0x2f, 0x34, 0x87, 0x58, 0xca,
|
||||
0xb8, 0x20, 0xbf, 0xed, 0x4c, 0x3e, 0xe9, 0xbf, 0xd5, 0xe0, 0x3c, 0x95, 0x74, 0xc7, 0x0c, 0x42,
|
||||
0xfb, 0x05, 0xe8, 0x4b, 0x87, 0x7a, 0x5c, 0xc6, 0x4e, 0x91, 0x7d, 0x4b, 0xc0, 0x28, 0xce, 0x48,
|
||||
0xb2, 0xa7, 0x67, 0x2b, 0x31, 0x71, 0x13, 0x30, 0xfd, 0x37, 0xc2, 0xb0, 0x71, 0x39, 0xcf, 0xa2,
|
||||
0xd0, 0x34, 0xcf, 0x42, 0x96, 0xe7, 0x69, 0xd4, 0xf9, 0x0f, 0x0d, 0xce, 0x7f, 0xe0, 0x9b, 0xd6,
|
||||
0xc4, 0xf0, 0x9f, 0xbf, 0x3a, 0xbf, 0x09, 0x15, 0x1e, 0x25, 0x9d, 0x12, 0xe3, 0xb5, 0x9c, 0xe4,
|
||||
0x25, 0x22, 0x68, 0x22, 0xe1, 0x2e, 0x03, 0x18, 0x62, 0x13, 0x5a, 0x86, 0x66, 0x80, 0x47, 0x8e,
|
||||
0x3d, 0x30, 0x7b, 0xde, 0xd8, 0xed, 0xe3, 0xa0, 0x53, 0x5e, 0xd2, 0xae, 0x95, 0x8d, 0x86, 0x80,
|
||||
0x6e, 0x33, 0xa0, 0xfe, 0x2b, 0x0d, 0x3a, 0x06, 0x76, 0xb0, 0x49, 0xf0, 0xcb, 0x3c, 0xec, 0x22,
|
||||
0x54, 0x3c, 0xdf, 0xc2, 0x5b, 0x1b, 0xec, 0xb0, 0x45, 0x43, 0xac, 0xf4, 0x9f, 0x16, 0xb8, 0x21,
|
||||
0x5e, 0x71, 0xbf, 0x8e, 0x19, 0xab, 0xfc, 0xd9, 0x18, 0xab, 0xa2, 0x32, 0xd6, 0x9f, 0x26, 0xc6,
|
||||
0x7a, 0xd5, 0x15, 0x32, 0x31, 0x68, 0x39, 0x61, 0xd0, 0xef, 0xc1, 0x85, 0xf5, 0x00, 0x9b, 0x21,
|
||||
0xbe, 0x47, 0x8b, 0xc6, 0xfa, 0x81, 0xe9, 0x79, 0xd8, 0x91, 0x47, 0x48, 0x33, 0xd7, 0x14, 0xcc,
|
||||
0x3b, 0x30, 0x3b, 0x0a, 0xfc, 0x67, 0x87, 0x91, 0xdc, 0x72, 0xa9, 0xff, 0x5e, 0x83, 0xae, 0x8a,
|
||||
0xf6, 0x59, 0xf2, 0xcb, 0x65, 0x68, 0x88, 0xea, 0xc7, 0xa9, 0x31, 0x9e, 0x55, 0xa3, 0xfe, 0x24,
|
||||
0xc6, 0x01, 0xdd, 0x84, 0x73, 0x1c, 0x29, 0xc0, 0x64, 0xec, 0x84, 0x11, 0x6e, 0x91, 0xe1, 0x22,
|
||||
0xf6, 0xcd, 0x60, 0x9f, 0xc4, 0x0e, 0xfd, 0x13, 0x0d, 0x2e, 0x6c, 0xe2, 0x30, 0x32, 0x22, 0xe5,
|
||||
0x8a, 0x5f, 0xd1, 0x94, 0xfd, 0xa9, 0x06, 0x5d, 0x95, 0xac, 0x67, 0x51, 0xeb, 0x43, 0x58, 0x8c,
|
||||
0x78, 0xf4, 0x2c, 0x4c, 0x06, 0x81, 0x3d, 0x62, 0xce, 0xcc, 0x12, 0x78, 0x6d, 0xf5, 0xf2, 0x4a,
|
||||
0xb6, 0xc1, 0x58, 0x49, 0x4b, 0x70, 0x3e, 0x22, 0xb1, 0x11, 0xa3, 0xa0, 0xff, 0x4c, 0x83, 0xf3,
|
||||
0x9b, 0x38, 0xdc, 0xc5, 0x43, 0x17, 0x7b, 0xe1, 0x96, 0xb7, 0xef, 0x9f, 0x5e, 0xaf, 0x6f, 0x00,
|
||||
0x10, 0x41, 0x27, 0x2a, 0x2e, 0x31, 0x48, 0x1e, 0x1d, 0xb3, 0x5e, 0x26, 0x2d, 0xcf, 0x59, 0x74,
|
||||
0xf7, 0x55, 0x28, 0xdb, 0xde, 0xbe, 0x2f, 0x55, 0x75, 0x51, 0xa5, 0xaa, 0x38, 0x33, 0x8e, 0xad,
|
||||
0xff, 0xbb, 0x00, 0x8b, 0xef, 0x59, 0x96, 0x2a, 0xec, 0x4e, 0xae, 0x97, 0x49, 0x74, 0x17, 0xe2,
|
||||
0xd1, 0x9d, 0xcb, 0xe7, 0x32, 0x21, 0x55, 0x3a, 0x41, 0x48, 0x95, 0xa7, 0x85, 0x14, 0xda, 0x84,
|
||||
0x06, 0xc1, 0xf8, 0x71, 0x6f, 0xe4, 0x13, 0xe6, 0x13, 0x2c, 0x83, 0xd6, 0x56, 0xf5, 0xe4, 0x69,
|
||||
0xa2, 0x3e, 0xf4, 0x2e, 0x19, 0xee, 0x08, 0x4c, 0xa3, 0x4e, 0x37, 0xca, 0x15, 0xba, 0x0f, 0x8b,
|
||||
0x43, 0xc7, 0xef, 0x9b, 0x4e, 0x8f, 0x60, 0xd3, 0xc1, 0x56, 0x4f, 0xd8, 0x9b, 0x74, 0x66, 0xf3,
|
||||
0x29, 0xfc, 0x1c, 0xdf, 0xbe, 0xcb, 0x76, 0x8b, 0x0f, 0x44, 0xff, 0xbb, 0x06, 0x17, 0x0c, 0xec,
|
||||
0xfa, 0x1f, 0xe1, 0xff, 0x55, 0x13, 0xe8, 0xbf, 0xd0, 0xa0, 0x4e, 0x8b, 0xf5, 0x5d, 0x1c, 0x9a,
|
||||
0x54, 0x13, 0xe8, 0x5d, 0xa8, 0x3a, 0xbe, 0x69, 0xf5, 0xc2, 0xc3, 0x11, 0x3f, 0x5a, 0x33, 0x7d,
|
||||
0x34, 0xae, 0x3d, 0xba, 0x69, 0xef, 0x70, 0x84, 0x8d, 0x39, 0x47, 0xfc, 0xca, 0x1c, 0xa3, 0x90,
|
||||
0x23, 0x7b, 0x15, 0x55, 0x0d, 0x67, 0x11, 0x16, 0xbf, 0x63, 0x86, 0x83, 0x83, 0x0d, 0x57, 0x88,
|
||||
0x49, 0x5e, 0x8e, 0xce, 0xf3, 0x14, 0xcd, 0x28, 0xb4, 0xcb, 0x2a, 0x4f, 0xa3, 0xb7, 0xa4, 0x95,
|
||||
0x07, 0xc2, 0x0c, 0xb1, 0xd0, 0x8e, 0x35, 0x1f, 0x95, 0xd3, 0x34, 0x1f, 0xeb, 0xd0, 0xc0, 0xcf,
|
||||
0x06, 0xce, 0xd8, 0xc2, 0x3d, 0xce, 0x9d, 0xfb, 0xf9, 0x1b, 0x0a, 0xee, 0x71, 0x37, 0xaf, 0x8b,
|
||||
0x4d, 0x5b, 0x42, 0x06, 0x6e, 0x6a, 0x17, 0x87, 0x66, 0x67, 0x8e, 0x89, 0xb1, 0x34, 0xcd, 0xd4,
|
||||
0xd2, 0x3f, 0xb8, 0xb9, 0xe9, 0x4a, 0xff, 0x8f, 0x06, 0x17, 0xb8, 0x99, 0xb0, 0x13, 0x9a, 0x2f,
|
||||
0xd7, 0x52, 0x91, 0x15, 0x4a, 0x27, 0xb4, 0x42, 0x4c, 0x03, 0xd5, 0x13, 0x6b, 0xe0, 0x97, 0x25,
|
||||
0x68, 0x09, 0xf5, 0x52, 0x0c, 0x16, 0x3f, 0xaf, 0x41, 0x35, 0x2a, 0x36, 0xa2, 0x19, 0x9a, 0x00,
|
||||
0xd0, 0x12, 0xd4, 0x62, 0xde, 0x23, 0x0e, 0x1a, 0x07, 0xe5, 0x3a, 0xad, 0x6c, 0x1d, 0x4a, 0xb1,
|
||||
0xd6, 0xe1, 0x75, 0x80, 0x7d, 0x67, 0x4c, 0x0e, 0x7a, 0xa1, 0xed, 0x62, 0xd1, 0xc0, 0x55, 0x19,
|
||||
0x64, 0xcf, 0x76, 0x31, 0x7a, 0x0f, 0xea, 0x7d, 0xdb, 0x73, 0xfc, 0x61, 0x6f, 0x64, 0x86, 0x07,
|
||||
0xa4, 0x53, 0x99, 0xea, 0x2f, 0xb7, 0x6d, 0xec, 0x58, 0x6b, 0x0c, 0xd7, 0xa8, 0xf1, 0x3d, 0x3b,
|
||||
0x74, 0x0b, 0x7a, 0x03, 0x6a, 0xde, 0xd8, 0xed, 0xf9, 0xfb, 0xbd, 0xc0, 0x7f, 0x4a, 0x3d, 0x8e,
|
||||
0xb1, 0xf0, 0xc6, 0xee, 0x87, 0xfb, 0x86, 0xff, 0x94, 0xa0, 0x6f, 0x40, 0x95, 0x96, 0x3b, 0xe2,
|
||||
0xf8, 0x43, 0xd2, 0x99, 0xcb, 0x45, 0x7f, 0xb2, 0x81, 0xee, 0xb6, 0xa8, 0x1f, 0xb1, 0xdd, 0xd5,
|
||||
0x7c, 0xbb, 0xa3, 0x0d, 0xe8, 0x0a, 0x34, 0x07, 0xbe, 0x3b, 0x32, 0x99, 0x86, 0x6e, 0x07, 0xbe,
|
||||
0xdb, 0x01, 0x16, 0xab, 0x29, 0x28, 0xba, 0x0d, 0x35, 0xdb, 0xb3, 0xf0, 0x33, 0x11, 0x35, 0x35,
|
||||
0xc6, 0x67, 0x59, 0x65, 0xf2, 0x07, 0x78, 0xc0, 0x78, 0x6d, 0x51, 0x74, 0x66, 0x77, 0xb0, 0xe5,
|
||||
0x4f, 0x82, 0x2e, 0x41, 0x5d, 0x18, 0xb5, 0x47, 0xec, 0xe7, 0xb8, 0x53, 0xe7, 0x86, 0x14, 0xb0,
|
||||
0x5d, 0xfb, 0x39, 0xd6, 0xff, 0x50, 0x80, 0xf9, 0x0c, 0x11, 0xda, 0x0a, 0xef, 0x33, 0x88, 0x74,
|
||||
0x0e, 0xb9, 0xa4, 0x24, 0xb1, 0x67, 0xf6, 0x1d, 0x1a, 0xd1, 0x16, 0x7e, 0xc6, 0x7c, 0x63, 0xce,
|
||||
0xa8, 0x71, 0x18, 0x23, 0x40, 0x6d, 0xcc, 0xa5, 0xf7, 0x4c, 0x17, 0x8b, 0x56, 0xb5, 0xca, 0x20,
|
||||
0xdb, 0xa6, 0x8b, 0x29, 0x6d, 0x2e, 0xa2, 0xf4, 0x0c, 0xb9, 0xa4, 0x5f, 0xfa, 0x63, 0x9b, 0x71,
|
||||
0xe5, 0x9e, 0x21, 0x97, 0x68, 0x03, 0xea, 0x9c, 0xe4, 0xc8, 0x0c, 0x4c, 0x57, 0xfa, 0xc5, 0x25,
|
||||
0x65, 0xb8, 0xde, 0xc1, 0x87, 0x0f, 0x4c, 0x67, 0x8c, 0x77, 0x4c, 0x3b, 0x30, 0xb8, 0x1e, 0x77,
|
||||
0xd8, 0x2e, 0x74, 0x0d, 0xda, 0x9c, 0xca, 0xbe, 0xed, 0x60, 0xe1, 0x61, 0x34, 0x23, 0x55, 0x8d,
|
||||
0x26, 0x83, 0xdf, 0xb6, 0x1d, 0xcc, 0x9d, 0x28, 0x3a, 0x02, 0x53, 0xdb, 0x1c, 0xf7, 0x21, 0x06,
|
||||
0x61, 0x4a, 0xfb, 0x67, 0x01, 0x16, 0x68, 0x28, 0xc9, 0x12, 0x7c, 0xfa, 0x6c, 0xf2, 0x3a, 0x80,
|
||||
0x45, 0xc2, 0x5e, 0x22, 0xa3, 0x54, 0x2d, 0x12, 0x6e, 0xf3, 0xa4, 0xf2, 0xae, 0x4c, 0x18, 0xc5,
|
||||
0xe9, 0xcd, 0x6b, 0x2a, 0xb4, 0xb3, 0xa9, 0xfb, 0x54, 0x97, 0xfc, 0xcb, 0xd0, 0x20, 0xfe, 0x38,
|
||||
0x18, 0xe0, 0x5e, 0xe2, 0xb2, 0x55, 0xe7, 0xc0, 0x6d, 0x75, 0xce, 0xab, 0x28, 0x1f, 0x1b, 0x62,
|
||||
0xc9, 0x6b, 0xf6, 0xc4, 0xc9, 0xeb, 0x6f, 0x1a, 0x2c, 0x8a, 0x8b, 0xe9, 0xd9, 0xb5, 0x3d, 0x2d,
|
||||
0x77, 0xcb, 0x4c, 0x55, 0x3c, 0xe2, 0x92, 0x53, 0xca, 0x51, 0x79, 0xcb, 0x8a, 0xca, 0x9b, 0x6c,
|
||||
0xf4, 0x2b, 0xe9, 0x46, 0x5f, 0xff, 0xa1, 0x06, 0x8d, 0x5d, 0x6c, 0x06, 0x83, 0x03, 0x79, 0xae,
|
||||
0x77, 0xa0, 0x18, 0xe0, 0x27, 0xe2, 0x58, 0xa9, 0x2e, 0x53, 0x2c, 0x12, 0x1b, 0x0c, 0x8a, 0x8e,
|
||||
0x2e, 0x42, 0xcd, 0x72, 0x9d, 0xd4, 0x6d, 0x12, 0x2c, 0xd7, 0x91, 0x5d, 0x57, 0x52, 0x90, 0x62,
|
||||
0x46, 0x90, 0x8f, 0x35, 0xa8, 0xdf, 0xe3, 0xad, 0x17, 0x97, 0xe3, 0x56, 0x5c, 0x8e, 0x4b, 0x4a,
|
||||
0x39, 0xe2, 0xf8, 0x9f, 0x91, 0x18, 0x3f, 0xd7, 0x60, 0xf1, 0x7d, 0xd3, 0xb3, 0xfc, 0xfd, 0xfd,
|
||||
0xb3, 0x1b, 0x7c, 0x3d, 0x4a, 0x80, 0x5b, 0x27, 0xb9, 0xd8, 0x24, 0x36, 0xe9, 0x3f, 0x2a, 0x00,
|
||||
0xa2, 0xde, 0xb9, 0x66, 0x3a, 0xa6, 0x37, 0xc0, 0xa7, 0x97, 0x66, 0x19, 0x9a, 0x89, 0x98, 0x8a,
|
||||
0x1e, 0x69, 0xe3, 0x41, 0x45, 0xd0, 0x1d, 0x68, 0xf6, 0x39, 0xab, 0x5e, 0x80, 0x4d, 0xe2, 0x7b,
|
||||
0xcc, 0x2f, 0x9b, 0xab, 0x6f, 0xaa, 0xc4, 0xde, 0x0b, 0xec, 0xe1, 0x10, 0x07, 0xeb, 0xbe, 0x67,
|
||||
0xf1, 0x2b, 0x47, 0xa3, 0x2f, 0xc5, 0xa4, 0x5b, 0x99, 0x3d, 0xa2, 0x04, 0x23, 0x7b, 0x43, 0x88,
|
||||
0x32, 0x0c, 0x41, 0x6f, 0xc1, 0x7c, 0xf2, 0x36, 0x32, 0x71, 0xe4, 0x36, 0x89, 0x5f, 0x34, 0xa8,
|
||||
0x71, 0x7e, 0x00, 0x28, 0xea, 0x76, 0x59, 0x53, 0xc5, 0xaa, 0x45, 0x9e, 0xc7, 0x95, 0xd7, 0xa0,
|
||||
0x6a, 0xc9, 0x9d, 0xc2, 0x2b, 0x26, 0x00, 0x9a, 0x6d, 0xb8, 0x84, 0x3d, 0x1a, 0xf8, 0xd8, 0x92,
|
||||
0xfd, 0x04, 0x07, 0x7e, 0xc0, 0x60, 0xfa, 0xa7, 0x05, 0x68, 0xc7, 0x6f, 0x38, 0xb9, 0x79, 0xbf,
|
||||
0x98, 0xa7, 0x96, 0x23, 0xae, 0x73, 0xa5, 0x33, 0x5c, 0xe7, 0xb2, 0xd7, 0xcd, 0xf2, 0xe9, 0xae,
|
||||
0x9b, 0xfa, 0xaf, 0x35, 0x68, 0xa5, 0x5e, 0x36, 0xd2, 0x9d, 0x9d, 0x96, 0xed, 0xec, 0xbe, 0x06,
|
||||
0x65, 0xda, 0xee, 0x60, 0xa6, 0xa4, 0x66, 0x9a, 0xad, 0xea, 0xbd, 0xc4, 0xe0, 0x1b, 0xd0, 0x0d,
|
||||
0x58, 0x50, 0xbc, 0x86, 0x0b, 0x53, 0xa2, 0xec, 0x63, 0xb8, 0xfe, 0xc7, 0x12, 0xd4, 0x62, 0xfa,
|
||||
0x38, 0xa6, 0x29, 0xcd, 0x73, 0x6f, 0x4b, 0x1d, 0xaf, 0x98, 0x3d, 0xde, 0x94, 0xe7, 0x60, 0x74,
|
||||
0x01, 0xe6, 0x5c, 0xec, 0xf2, 0x7a, 0x2f, 0x9a, 0x0f, 0x17, 0xbb, 0xb4, 0xda, 0xd3, 0x4f, 0xb4,
|
||||
0xa3, 0x64, 0xed, 0x24, 0xaf, 0x70, 0xb3, 0xde, 0xd8, 0x65, 0xcd, 0x64, 0xb2, 0xd5, 0x99, 0x3d,
|
||||
0xa2, 0xd5, 0x99, 0x4b, 0xb6, 0x3a, 0x89, 0x70, 0xa8, 0xa6, 0xc3, 0x21, 0x6f, 0x9f, 0x78, 0x13,
|
||||
0x16, 0x06, 0xec, 0x59, 0xd2, 0x5a, 0x3b, 0x5c, 0x8f, 0x3e, 0x75, 0x6a, 0xac, 0x27, 0x53, 0x7d,
|
||||
0x42, 0xb7, 0xa9, 0x73, 0x89, 0x8e, 0x90, 0x59, 0xb9, 0xce, 0xac, 0xac, 0xee, 0xa4, 0x84, 0x6d,
|
||||
0xb8, 0x91, 0x65, 0x4e, 0x64, 0xab, 0x74, 0x87, 0xda, 0x38, 0x6d, 0x87, 0x7a, 0x11, 0x6a, 0xf2,
|
||||
0x79, 0xda, 0xb6, 0x48, 0xa7, 0xc9, 0xd3, 0x93, 0x00, 0x6d, 0x59, 0x84, 0x29, 0xdf, 0xa7, 0xf7,
|
||||
0x47, 0x8b, 0x74, 0x5a, 0xec, 0xeb, 0x2c, 0xb3, 0x98, 0x45, 0xf4, 0x4f, 0x8a, 0xd0, 0x9c, 0xf4,
|
||||
0x2f, 0xb9, 0xb3, 0x41, 0x9e, 0xc1, 0xce, 0x36, 0xb4, 0x27, 0xaf, 0x88, 0x4c, 0x51, 0x47, 0xb6,
|
||||
0x60, 0xe9, 0xf7, 0xc3, 0xd6, 0x28, 0x15, 0x76, 0x89, 0xe7, 0x8a, 0xd2, 0x89, 0x9e, 0x2b, 0xce,
|
||||
0xf8, 0xfe, 0x7f, 0x0b, 0xce, 0x07, 0xbc, 0x7d, 0xb2, 0x7a, 0x89, 0x63, 0xf3, 0x4e, 0xe4, 0x9c,
|
||||
0xfc, 0xb8, 0x13, 0x3f, 0xfe, 0x94, 0x48, 0x9e, 0x9d, 0x16, 0xc9, 0x69, 0x33, 0xce, 0xa5, 0xcd,
|
||||
0xa8, 0xdf, 0x87, 0x85, 0xfb, 0x1e, 0x19, 0xf7, 0xc9, 0x20, 0xb0, 0xfb, 0x58, 0xde, 0xc2, 0x73,
|
||||
0xd9, 0xab, 0x0b, 0x73, 0x22, 0x17, 0x73, 0x5b, 0x55, 0x8d, 0x68, 0xad, 0xff, 0x44, 0x83, 0xc5,
|
||||
0x2c, 0x5d, 0xe6, 0x0a, 0x93, 0x40, 0xd7, 0x12, 0x81, 0xfe, 0x5d, 0x58, 0x98, 0x90, 0xef, 0x25,
|
||||
0x28, 0xd7, 0x56, 0xaf, 0xaa, 0x8c, 0xa2, 0x10, 0xdc, 0x40, 0x13, 0x1a, 0x12, 0xa6, 0xff, 0x4b,
|
||||
0x83, 0x79, 0x11, 0x32, 0x14, 0x36, 0x64, 0xef, 0x17, 0xb4, 0xf8, 0xf8, 0x9e, 0x63, 0x7b, 0x51,
|
||||
0x23, 0x2d, 0xce, 0xc8, 0x81, 0xa2, 0x91, 0x7e, 0x1f, 0x5a, 0x02, 0x29, 0xaa, 0x21, 0x39, 0x5b,
|
||||
0x95, 0x26, 0xdf, 0x17, 0x55, 0x8f, 0x65, 0x68, 0xfa, 0xfb, 0xfb, 0x71, 0x7e, 0x3c, 0x09, 0x36,
|
||||
0x04, 0x54, 0x30, 0xfc, 0x36, 0xb4, 0x25, 0xda, 0x49, 0xab, 0x56, 0x4b, 0x6c, 0x8c, 0xde, 0x1f,
|
||||
0x7f, 0xac, 0x41, 0x27, 0x59, 0xc3, 0x62, 0xc7, 0x3f, 0x79, 0x97, 0xf4, 0xf5, 0xe4, 0x2b, 0xf4,
|
||||
0xf2, 0x11, 0xf2, 0x4c, 0xf8, 0xc8, 0xb7, 0xe8, 0xbf, 0x6a, 0x50, 0x33, 0x84, 0xdb, 0x51, 0xf6,
|
||||
0xaf, 0x03, 0x4c, 0x1c, 0x53, 0xd6, 0x94, 0xc8, 0x2f, 0xa9, 0x71, 0x62, 0xce, 0x60, 0x5b, 0x8a,
|
||||
0xa2, 0xc2, 0x90, 0x26, 0xc9, 0x80, 0xba, 0x77, 0xe6, 0x35, 0xd0, 0xa2, 0x55, 0xbb, 0x49, 0x0e,
|
||||
0xcc, 0xc0, 0xea, 0x09, 0xe2, 0x52, 0x9d, 0xca, 0xbb, 0xce, 0x2e, 0xc5, 0x14, 0x62, 0x1a, 0x0d,
|
||||
0x12, 0x5b, 0x25, 0x13, 0x5e, 0x39, 0x99, 0xf0, 0xb6, 0xa1, 0x1e, 0xdf, 0x49, 0x5d, 0xdc, 0xc1,
|
||||
0xa6, 0x85, 0x03, 0xe9, 0xe2, 0x7c, 0x85, 0xae, 0x40, 0xcb, 0x72, 0xa5, 0x6b, 0xf3, 0xd2, 0xc4,
|
||||
0x3b, 0x9e, 0x46, 0x54, 0x62, 0x68, 0x79, 0xba, 0xfe, 0x1c, 0x9a, 0xc9, 0xcc, 0x85, 0xea, 0x30,
|
||||
0xb7, 0xed, 0x87, 0xdf, 0x7a, 0x66, 0x93, 0xb0, 0x3d, 0x83, 0x9a, 0x00, 0xdb, 0x7e, 0xb8, 0x13,
|
||||
0x60, 0x82, 0xbd, 0xb0, 0xad, 0x21, 0x80, 0xca, 0x87, 0xde, 0x86, 0x4d, 0x1e, 0xb7, 0x0b, 0x68,
|
||||
0x41, 0xf4, 0x16, 0xa6, 0xb3, 0x25, 0xd2, 0x41, 0xbb, 0x48, 0xb7, 0x47, 0xab, 0x12, 0x6a, 0x43,
|
||||
0x3d, 0x42, 0xd9, 0xdc, 0xb9, 0xdf, 0x2e, 0xa3, 0x2a, 0x94, 0xf9, 0xcf, 0xca, 0x75, 0x0b, 0xda,
|
||||
0xe9, 0xd6, 0x95, 0xd2, 0xbc, 0xef, 0xdd, 0xf1, 0xfc, 0xa7, 0x11, 0xa8, 0x3d, 0x83, 0x6a, 0x30,
|
||||
0x2b, 0xae, 0x03, 0x6d, 0x0d, 0xb5, 0xa0, 0x16, 0xeb, 0xc4, 0xdb, 0x05, 0x0a, 0xd8, 0x0c, 0x46,
|
||||
0x03, 0xd1, 0x93, 0x73, 0x11, 0xa8, 0x8b, 0x6f, 0xf8, 0x4f, 0xbd, 0x76, 0xe9, 0xfa, 0x1a, 0xcc,
|
||||
0xc9, 0x94, 0x4a, 0x51, 0x39, 0x75, 0x8f, 0x2e, 0xdb, 0x33, 0x68, 0x1e, 0x1a, 0x89, 0x01, 0x70,
|
||||
0x5b, 0x43, 0x08, 0x9a, 0xc9, 0xe1, 0x7c, 0xbb, 0xb0, 0xfa, 0xe7, 0x1a, 0x00, 0x6f, 0x3b, 0x7d,
|
||||
0x3f, 0xb0, 0xd0, 0x08, 0xd0, 0x26, 0x0e, 0x69, 0x49, 0xf5, 0x3d, 0x59, 0x0e, 0x09, 0xba, 0x39,
|
||||
0xa5, 0x3b, 0xcb, 0xa2, 0x0a, 0x51, 0xbb, 0x57, 0xa6, 0xec, 0x48, 0xa1, 0xeb, 0x33, 0xc8, 0x65,
|
||||
0x1c, 0xf7, 0x6c, 0x17, 0xef, 0xd9, 0x83, 0xc7, 0x51, 0xbf, 0x3a, 0x9d, 0x63, 0x0a, 0x55, 0x72,
|
||||
0xbc, 0xac, 0xbe, 0x4a, 0x86, 0x81, 0xed, 0x0d, 0xe5, 0xe0, 0x48, 0x9f, 0x41, 0x4f, 0xe0, 0xdc,
|
||||
0x26, 0x66, 0xdc, 0x6d, 0x12, 0xda, 0x03, 0x22, 0x19, 0xae, 0x4e, 0x67, 0x98, 0x41, 0x3e, 0x21,
|
||||
0x4b, 0x07, 0x5a, 0xa9, 0x3f, 0xc3, 0xa0, 0xeb, 0xea, 0xb8, 0x51, 0xfd, 0x71, 0xa7, 0xfb, 0x56,
|
||||
0x2e, 0xdc, 0x88, 0x9b, 0x0d, 0xcd, 0xe4, 0x1f, 0x45, 0xd0, 0x97, 0xa6, 0x11, 0xc8, 0xcc, 0xc2,
|
||||
0xbb, 0xd7, 0xf3, 0xa0, 0x46, 0xac, 0x1e, 0x72, 0x7f, 0x3a, 0x8e, 0x95, 0xf2, 0x7f, 0x08, 0xdd,
|
||||
0xa3, 0x66, 0x76, 0xfa, 0x0c, 0xfa, 0x3e, 0xcc, 0x67, 0x26, 0xf6, 0xe8, 0xcb, 0x2a, 0xf2, 0xd3,
|
||||
0x06, 0xfb, 0xc7, 0x71, 0x78, 0x98, 0x8e, 0x86, 0xe9, 0xd2, 0x67, 0xfe, 0xe1, 0x91, 0x5f, 0xfa,
|
||||
0x18, 0xf9, 0xa3, 0xa4, 0x3f, 0x31, 0x87, 0x31, 0xa0, 0xec, 0xcc, 0x1e, 0xbd, 0xad, 0x62, 0x31,
|
||||
0xf5, 0x7f, 0x03, 0xdd, 0x95, 0xbc, 0xe8, 0x91, 0xc9, 0xc7, 0x2c, 0x5a, 0xd3, 0xf7, 0x2e, 0x25,
|
||||
0xdb, 0xa9, 0x73, 0x7a, 0x35, 0xdb, 0xe9, 0xa3, 0x72, 0xee, 0xd4, 0xc9, 0x51, 0xb0, 0xda, 0x56,
|
||||
0xca, 0xf1, 0xb5, 0xda, 0xa9, 0xd5, 0x93, 0x65, 0x7d, 0x06, 0xed, 0x25, 0x92, 0x30, 0xba, 0x32,
|
||||
0xcd, 0x27, 0x92, 0xef, 0x25, 0xc7, 0x99, 0xab, 0x07, 0xb0, 0x89, 0xc3, 0xbb, 0x38, 0x0c, 0xec,
|
||||
0x01, 0x49, 0x13, 0x15, 0x8b, 0x09, 0x82, 0x24, 0x7a, 0xf5, 0x58, 0x3c, 0x29, 0xf6, 0xea, 0x5f,
|
||||
0x6a, 0x50, 0x65, 0x36, 0xa3, 0xf5, 0xe1, 0xff, 0x69, 0xfc, 0x05, 0xa4, 0xf1, 0x47, 0xd0, 0x4a,
|
||||
0xfd, 0x0f, 0x40, 0x9d, 0xc6, 0xd5, 0x7f, 0x16, 0x38, 0xce, 0x41, 0xfa, 0x80, 0xb2, 0x53, 0x6e,
|
||||
0x75, 0x60, 0x4d, 0x9d, 0x86, 0x1f, 0xc7, 0xe3, 0x11, 0xb4, 0x52, 0x23, 0x5d, 0xf5, 0x09, 0xd4,
|
||||
0x73, 0xdf, 0x1c, 0x27, 0xc8, 0x4e, 0x22, 0xd5, 0x27, 0x98, 0x3a, 0xb1, 0x3c, 0x8e, 0xc7, 0x03,
|
||||
0x3e, 0x28, 0x8f, 0xee, 0x03, 0x57, 0xa7, 0x45, 0x67, 0xea, 0x71, 0xf5, 0xe5, 0xe7, 0xeb, 0x17,
|
||||
0x5f, 0xcf, 0x1e, 0x41, 0x2b, 0x35, 0x4a, 0x50, 0x5b, 0x57, 0x3d, 0x6f, 0x38, 0x8e, 0xfa, 0xe7,
|
||||
0x98, 0x81, 0xef, 0x41, 0x85, 0x4f, 0x00, 0xd0, 0x25, 0xf5, 0xed, 0x28, 0x36, 0x1d, 0xe8, 0x1e,
|
||||
0x3d, 0x41, 0x20, 0x63, 0x27, 0xa4, 0xd2, 0x6f, 0x43, 0x99, 0xc5, 0x0b, 0x52, 0x5e, 0x58, 0xe2,
|
||||
0xef, 0xfc, 0xdd, 0x23, 0x47, 0x01, 0x92, 0xde, 0x8b, 0x4e, 0xe7, 0x6b, 0xef, 0x3c, 0x5c, 0x1d,
|
||||
0xda, 0xe1, 0xc1, 0xb8, 0x4f, 0x0d, 0x71, 0x83, 0x63, 0xbe, 0x6d, 0xfb, 0xe2, 0xd7, 0x0d, 0x99,
|
||||
0xd7, 0x6e, 0x30, 0x4a, 0x37, 0xd8, 0x31, 0x46, 0xfd, 0x7e, 0x85, 0x2d, 0x6f, 0xfd, 0x37, 0x00,
|
||||
0x00, 0xff, 0xff, 0x49, 0x2f, 0x9e, 0xbd, 0x7a, 0x2e, 0x00, 0x00,
|
||||
0xd5, 0x3d, 0x5f, 0xf6, 0xbc, 0xf9, 0x4c, 0x39, 0x31, 0x93, 0x61, 0x77, 0xe3, 0x74, 0x36, 0x1f,
|
||||
0x64, 0x59, 0x27, 0x38, 0x8b, 0xc4, 0x0a, 0x38, 0xac, 0x6d, 0xe2, 0x35, 0xd9, 0x78, 0x9d, 0xb6,
|
||||
0x13, 0x20, 0x8a, 0x34, 0xf4, 0x4c, 0x97, 0xc7, 0xad, 0xf4, 0xc7, 0xa4, 0xab, 0x67, 0x13, 0x87,
|
||||
0xeb, 0x0a, 0xf1, 0x21, 0x84, 0x38, 0x71, 0x41, 0x9c, 0x40, 0xb0, 0x87, 0x15, 0x67, 0x6e, 0x5c,
|
||||
0xb8, 0xf1, 0x0b, 0x38, 0x20, 0x6e, 0xf0, 0x07, 0x38, 0x22, 0x50, 0x7d, 0xf5, 0x74, 0xf7, 0x54,
|
||||
0xdb, 0x3d, 0xf6, 0x66, 0x13, 0x21, 0x6e, 0x53, 0xaf, 0x5f, 0xbd, 0xf7, 0xea, 0x7d, 0x57, 0xbd,
|
||||
0x81, 0x33, 0x4f, 0xc6, 0x38, 0x38, 0xec, 0x0d, 0x7c, 0x3f, 0xb0, 0x56, 0x46, 0x81, 0x1f, 0xfa,
|
||||
0x08, 0xb9, 0xb6, 0xf3, 0xd1, 0x98, 0xf0, 0xd5, 0x0a, 0xfb, 0xde, 0xad, 0x0f, 0x7c, 0xd7, 0xf5,
|
||||
0x3d, 0x0e, 0xeb, 0xd6, 0xe3, 0x18, 0xdd, 0xa6, 0xed, 0x85, 0x38, 0xf0, 0x4c, 0x47, 0x7e, 0x25,
|
||||
0x83, 0x03, 0xec, 0x9a, 0x62, 0xd5, 0xb6, 0xcc, 0xd0, 0x8c, 0xd3, 0xd7, 0x3f, 0xd6, 0x60, 0x69,
|
||||
0xf7, 0xc0, 0x7f, 0xba, 0xee, 0x3b, 0x0e, 0x1e, 0x84, 0xb6, 0xef, 0x11, 0x03, 0x3f, 0x19, 0x63,
|
||||
0x12, 0xa2, 0x9b, 0x50, 0xea, 0x9b, 0x04, 0x77, 0xb4, 0x65, 0xed, 0x5a, 0x6d, 0xf5, 0xb5, 0x95,
|
||||
0x84, 0x24, 0x42, 0x84, 0xbb, 0x64, 0xb8, 0x66, 0x12, 0x6c, 0x30, 0x4c, 0x84, 0xa0, 0x64, 0xf5,
|
||||
0xb7, 0x36, 0x3a, 0x85, 0x65, 0xed, 0x5a, 0xd1, 0x60, 0xbf, 0xd1, 0x9b, 0xd0, 0x18, 0x44, 0xb4,
|
||||
0xb7, 0x36, 0x48, 0xa7, 0xb8, 0x5c, 0xbc, 0x56, 0x34, 0x92, 0x40, 0xfd, 0x77, 0x1a, 0x7c, 0x61,
|
||||
0x4a, 0x0c, 0x32, 0xf2, 0x3d, 0x82, 0xd1, 0x2d, 0xa8, 0x90, 0xd0, 0x0c, 0xc7, 0x44, 0x48, 0xf2,
|
||||
0x45, 0xa5, 0x24, 0xbb, 0x0c, 0xc5, 0x10, 0xa8, 0xd3, 0x6c, 0x0b, 0x0a, 0xb6, 0xe8, 0x2b, 0x70,
|
||||
0xd6, 0xf6, 0xee, 0x62, 0xd7, 0x0f, 0x0e, 0x7b, 0x23, 0x1c, 0x0c, 0xb0, 0x17, 0x9a, 0x43, 0x2c,
|
||||
0x65, 0x5c, 0x94, 0xdf, 0x76, 0x26, 0x9f, 0xf4, 0xdf, 0x6a, 0x70, 0x8e, 0x4a, 0xba, 0x63, 0x06,
|
||||
0xa1, 0xfd, 0x02, 0xf4, 0xa5, 0x43, 0x3d, 0x2e, 0x63, 0xa7, 0xc8, 0xbe, 0x25, 0x60, 0x14, 0x67,
|
||||
0x24, 0xd9, 0xd3, 0xb3, 0x95, 0x98, 0xb8, 0x09, 0x98, 0xfe, 0x1b, 0x61, 0xd8, 0xb8, 0x9c, 0xa7,
|
||||
0x51, 0x68, 0x9a, 0x67, 0x61, 0x9a, 0xe7, 0x49, 0xd4, 0xf9, 0x0f, 0x0d, 0xce, 0x7d, 0xe0, 0x9b,
|
||||
0xd6, 0xc4, 0xf0, 0x9f, 0xbf, 0x3a, 0xbf, 0x09, 0x15, 0x1e, 0x25, 0x9d, 0x12, 0xe3, 0x75, 0x39,
|
||||
0xc9, 0x4b, 0x44, 0xd0, 0x44, 0xc2, 0x5d, 0x06, 0x30, 0xc4, 0x26, 0x74, 0x19, 0x9a, 0x01, 0x1e,
|
||||
0x39, 0xf6, 0xc0, 0xec, 0x79, 0x63, 0xb7, 0x8f, 0x83, 0x4e, 0x79, 0x59, 0xbb, 0x56, 0x36, 0x1a,
|
||||
0x02, 0xba, 0xcd, 0x80, 0xfa, 0xaf, 0x34, 0xe8, 0x18, 0xd8, 0xc1, 0x26, 0xc1, 0x2f, 0xf3, 0xb0,
|
||||
0x4b, 0x50, 0xf1, 0x7c, 0x0b, 0x6f, 0x6d, 0xb0, 0xc3, 0x16, 0x0d, 0xb1, 0xd2, 0x7f, 0x5a, 0xe0,
|
||||
0x86, 0x78, 0xc5, 0xfd, 0x3a, 0x66, 0xac, 0xf2, 0x67, 0x63, 0xac, 0x8a, 0xca, 0x58, 0x7f, 0x9a,
|
||||
0x18, 0xeb, 0x55, 0x57, 0xc8, 0xc4, 0xa0, 0xe5, 0x84, 0x41, 0xbf, 0x07, 0xe7, 0xd7, 0x03, 0x6c,
|
||||
0x86, 0xf8, 0x1e, 0x2d, 0x1a, 0xeb, 0x07, 0xa6, 0xe7, 0x61, 0x47, 0x1e, 0x21, 0xcd, 0x5c, 0x53,
|
||||
0x30, 0xef, 0xc0, 0xfc, 0x28, 0xf0, 0x9f, 0x1d, 0x46, 0x72, 0xcb, 0xa5, 0xfe, 0x7b, 0x0d, 0xba,
|
||||
0x2a, 0xda, 0xa7, 0xc9, 0x2f, 0x97, 0xa0, 0x21, 0xaa, 0x1f, 0xa7, 0xc6, 0x78, 0x56, 0x8d, 0xfa,
|
||||
0x93, 0x18, 0x07, 0x74, 0x13, 0xce, 0x72, 0xa4, 0x00, 0x93, 0xb1, 0x13, 0x46, 0xb8, 0x45, 0x86,
|
||||
0x8b, 0xd8, 0x37, 0x83, 0x7d, 0x12, 0x3b, 0xf4, 0x4f, 0x34, 0x38, 0xbf, 0x89, 0xc3, 0xc8, 0x88,
|
||||
0x94, 0x2b, 0x7e, 0x45, 0x53, 0xf6, 0xa7, 0x1a, 0x74, 0x55, 0xb2, 0x9e, 0x46, 0xad, 0x0f, 0x61,
|
||||
0x29, 0xe2, 0xd1, 0xb3, 0x30, 0x19, 0x04, 0xf6, 0x88, 0x39, 0x33, 0x4b, 0xe0, 0xb5, 0xd5, 0x4b,
|
||||
0x2b, 0xd3, 0x0d, 0xc6, 0x4a, 0x5a, 0x82, 0x73, 0x11, 0x89, 0x8d, 0x18, 0x05, 0xfd, 0x67, 0x1a,
|
||||
0x9c, 0xdb, 0xc4, 0xe1, 0x2e, 0x1e, 0xba, 0xd8, 0x0b, 0xb7, 0xbc, 0x7d, 0xff, 0xe4, 0x7a, 0x7d,
|
||||
0x03, 0x80, 0x08, 0x3a, 0x51, 0x71, 0x89, 0x41, 0xf2, 0xe8, 0x98, 0xf5, 0x32, 0x69, 0x79, 0x4e,
|
||||
0xa3, 0xbb, 0xaf, 0x42, 0xd9, 0xf6, 0xf6, 0x7d, 0xa9, 0xaa, 0x0b, 0x2a, 0x55, 0xc5, 0x99, 0x71,
|
||||
0x6c, 0xfd, 0xdf, 0x05, 0x58, 0x7a, 0xcf, 0xb2, 0x54, 0x61, 0x37, 0xbb, 0x5e, 0x26, 0xd1, 0x5d,
|
||||
0x88, 0x47, 0x77, 0x2e, 0x9f, 0x9b, 0x0a, 0xa9, 0xd2, 0x0c, 0x21, 0x55, 0xce, 0x0a, 0x29, 0xb4,
|
||||
0x09, 0x0d, 0x82, 0xf1, 0xe3, 0xde, 0xc8, 0x27, 0xcc, 0x27, 0x58, 0x06, 0xad, 0xad, 0xea, 0xc9,
|
||||
0xd3, 0x44, 0x7d, 0xe8, 0x5d, 0x32, 0xdc, 0x11, 0x98, 0x46, 0x9d, 0x6e, 0x94, 0x2b, 0x74, 0x1f,
|
||||
0x96, 0x86, 0x8e, 0xdf, 0x37, 0x9d, 0x1e, 0xc1, 0xa6, 0x83, 0xad, 0x9e, 0xb0, 0x37, 0xe9, 0xcc,
|
||||
0xe7, 0x53, 0xf8, 0x59, 0xbe, 0x7d, 0x97, 0xed, 0x16, 0x1f, 0x88, 0xfe, 0x77, 0x0d, 0xce, 0x1b,
|
||||
0xd8, 0xf5, 0x3f, 0xc2, 0xff, 0xab, 0x26, 0xd0, 0x7f, 0xa1, 0x41, 0x9d, 0x16, 0xeb, 0xbb, 0x38,
|
||||
0x34, 0xa9, 0x26, 0xd0, 0xbb, 0x50, 0x75, 0x7c, 0xd3, 0xea, 0x85, 0x87, 0x23, 0x7e, 0xb4, 0x66,
|
||||
0xfa, 0x68, 0x5c, 0x7b, 0x74, 0xd3, 0xde, 0xe1, 0x08, 0x1b, 0x0b, 0x8e, 0xf8, 0x35, 0x75, 0x8c,
|
||||
0x42, 0x8e, 0xec, 0x55, 0x54, 0x35, 0x9c, 0x45, 0x58, 0xfa, 0x8e, 0x19, 0x0e, 0x0e, 0x36, 0x5c,
|
||||
0x21, 0x26, 0x79, 0x39, 0x3a, 0xcf, 0x53, 0x34, 0xa3, 0xd0, 0x2e, 0xab, 0x3c, 0x8d, 0xde, 0x92,
|
||||
0x56, 0x1e, 0x08, 0x33, 0xc4, 0x42, 0x3b, 0xd6, 0x7c, 0x54, 0x4e, 0xd2, 0x7c, 0xac, 0x43, 0x03,
|
||||
0x3f, 0x1b, 0x38, 0x63, 0x0b, 0xf7, 0x38, 0x77, 0xee, 0xe7, 0x6f, 0x28, 0xb8, 0xc7, 0xdd, 0xbc,
|
||||
0x2e, 0x36, 0x6d, 0x09, 0x19, 0xb8, 0xa9, 0x5d, 0x1c, 0x9a, 0x9d, 0x05, 0x26, 0xc6, 0x72, 0x96,
|
||||
0xa9, 0xa5, 0x7f, 0x70, 0x73, 0xd3, 0x95, 0xfe, 0x1f, 0x0d, 0xce, 0x73, 0x33, 0x61, 0x27, 0x34,
|
||||
0x5f, 0xae, 0xa5, 0x22, 0x2b, 0x94, 0x66, 0xb4, 0x42, 0x4c, 0x03, 0xd5, 0x99, 0x35, 0xf0, 0xcb,
|
||||
0x12, 0xb4, 0x84, 0x7a, 0x29, 0x06, 0x8b, 0x9f, 0xd7, 0xa0, 0x1a, 0x15, 0x1b, 0xd1, 0x0c, 0x4d,
|
||||
0x00, 0x68, 0x19, 0x6a, 0x31, 0xef, 0x11, 0x07, 0x8d, 0x83, 0x72, 0x9d, 0x56, 0xb6, 0x0e, 0xa5,
|
||||
0x58, 0xeb, 0xf0, 0x3a, 0xc0, 0xbe, 0x33, 0x26, 0x07, 0xbd, 0xd0, 0x76, 0xb1, 0x68, 0xe0, 0xaa,
|
||||
0x0c, 0xb2, 0x67, 0xbb, 0x18, 0xbd, 0x07, 0xf5, 0xbe, 0xed, 0x39, 0xfe, 0xb0, 0x37, 0x32, 0xc3,
|
||||
0x03, 0xd2, 0xa9, 0x64, 0xfa, 0xcb, 0x6d, 0x1b, 0x3b, 0xd6, 0x1a, 0xc3, 0x35, 0x6a, 0x7c, 0xcf,
|
||||
0x0e, 0xdd, 0x82, 0xde, 0x80, 0x9a, 0x37, 0x76, 0x7b, 0xfe, 0x7e, 0x2f, 0xf0, 0x9f, 0x52, 0x8f,
|
||||
0x63, 0x2c, 0xbc, 0xb1, 0xfb, 0xe1, 0xbe, 0xe1, 0x3f, 0x25, 0xe8, 0x1b, 0x50, 0xa5, 0xe5, 0x8e,
|
||||
0x38, 0xfe, 0x90, 0x74, 0x16, 0x72, 0xd1, 0x9f, 0x6c, 0xa0, 0xbb, 0x2d, 0xea, 0x47, 0x6c, 0x77,
|
||||
0x35, 0xdf, 0xee, 0x68, 0x03, 0xba, 0x02, 0xcd, 0x81, 0xef, 0x8e, 0x4c, 0xa6, 0xa1, 0xdb, 0x81,
|
||||
0xef, 0x76, 0x80, 0xc5, 0x6a, 0x0a, 0x8a, 0xd6, 0xa1, 0x66, 0x7b, 0x16, 0x7e, 0x26, 0xa2, 0xa6,
|
||||
0xc6, 0xf8, 0xe8, 0x2a, 0x93, 0x33, 0x46, 0x5b, 0x14, 0x97, 0x19, 0x1d, 0x6c, 0xf9, 0x93, 0xa0,
|
||||
0x8b, 0x50, 0x17, 0x16, 0xed, 0x11, 0xfb, 0x39, 0xee, 0xd4, 0xb9, 0x15, 0x05, 0x6c, 0xd7, 0x7e,
|
||||
0x8e, 0xf5, 0x3f, 0x14, 0xa0, 0x99, 0xa4, 0x40, 0x9b, 0xe0, 0x7d, 0x06, 0x91, 0x6e, 0x21, 0x97,
|
||||
0x94, 0x1e, 0xf6, 0xcc, 0xbe, 0x43, 0x63, 0xd9, 0xc2, 0xcf, 0x98, 0x57, 0x2c, 0x18, 0x35, 0x0e,
|
||||
0x63, 0x04, 0xa8, 0x75, 0xb9, 0xdc, 0x9e, 0xe9, 0x62, 0xd1, 0xa4, 0x56, 0x19, 0x64, 0xdb, 0x74,
|
||||
0x31, 0xa5, 0xcd, 0xe5, 0x93, 0x3e, 0x21, 0x97, 0xf4, 0x4b, 0x7f, 0x6c, 0x33, 0xae, 0xdc, 0x27,
|
||||
0xe4, 0x12, 0x6d, 0x40, 0x9d, 0x93, 0x1c, 0x99, 0x81, 0xe9, 0x4a, 0x8f, 0xb8, 0xa8, 0x0c, 0xd4,
|
||||
0x3b, 0xf8, 0xf0, 0x81, 0xe9, 0x8c, 0xf1, 0x8e, 0x69, 0x07, 0x06, 0xd7, 0xe0, 0x0e, 0xdb, 0x85,
|
||||
0xae, 0x41, 0x9b, 0x53, 0xd9, 0xb7, 0x1d, 0x2c, 0x7c, 0x8b, 0xe6, 0xa2, 0xaa, 0xd1, 0x64, 0xf0,
|
||||
0xdb, 0xb6, 0x83, 0xb9, 0xfb, 0x44, 0x47, 0x60, 0x3a, 0x5b, 0xe0, 0xde, 0xc3, 0x20, 0x4c, 0x63,
|
||||
0xff, 0x2c, 0xc0, 0x22, 0x0d, 0x22, 0x59, 0x7c, 0x4f, 0x9e, 0x47, 0x5e, 0x07, 0xb0, 0x48, 0xd8,
|
||||
0x4b, 0xe4, 0x92, 0xaa, 0x45, 0xc2, 0x6d, 0x9e, 0x4e, 0xde, 0x95, 0xa9, 0xa2, 0x98, 0xdd, 0xb6,
|
||||
0xa6, 0x82, 0x7a, 0x3a, 0x69, 0x9f, 0xe8, 0x7a, 0x7f, 0x09, 0x1a, 0xc4, 0x1f, 0x07, 0x03, 0xdc,
|
||||
0x4b, 0x5c, 0xb3, 0xea, 0x1c, 0xb8, 0xad, 0xce, 0x76, 0x15, 0xe5, 0x33, 0x43, 0x2c, 0x6d, 0xcd,
|
||||
0xcf, 0x9c, 0xb6, 0xfe, 0xa6, 0xc1, 0x92, 0xb8, 0x92, 0x9e, 0x5e, 0xdb, 0x59, 0x59, 0x5b, 0xe6,
|
||||
0xa8, 0xe2, 0x11, 0xd7, 0x9b, 0x52, 0x8e, 0x9a, 0x5b, 0x56, 0xd4, 0xdc, 0x64, 0x8b, 0x5f, 0x49,
|
||||
0xb7, 0xf8, 0xfa, 0x0f, 0x35, 0x68, 0xec, 0x62, 0x33, 0x18, 0x1c, 0xc8, 0x73, 0xbd, 0x03, 0xc5,
|
||||
0x00, 0x3f, 0x11, 0xc7, 0x4a, 0xc5, 0xbb, 0x58, 0x24, 0x36, 0x18, 0x14, 0x1d, 0x5d, 0x80, 0x9a,
|
||||
0xe5, 0x3a, 0xa9, 0x7b, 0x24, 0x58, 0xae, 0x23, 0xfb, 0xad, 0xa4, 0x20, 0xc5, 0x29, 0x41, 0x3e,
|
||||
0xd6, 0xa0, 0x7e, 0x8f, 0x37, 0x5d, 0x5c, 0x8e, 0x5b, 0x71, 0x39, 0x2e, 0x2a, 0xe5, 0x88, 0xe3,
|
||||
0x7f, 0x46, 0x62, 0xfc, 0x5c, 0x83, 0xa5, 0xf7, 0x4d, 0xcf, 0xf2, 0xf7, 0xf7, 0x4f, 0x6f, 0xf0,
|
||||
0xf5, 0x28, 0xfb, 0x6d, 0xcd, 0x72, 0xa5, 0x49, 0x6c, 0xd2, 0x7f, 0x54, 0x00, 0x44, 0xbd, 0x73,
|
||||
0xcd, 0x74, 0x4c, 0x6f, 0x80, 0x4f, 0x2e, 0xcd, 0x65, 0x68, 0x26, 0x62, 0x2a, 0x7a, 0x9e, 0x8d,
|
||||
0x07, 0x15, 0x41, 0x77, 0xa0, 0xd9, 0xe7, 0xac, 0x7a, 0x01, 0x36, 0x89, 0xef, 0x31, 0xbf, 0x6c,
|
||||
0xae, 0xbe, 0xa9, 0x12, 0x7b, 0x2f, 0xb0, 0x87, 0x43, 0x1c, 0xac, 0xfb, 0x9e, 0xc5, 0x2f, 0x1b,
|
||||
0x8d, 0xbe, 0x14, 0x93, 0x6e, 0x65, 0xf6, 0x88, 0x12, 0x8c, 0xec, 0x0a, 0x21, 0xca, 0x30, 0x04,
|
||||
0xbd, 0x05, 0x67, 0x92, 0xf7, 0x90, 0x89, 0x23, 0xb7, 0x49, 0xfc, 0x8a, 0x41, 0x8d, 0xf3, 0x03,
|
||||
0x40, 0x51, 0x9f, 0xcb, 0xda, 0x29, 0x56, 0x2d, 0xf2, 0x3c, 0xab, 0xbc, 0x06, 0x55, 0x4b, 0xee,
|
||||
0x14, 0x5e, 0x31, 0x01, 0xd0, 0x6c, 0xc3, 0x25, 0xec, 0xd1, 0xc0, 0xc7, 0x96, 0xec, 0x24, 0x38,
|
||||
0xf0, 0x03, 0x06, 0xd3, 0x3f, 0x2d, 0x40, 0x3b, 0x7e, 0xb7, 0xc9, 0xcd, 0xfb, 0xc5, 0x3c, 0xb2,
|
||||
0x1c, 0x71, 0x91, 0x2b, 0x9d, 0xe2, 0x22, 0x37, 0x7d, 0xd1, 0x2c, 0x9f, 0xec, 0xa2, 0xa9, 0xff,
|
||||
0x5a, 0x83, 0x56, 0xea, 0x4d, 0x23, 0xdd, 0xd3, 0x69, 0xd3, 0x3d, 0xdd, 0xd7, 0xa0, 0x4c, 0x1b,
|
||||
0x1d, 0xcc, 0x94, 0xd4, 0x54, 0xf7, 0x1b, 0x49, 0xaa, 0x06, 0xdf, 0x80, 0x6e, 0xc0, 0xa2, 0xe2,
|
||||
0x1d, 0x5c, 0x98, 0x12, 0x4d, 0x3f, 0x83, 0xeb, 0x7f, 0x2c, 0x41, 0x2d, 0xa6, 0x8f, 0x63, 0xda,
|
||||
0xd1, 0x3c, 0x37, 0xb6, 0xd4, 0xf1, 0x8a, 0xd3, 0xc7, 0xcb, 0x78, 0x08, 0x46, 0xe7, 0x61, 0xc1,
|
||||
0xc5, 0x2e, 0xaf, 0xf7, 0xa2, 0xf9, 0x70, 0xb1, 0x4b, 0xab, 0x3d, 0xfd, 0x44, 0x7b, 0x49, 0xd6,
|
||||
0x48, 0xf2, 0x0a, 0x37, 0xef, 0x8d, 0x5d, 0xd6, 0x46, 0x26, 0x5b, 0x9d, 0xf9, 0x23, 0x5a, 0x9d,
|
||||
0x85, 0x64, 0xab, 0x93, 0x08, 0x87, 0x6a, 0x3a, 0x1c, 0xf2, 0x76, 0x88, 0x37, 0x61, 0x71, 0xc0,
|
||||
0x1e, 0x24, 0xad, 0xb5, 0xc3, 0xf5, 0xe8, 0x53, 0xa7, 0xc6, 0x7a, 0x32, 0xd5, 0x27, 0x74, 0x9b,
|
||||
0x3a, 0x97, 0x68, 0x07, 0x99, 0x95, 0xeb, 0xcc, 0xca, 0xea, 0x4e, 0x4a, 0xd8, 0x86, 0x1b, 0x59,
|
||||
0xe6, 0x44, 0xb6, 0x4a, 0xf7, 0xa6, 0x8d, 0x13, 0xf5, 0xa6, 0x17, 0xa0, 0x26, 0x5f, 0xa5, 0x6d,
|
||||
0x8b, 0x74, 0x9a, 0x3c, 0x37, 0x09, 0xd0, 0x96, 0x45, 0x98, 0xe6, 0x7d, 0x7a, 0x6d, 0xb4, 0x48,
|
||||
0xa7, 0xc5, 0xbe, 0xce, 0x33, 0x73, 0x59, 0x44, 0xff, 0xa4, 0x08, 0xcd, 0x49, 0xf3, 0x92, 0x3b,
|
||||
0x15, 0xe4, 0x99, 0xe7, 0x6c, 0x43, 0x7b, 0xf2, 0x78, 0xc8, 0xb4, 0x74, 0x64, 0xff, 0x95, 0x7e,
|
||||
0x36, 0x6c, 0x8d, 0x52, 0x31, 0x97, 0x78, 0xa5, 0x28, 0xcd, 0xf4, 0x4a, 0x71, 0xca, 0x67, 0xff,
|
||||
0x5b, 0x70, 0x2e, 0xe0, 0xbd, 0x93, 0xd5, 0x4b, 0x1c, 0x9b, 0xb7, 0x21, 0x67, 0xe5, 0xc7, 0x9d,
|
||||
0xf8, 0xf1, 0x33, 0xc2, 0x78, 0x3e, 0x2b, 0x8c, 0xd3, 0x66, 0x5c, 0x48, 0x9b, 0x51, 0xbf, 0x0f,
|
||||
0x8b, 0xf7, 0x3d, 0x32, 0xee, 0x93, 0x41, 0x60, 0xf7, 0xb1, 0xbc, 0x7c, 0xe7, 0xb2, 0x57, 0x17,
|
||||
0x16, 0x44, 0x22, 0xe6, 0xb6, 0xaa, 0x1a, 0xd1, 0x5a, 0xff, 0x89, 0x06, 0x4b, 0xd3, 0x74, 0x99,
|
||||
0x2b, 0x4c, 0xa2, 0x5c, 0x4b, 0x44, 0xf9, 0x77, 0x61, 0x71, 0x42, 0xbe, 0x97, 0xa0, 0x5c, 0x5b,
|
||||
0xbd, 0xaa, 0x32, 0x8a, 0x42, 0x70, 0x03, 0x4d, 0x68, 0x48, 0x98, 0xfe, 0x2f, 0x0d, 0xce, 0x88,
|
||||
0x78, 0xa1, 0xb0, 0x21, 0x7b, 0xb6, 0xa0, 0x95, 0xc7, 0xf7, 0x1c, 0xdb, 0x8b, 0xba, 0x68, 0x71,
|
||||
0x46, 0x0e, 0x14, 0x5d, 0xf4, 0xfb, 0xd0, 0x12, 0x48, 0x51, 0x01, 0xc9, 0xd9, 0xa7, 0x34, 0xf9,
|
||||
0xbe, 0xa8, 0x74, 0x5c, 0x86, 0xa6, 0xbf, 0xbf, 0x1f, 0xe7, 0xc7, 0x33, 0x60, 0x43, 0x40, 0x05,
|
||||
0xc3, 0x6f, 0x43, 0x5b, 0xa2, 0xcd, 0x5a, 0xb2, 0x5a, 0x62, 0x63, 0xf4, 0xec, 0xf8, 0x63, 0x0d,
|
||||
0x3a, 0xc9, 0x02, 0x16, 0x3b, 0xfe, 0xec, 0x2d, 0xd2, 0xd7, 0x93, 0x8f, 0xcf, 0x97, 0x8f, 0x90,
|
||||
0x67, 0xc2, 0x47, 0x3e, 0x41, 0xff, 0x55, 0x83, 0x9a, 0x21, 0xdc, 0x8e, 0xb2, 0x7f, 0x1d, 0x60,
|
||||
0xe2, 0x98, 0xb2, 0xa0, 0x44, 0x7e, 0x49, 0x8d, 0x13, 0x73, 0x06, 0xdb, 0x52, 0x54, 0x14, 0x86,
|
||||
0x34, 0x49, 0x06, 0xd4, 0xbd, 0xa7, 0x1e, 0x01, 0x2d, 0x5a, 0xb2, 0x9b, 0xe4, 0xc0, 0x0c, 0xac,
|
||||
0x9e, 0x20, 0x2e, 0xd5, 0xa9, 0xbc, 0xe8, 0xec, 0x52, 0x4c, 0x21, 0xa6, 0xd1, 0x20, 0xb1, 0x55,
|
||||
0x32, 0xe1, 0x95, 0x93, 0x09, 0x6f, 0x1b, 0xea, 0xf1, 0x9d, 0xd4, 0xc5, 0x1d, 0x6c, 0x5a, 0x38,
|
||||
0x90, 0x2e, 0xce, 0x57, 0xe8, 0x0a, 0xb4, 0x2c, 0x57, 0xba, 0x36, 0xaf, 0x4b, 0xbc, 0xdd, 0x69,
|
||||
0x44, 0xf5, 0x85, 0xd6, 0xa6, 0xeb, 0xcf, 0xa1, 0x99, 0xcc, 0x5c, 0xa8, 0x0e, 0x0b, 0xdb, 0x7e,
|
||||
0xf8, 0xad, 0x67, 0x36, 0x09, 0xdb, 0x73, 0xa8, 0x09, 0xb0, 0xed, 0x87, 0x3b, 0x01, 0x26, 0xd8,
|
||||
0x0b, 0xdb, 0x1a, 0x02, 0xa8, 0x7c, 0xe8, 0x6d, 0xd8, 0xe4, 0x71, 0xbb, 0x80, 0x16, 0x45, 0x63,
|
||||
0x61, 0x3a, 0x5b, 0x22, 0x1d, 0xb4, 0x8b, 0x74, 0x7b, 0xb4, 0x2a, 0xa1, 0x36, 0xd4, 0x23, 0x94,
|
||||
0xcd, 0x9d, 0xfb, 0xed, 0x32, 0xaa, 0x42, 0x99, 0xff, 0xac, 0x5c, 0xb7, 0xa0, 0x9d, 0xee, 0x5b,
|
||||
0x29, 0xcd, 0xfb, 0xde, 0x1d, 0xcf, 0x7f, 0x1a, 0x81, 0xda, 0x73, 0xa8, 0x06, 0xf3, 0xe2, 0x2e,
|
||||
0xd0, 0xd6, 0x50, 0x0b, 0x6a, 0xb1, 0x36, 0xbc, 0x5d, 0xa0, 0x80, 0xcd, 0x60, 0x34, 0x10, 0x0d,
|
||||
0x39, 0x17, 0x81, 0xba, 0xf8, 0x86, 0xff, 0xd4, 0x6b, 0x97, 0xae, 0xaf, 0xc1, 0x82, 0x4c, 0xa9,
|
||||
0x14, 0x95, 0x53, 0xf7, 0xe8, 0xb2, 0x3d, 0x87, 0xce, 0x40, 0x23, 0x31, 0xf7, 0x6d, 0x6b, 0x08,
|
||||
0x41, 0x33, 0x39, 0x93, 0x6f, 0x17, 0x56, 0xff, 0x5c, 0x03, 0xe0, 0x3d, 0xa7, 0xef, 0x07, 0x16,
|
||||
0x1a, 0x01, 0xda, 0xc4, 0x21, 0xad, 0xa7, 0xbe, 0x27, 0x6b, 0x21, 0x41, 0x37, 0x33, 0x5a, 0xb3,
|
||||
0x69, 0x54, 0x21, 0x6a, 0xf7, 0x4a, 0xc6, 0x8e, 0x14, 0xba, 0x3e, 0x87, 0x5c, 0xc6, 0x71, 0xcf,
|
||||
0x76, 0xf1, 0x9e, 0x3d, 0x78, 0x1c, 0x35, 0xab, 0xd9, 0x1c, 0x53, 0xa8, 0x92, 0xe3, 0x25, 0xf5,
|
||||
0x3d, 0x32, 0x0c, 0x6c, 0x6f, 0x28, 0xe7, 0x45, 0xfa, 0x1c, 0x7a, 0x02, 0x67, 0x37, 0x31, 0xe3,
|
||||
0x6e, 0x93, 0xd0, 0x1e, 0x10, 0xc9, 0x70, 0x35, 0x9b, 0xe1, 0x14, 0xf2, 0x8c, 0x2c, 0x1d, 0x68,
|
||||
0xa5, 0xfe, 0x03, 0x83, 0xae, 0xab, 0xe3, 0x46, 0xf5, 0x7f, 0x9d, 0xee, 0x5b, 0xb9, 0x70, 0x23,
|
||||
0x6e, 0x36, 0x34, 0x93, 0xff, 0x0f, 0x41, 0x5f, 0xca, 0x22, 0x30, 0x35, 0x02, 0xef, 0x5e, 0xcf,
|
||||
0x83, 0x1a, 0xb1, 0x7a, 0xc8, 0xfd, 0xe9, 0x38, 0x56, 0xca, 0xbf, 0x1f, 0x74, 0x8f, 0x1a, 0xd5,
|
||||
0xe9, 0x73, 0xe8, 0xfb, 0x70, 0x66, 0x6a, 0x50, 0x8f, 0xbe, 0xac, 0x22, 0x9f, 0x35, 0xcf, 0x3f,
|
||||
0x8e, 0xc3, 0xc3, 0x74, 0x34, 0x64, 0x4b, 0x3f, 0xf5, 0xc7, 0x8e, 0xfc, 0xd2, 0xc7, 0xc8, 0x1f,
|
||||
0x25, 0xfd, 0xcc, 0x1c, 0xc6, 0x80, 0xa6, 0x47, 0xf5, 0xe8, 0x6d, 0x15, 0x8b, 0xcc, 0xbf, 0x0b,
|
||||
0x74, 0x57, 0xf2, 0xa2, 0x47, 0x26, 0x1f, 0xb3, 0x68, 0x4d, 0x5f, 0xba, 0x94, 0x6c, 0x33, 0xc7,
|
||||
0xf3, 0x6a, 0xb6, 0xd9, 0x13, 0x72, 0xee, 0xd4, 0xc9, 0x09, 0xb0, 0xda, 0x56, 0xca, 0xa9, 0xb5,
|
||||
0xda, 0xa9, 0xd5, 0x03, 0x65, 0x7d, 0x0e, 0xed, 0x25, 0x92, 0x30, 0xba, 0x92, 0xe5, 0x13, 0xc9,
|
||||
0xc7, 0x92, 0xe3, 0xcc, 0xd5, 0x03, 0xd8, 0xc4, 0xe1, 0x5d, 0x1c, 0x06, 0xf6, 0x80, 0xa4, 0x89,
|
||||
0x8a, 0xc5, 0x04, 0x41, 0x12, 0xbd, 0x7a, 0x2c, 0x9e, 0x14, 0x7b, 0xf5, 0x2f, 0x35, 0xa8, 0x32,
|
||||
0x9b, 0xd1, 0xfa, 0xf0, 0xff, 0x34, 0xfe, 0x02, 0xd2, 0xf8, 0x23, 0x68, 0xa5, 0xc6, 0xff, 0xea,
|
||||
0x34, 0xae, 0xfe, 0x8f, 0xc0, 0x71, 0x0e, 0xd2, 0x07, 0x34, 0x3d, 0xdc, 0x56, 0x07, 0x56, 0xe6,
|
||||
0x10, 0xfc, 0x38, 0x1e, 0x8f, 0xa0, 0x95, 0x9a, 0xe4, 0xaa, 0x4f, 0xa0, 0x1e, 0xf7, 0xe6, 0x38,
|
||||
0xc1, 0xf4, 0x00, 0x52, 0x7d, 0x82, 0xcc, 0x41, 0xe5, 0x71, 0x3c, 0x1e, 0xf0, 0xf9, 0x78, 0x74,
|
||||
0x1f, 0xb8, 0x9a, 0x15, 0x9d, 0xa9, 0x97, 0xd5, 0x97, 0x9f, 0xaf, 0x5f, 0x7c, 0x3d, 0x7b, 0x04,
|
||||
0xad, 0xd4, 0x1c, 0x41, 0x6d, 0x5d, 0xf5, 0xb0, 0xe1, 0x38, 0xea, 0x9f, 0x63, 0x06, 0xbe, 0x07,
|
||||
0x15, 0xfe, 0xfc, 0x8f, 0x2e, 0xaa, 0x6f, 0x47, 0xb1, 0xd1, 0x40, 0xf7, 0xe8, 0xf1, 0x01, 0x19,
|
||||
0x3b, 0x21, 0x95, 0x7e, 0x1b, 0xca, 0x2c, 0x5e, 0x90, 0xf2, 0xc2, 0x12, 0x7f, 0xe4, 0xef, 0x1e,
|
||||
0x39, 0x07, 0x90, 0xf4, 0x5e, 0x74, 0x3a, 0x5f, 0x7b, 0xe7, 0xe1, 0xea, 0xd0, 0x0e, 0x0f, 0xc6,
|
||||
0x7d, 0x6a, 0x88, 0x1b, 0x1c, 0xf3, 0x6d, 0xdb, 0x17, 0xbf, 0x6e, 0xc8, 0xbc, 0x76, 0x83, 0x51,
|
||||
0xba, 0xc1, 0x8e, 0x31, 0xea, 0xf7, 0x2b, 0x6c, 0x79, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
|
||||
0xa5, 0x1e, 0x78, 0x64, 0x71, 0x2e, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import "milvus.proto";
|
|||
import "internal.proto";
|
||||
import "proxy.proto";
|
||||
import "data_coord.proto";
|
||||
import "etcd_meta.proto";
|
||||
|
||||
service RootCoord {
|
||||
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
|
||||
|
|
@ -92,6 +93,7 @@ service RootCoord {
|
|||
|
||||
rpc DescribeSegment(milvus.DescribeSegmentRequest) returns (milvus.DescribeSegmentResponse) {}
|
||||
rpc ShowSegments(milvus.ShowSegmentsRequest) returns (milvus.ShowSegmentsResponse) {}
|
||||
rpc DescribeSegments(DescribeSegmentsRequest) returns (DescribeSegmentsResponse) {}
|
||||
|
||||
rpc CreateIndex(milvus.CreateIndexRequest) returns (common.Status) {}
|
||||
rpc DescribeIndex(milvus.DescribeIndexRequest) returns (milvus.DescribeIndexResponse) {}
|
||||
|
|
@ -144,3 +146,29 @@ message ImportResult {
|
|||
int64 row_count = 7; // how many rows are imported by this task
|
||||
repeated common.KeyValuePair infos = 8; // more informations about the task, file path, failed reason, etc.
|
||||
}
|
||||
|
||||
// TODO: find a proper place for these segment-related messages.
|
||||
|
||||
message DescribeSegmentsRequest {
|
||||
common.MsgBase base = 1;
|
||||
int64 collectionID = 2;
|
||||
repeated int64 segmentIDs = 3;
|
||||
}
|
||||
|
||||
message SegmentBaseInfo {
|
||||
int64 collectionID = 1; // in which collection.
|
||||
int64 partitionID = 2; // in which partition.
|
||||
int64 segmentID = 3;
|
||||
}
|
||||
|
||||
message SegmentInfos {
|
||||
SegmentBaseInfo base_info = 1; // base information.
|
||||
repeated etcd.SegmentIndexInfo index_infos = 2; // multiple index infos.
|
||||
map<int64, etcd.IndexInfo> extra_index_infos = 3; // index_id -> IndexInfo{index_name, index_id, index_params}
|
||||
}
|
||||
|
||||
message DescribeSegmentsResponse {
|
||||
common.Status status = 1;
|
||||
int64 collectionID = 2;
|
||||
map<int64, SegmentInfos> segment_infos = 3; // segment_id -> segment infos
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ import (
|
|||
proto "github.com/golang/protobuf/proto"
|
||||
commonpb "github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
datapb "github.com/milvus-io/milvus/internal/proto/datapb"
|
||||
etcdpb "github.com/milvus-io/milvus/internal/proto/etcdpb"
|
||||
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
|
||||
milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb"
|
||||
proxypb "github.com/milvus-io/milvus/internal/proto/proxypb"
|
||||
|
|
@ -328,83 +329,325 @@ func (m *ImportResult) GetInfos() []*commonpb.KeyValuePair {
|
|||
return nil
|
||||
}
|
||||
|
||||
type DescribeSegmentsRequest struct {
|
||||
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
|
||||
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
SegmentIDs []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsRequest) Reset() { *m = DescribeSegmentsRequest{} }
|
||||
func (m *DescribeSegmentsRequest) String() string { return proto.CompactTextString(m) }
|
||||
func (*DescribeSegmentsRequest) ProtoMessage() {}
|
||||
func (*DescribeSegmentsRequest) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_4513485a144f6b06, []int{5}
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsRequest) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_DescribeSegmentsRequest.Unmarshal(m, b)
|
||||
}
|
||||
func (m *DescribeSegmentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_DescribeSegmentsRequest.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *DescribeSegmentsRequest) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_DescribeSegmentsRequest.Merge(m, src)
|
||||
}
|
||||
func (m *DescribeSegmentsRequest) XXX_Size() int {
|
||||
return xxx_messageInfo_DescribeSegmentsRequest.Size(m)
|
||||
}
|
||||
func (m *DescribeSegmentsRequest) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_DescribeSegmentsRequest.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_DescribeSegmentsRequest proto.InternalMessageInfo
|
||||
|
||||
func (m *DescribeSegmentsRequest) GetBase() *commonpb.MsgBase {
|
||||
if m != nil {
|
||||
return m.Base
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsRequest) GetCollectionID() int64 {
|
||||
if m != nil {
|
||||
return m.CollectionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsRequest) GetSegmentIDs() []int64 {
|
||||
if m != nil {
|
||||
return m.SegmentIDs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type SegmentBaseInfo struct {
|
||||
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
|
||||
SegmentID int64 `protobuf:"varint,3,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *SegmentBaseInfo) Reset() { *m = SegmentBaseInfo{} }
|
||||
func (m *SegmentBaseInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentBaseInfo) ProtoMessage() {}
|
||||
func (*SegmentBaseInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_4513485a144f6b06, []int{6}
|
||||
}
|
||||
|
||||
func (m *SegmentBaseInfo) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SegmentBaseInfo.Unmarshal(m, b)
|
||||
}
|
||||
func (m *SegmentBaseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_SegmentBaseInfo.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *SegmentBaseInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_SegmentBaseInfo.Merge(m, src)
|
||||
}
|
||||
func (m *SegmentBaseInfo) XXX_Size() int {
|
||||
return xxx_messageInfo_SegmentBaseInfo.Size(m)
|
||||
}
|
||||
func (m *SegmentBaseInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_SegmentBaseInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_SegmentBaseInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *SegmentBaseInfo) GetCollectionID() int64 {
|
||||
if m != nil {
|
||||
return m.CollectionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *SegmentBaseInfo) GetPartitionID() int64 {
|
||||
if m != nil {
|
||||
return m.PartitionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *SegmentBaseInfo) GetSegmentID() int64 {
|
||||
if m != nil {
|
||||
return m.SegmentID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type SegmentInfos struct {
|
||||
BaseInfo *SegmentBaseInfo `protobuf:"bytes,1,opt,name=base_info,json=baseInfo,proto3" json:"base_info,omitempty"`
|
||||
IndexInfos []*etcdpb.SegmentIndexInfo `protobuf:"bytes,2,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
|
||||
ExtraIndexInfos map[int64]*etcdpb.IndexInfo `protobuf:"bytes,3,rep,name=extra_index_infos,json=extraIndexInfos,proto3" json:"extra_index_infos,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *SegmentInfos) Reset() { *m = SegmentInfos{} }
|
||||
func (m *SegmentInfos) String() string { return proto.CompactTextString(m) }
|
||||
func (*SegmentInfos) ProtoMessage() {}
|
||||
func (*SegmentInfos) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_4513485a144f6b06, []int{7}
|
||||
}
|
||||
|
||||
func (m *SegmentInfos) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_SegmentInfos.Unmarshal(m, b)
|
||||
}
|
||||
func (m *SegmentInfos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_SegmentInfos.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *SegmentInfos) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_SegmentInfos.Merge(m, src)
|
||||
}
|
||||
func (m *SegmentInfos) XXX_Size() int {
|
||||
return xxx_messageInfo_SegmentInfos.Size(m)
|
||||
}
|
||||
func (m *SegmentInfos) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_SegmentInfos.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_SegmentInfos proto.InternalMessageInfo
|
||||
|
||||
func (m *SegmentInfos) GetBaseInfo() *SegmentBaseInfo {
|
||||
if m != nil {
|
||||
return m.BaseInfo
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *SegmentInfos) GetIndexInfos() []*etcdpb.SegmentIndexInfo {
|
||||
if m != nil {
|
||||
return m.IndexInfos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *SegmentInfos) GetExtraIndexInfos() map[int64]*etcdpb.IndexInfo {
|
||||
if m != nil {
|
||||
return m.ExtraIndexInfos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type DescribeSegmentsResponse struct {
|
||||
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
|
||||
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
|
||||
SegmentInfos map[int64]*SegmentInfos `protobuf:"bytes,3,rep,name=segment_infos,json=segmentInfos,proto3" json:"segment_infos,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||||
XXX_unrecognized []byte `json:"-"`
|
||||
XXX_sizecache int32 `json:"-"`
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsResponse) Reset() { *m = DescribeSegmentsResponse{} }
|
||||
func (m *DescribeSegmentsResponse) String() string { return proto.CompactTextString(m) }
|
||||
func (*DescribeSegmentsResponse) ProtoMessage() {}
|
||||
func (*DescribeSegmentsResponse) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_4513485a144f6b06, []int{8}
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsResponse) XXX_Unmarshal(b []byte) error {
|
||||
return xxx_messageInfo_DescribeSegmentsResponse.Unmarshal(m, b)
|
||||
}
|
||||
func (m *DescribeSegmentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
return xxx_messageInfo_DescribeSegmentsResponse.Marshal(b, m, deterministic)
|
||||
}
|
||||
func (m *DescribeSegmentsResponse) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_DescribeSegmentsResponse.Merge(m, src)
|
||||
}
|
||||
func (m *DescribeSegmentsResponse) XXX_Size() int {
|
||||
return xxx_messageInfo_DescribeSegmentsResponse.Size(m)
|
||||
}
|
||||
func (m *DescribeSegmentsResponse) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_DescribeSegmentsResponse.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_DescribeSegmentsResponse proto.InternalMessageInfo
|
||||
|
||||
func (m *DescribeSegmentsResponse) GetStatus() *commonpb.Status {
|
||||
if m != nil {
|
||||
return m.Status
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsResponse) GetCollectionID() int64 {
|
||||
if m != nil {
|
||||
return m.CollectionID
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *DescribeSegmentsResponse) GetSegmentInfos() map[int64]*SegmentInfos {
|
||||
if m != nil {
|
||||
return m.SegmentInfos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterType((*AllocTimestampRequest)(nil), "milvus.proto.rootcoord.AllocTimestampRequest")
|
||||
proto.RegisterType((*AllocTimestampResponse)(nil), "milvus.proto.rootcoord.AllocTimestampResponse")
|
||||
proto.RegisterType((*AllocIDRequest)(nil), "milvus.proto.rootcoord.AllocIDRequest")
|
||||
proto.RegisterType((*AllocIDResponse)(nil), "milvus.proto.rootcoord.AllocIDResponse")
|
||||
proto.RegisterType((*ImportResult)(nil), "milvus.proto.rootcoord.ImportResult")
|
||||
proto.RegisterType((*DescribeSegmentsRequest)(nil), "milvus.proto.rootcoord.DescribeSegmentsRequest")
|
||||
proto.RegisterType((*SegmentBaseInfo)(nil), "milvus.proto.rootcoord.SegmentBaseInfo")
|
||||
proto.RegisterType((*SegmentInfos)(nil), "milvus.proto.rootcoord.SegmentInfos")
|
||||
proto.RegisterMapType((map[int64]*etcdpb.IndexInfo)(nil), "milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry")
|
||||
proto.RegisterType((*DescribeSegmentsResponse)(nil), "milvus.proto.rootcoord.DescribeSegmentsResponse")
|
||||
proto.RegisterMapType((map[int64]*SegmentInfos)(nil), "milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry")
|
||||
}
|
||||
|
||||
func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) }
|
||||
|
||||
var fileDescriptor_4513485a144f6b06 = []byte{
|
||||
// 1031 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0x7f, 0x6f, 0xda, 0x46,
|
||||
0x18, 0xc7, 0x43, 0x48, 0x48, 0xf2, 0x40, 0x48, 0x74, 0x6a, 0x52, 0x46, 0x2b, 0x8d, 0xb2, 0xad,
|
||||
0x25, 0x4d, 0x0b, 0x15, 0x95, 0xba, 0xfd, 0x9b, 0x80, 0x96, 0xa2, 0x2d, 0x52, 0x6b, 0xda, 0x69,
|
||||
0xbf, 0x2a, 0x74, 0xd8, 0xcf, 0xc0, 0x8a, 0xed, 0x73, 0x7c, 0xc7, 0xd2, 0xfe, 0xb9, 0xb7, 0xb6,
|
||||
0x17, 0xb1, 0xd7, 0x33, 0x9d, 0xed, 0x33, 0xb6, 0xb1, 0x89, 0xb3, 0xf5, 0x3f, 0xce, 0xf7, 0xb9,
|
||||
0xef, 0xf7, 0x9e, 0xe7, 0x7e, 0x3d, 0xc0, 0xa1, 0xc7, 0x98, 0x98, 0xe8, 0x8c, 0x79, 0x46, 0xd7,
|
||||
0xf5, 0x98, 0x60, 0xe4, 0xd8, 0x36, 0xad, 0x3f, 0x17, 0x3c, 0x68, 0x75, 0x65, 0xb7, 0xdf, 0xdb,
|
||||
0xac, 0xe9, 0xcc, 0xb6, 0x99, 0x13, 0x7c, 0x6f, 0xd6, 0xe2, 0x54, 0xb3, 0x6e, 0x3a, 0x02, 0x3d,
|
||||
0x87, 0x5a, 0x61, 0xbb, 0xea, 0x7a, 0xec, 0xe3, 0xa7, 0xb0, 0x71, 0x68, 0x50, 0x41, 0xe3, 0x16,
|
||||
0xed, 0x09, 0x1c, 0x9d, 0x59, 0x16, 0xd3, 0xdf, 0x99, 0x36, 0x72, 0x41, 0x6d, 0x57, 0xc3, 0xeb,
|
||||
0x05, 0x72, 0x41, 0x5e, 0xc0, 0xd6, 0x94, 0x72, 0x6c, 0x94, 0x5a, 0xa5, 0x4e, 0xb5, 0xff, 0xb0,
|
||||
0x9b, 0x98, 0x4a, 0xe8, 0x7f, 0xc9, 0x67, 0xe7, 0x94, 0xa3, 0xe6, 0x93, 0xe4, 0x1e, 0x6c, 0xeb,
|
||||
0x6c, 0xe1, 0x88, 0x46, 0xb9, 0x55, 0xea, 0xec, 0x6b, 0x41, 0xa3, 0xfd, 0x57, 0x09, 0x8e, 0xd3,
|
||||
0x0e, 0xdc, 0x65, 0x0e, 0x47, 0xf2, 0x12, 0x2a, 0x5c, 0x50, 0xb1, 0xe0, 0xa1, 0xc9, 0x83, 0x4c,
|
||||
0x93, 0xb1, 0x8f, 0x68, 0x21, 0x4a, 0x1e, 0xc2, 0x9e, 0x50, 0x4a, 0x8d, 0xcd, 0x56, 0xa9, 0xb3,
|
||||
0xa5, 0x2d, 0x3f, 0xe4, 0xcc, 0xe1, 0x67, 0xa8, 0xfb, 0x53, 0x18, 0x0d, 0x3f, 0x43, 0x74, 0x9b,
|
||||
0x71, 0x65, 0x0b, 0x0e, 0x22, 0xe5, 0xff, 0x13, 0x55, 0x1d, 0x36, 0x47, 0x43, 0x5f, 0xba, 0xac,
|
||||
0x6d, 0x8e, 0x86, 0x39, 0x71, 0xfc, 0xbd, 0x09, 0xb5, 0x91, 0xed, 0x32, 0x4f, 0x68, 0xc8, 0x17,
|
||||
0x96, 0xf8, 0x6f, 0x5e, 0xf7, 0x61, 0x47, 0x50, 0x7e, 0x35, 0x31, 0x8d, 0xd0, 0xb0, 0x22, 0x9b,
|
||||
0x23, 0x83, 0x7c, 0x09, 0x55, 0xb9, 0x3f, 0x1c, 0x66, 0xa0, 0xec, 0x2c, 0xfb, 0x9d, 0xa0, 0x3e,
|
||||
0x8d, 0x0c, 0xf2, 0x0a, 0xb6, 0xa5, 0x06, 0x36, 0xb6, 0x5a, 0xa5, 0x4e, 0xbd, 0xdf, 0xca, 0x74,
|
||||
0x0b, 0x26, 0x28, 0x3d, 0x51, 0x0b, 0x70, 0xd2, 0x84, 0x5d, 0x8e, 0x33, 0x1b, 0x1d, 0xc1, 0x1b,
|
||||
0xdb, 0xad, 0x72, 0xa7, 0xac, 0x45, 0x6d, 0xf2, 0x05, 0xec, 0xd2, 0x85, 0x60, 0x13, 0xd3, 0xe0,
|
||||
0x8d, 0x8a, 0xdf, 0xb7, 0x23, 0xdb, 0x23, 0x83, 0x93, 0x07, 0xb0, 0xe7, 0xb1, 0x9b, 0x49, 0x90,
|
||||
0x88, 0x1d, 0x7f, 0x36, 0xbb, 0x1e, 0xbb, 0x19, 0xc8, 0x36, 0xf9, 0x16, 0xb6, 0x4d, 0xe7, 0x0f,
|
||||
0xc6, 0x1b, 0xbb, 0xad, 0x72, 0xa7, 0xda, 0x7f, 0x94, 0x39, 0x97, 0x1f, 0xf0, 0xd3, 0x4f, 0xd4,
|
||||
0x5a, 0xe0, 0x1b, 0x6a, 0x7a, 0x5a, 0xc0, 0xf7, 0xff, 0x39, 0x86, 0x3d, 0x8d, 0x31, 0x31, 0x90,
|
||||
0xa7, 0x80, 0xb8, 0x40, 0x2e, 0x50, 0x0c, 0x98, 0xed, 0x32, 0x07, 0x9d, 0x60, 0xda, 0x9c, 0xbc,
|
||||
0x48, 0xaa, 0x45, 0x47, 0x6a, 0x15, 0x0d, 0x37, 0x54, 0xf3, 0x71, 0xce, 0x88, 0x14, 0xde, 0xde,
|
||||
0x20, 0xb6, 0xef, 0x28, 0x4f, 0xc3, 0x3b, 0x53, 0xbf, 0x1a, 0xcc, 0xa9, 0xe3, 0xa0, 0xb5, 0xce,
|
||||
0x31, 0x85, 0x2a, 0xc7, 0xaf, 0x92, 0x23, 0xc2, 0xc6, 0x58, 0x78, 0xa6, 0x33, 0x53, 0x9b, 0xb1,
|
||||
0xbd, 0x41, 0xae, 0xe1, 0xde, 0x05, 0xfa, 0xee, 0x26, 0x17, 0xa6, 0xce, 0x95, 0x61, 0x3f, 0xdf,
|
||||
0x70, 0x05, 0xbe, 0xa3, 0xe5, 0x04, 0x0e, 0x07, 0x1e, 0x52, 0x81, 0x03, 0x66, 0x59, 0xa8, 0x0b,
|
||||
0x93, 0x39, 0xe4, 0x59, 0xe6, 0xd0, 0x34, 0xa6, 0x8c, 0xd6, 0xed, 0xe3, 0xf6, 0x06, 0xf9, 0x0d,
|
||||
0xea, 0x43, 0x8f, 0xb9, 0x31, 0xf9, 0xa7, 0x99, 0xf2, 0x49, 0xa8, 0xa0, 0xf8, 0x04, 0xf6, 0x5f,
|
||||
0x53, 0x1e, 0xd3, 0x3e, 0xc9, 0xd4, 0x4e, 0x30, 0x4a, 0xfa, 0x51, 0x26, 0x7a, 0xce, 0x98, 0x15,
|
||||
0x4b, 0xcf, 0x0d, 0x90, 0x21, 0x72, 0xdd, 0x33, 0xa7, 0xf1, 0x04, 0x75, 0xb3, 0x23, 0x58, 0x01,
|
||||
0x95, 0x55, 0xaf, 0x30, 0x1f, 0x19, 0xbf, 0x87, 0x6a, 0x90, 0xf0, 0x33, 0xcb, 0xa4, 0x9c, 0x3c,
|
||||
0x59, 0xb3, 0x24, 0x3e, 0x51, 0x30, 0x61, 0x6f, 0x61, 0x4f, 0x26, 0x3a, 0x10, 0xfd, 0x26, 0x77,
|
||||
0x21, 0xee, 0x22, 0x39, 0x06, 0x38, 0xb3, 0x04, 0x7a, 0x81, 0xe6, 0xe3, 0x4c, 0xcd, 0x25, 0x50,
|
||||
0x50, 0xd4, 0x81, 0x83, 0xf1, 0x5c, 0x5e, 0x1f, 0x2a, 0x35, 0x9c, 0x9c, 0x66, 0x6f, 0xe8, 0x24,
|
||||
0xa5, 0xe4, 0x9f, 0x15, 0x83, 0xa3, 0x74, 0x7f, 0x80, 0x83, 0x20, 0x99, 0x6f, 0xa8, 0x27, 0x4c,
|
||||
0x7f, 0x91, 0x4f, 0xd7, 0xa4, 0x3c, 0xa2, 0x0a, 0x86, 0xf3, 0x0b, 0xec, 0xcb, 0xb4, 0x2e, 0xc5,
|
||||
0x4f, 0x72, 0x53, 0x7f, 0x57, 0xe9, 0x0f, 0x50, 0x7b, 0x4d, 0xf9, 0x52, 0xb9, 0x93, 0x77, 0x02,
|
||||
0x56, 0x84, 0x0b, 0x1d, 0x80, 0x2b, 0xa8, 0xcb, 0xac, 0x45, 0x83, 0x79, 0xce, 0xf1, 0x4d, 0x42,
|
||||
0xca, 0xe2, 0xb4, 0x10, 0x1b, 0x99, 0x39, 0x70, 0xa0, 0x0e, 0xc5, 0x38, 0x78, 0x73, 0x72, 0x56,
|
||||
0x21, 0x45, 0xad, 0x5f, 0xf5, 0x15, 0x38, 0xf2, 0x43, 0xa8, 0xc9, 0xb9, 0x8c, 0xd5, 0xfb, 0xd6,
|
||||
0xc9, 0x9d, 0xae, 0x42, 0x94, 0xd3, 0x49, 0x01, 0x72, 0xf5, 0x2c, 0x8f, 0x1c, 0x03, 0x3f, 0xae,
|
||||
0x3d, 0xcb, 0x3e, 0x51, 0x70, 0xe5, 0xe7, 0xb0, 0xaf, 0x42, 0x0b, 0x84, 0x4f, 0xd6, 0x86, 0x9f,
|
||||
0x90, 0x7e, 0x5a, 0x04, 0x8d, 0x02, 0x08, 0x6f, 0x8d, 0xc0, 0x25, 0xff, 0xd6, 0xb8, 0xcb, 0xe4,
|
||||
0xaf, 0xc3, 0x32, 0x2f, 0xaa, 0x34, 0xc9, 0xf3, 0x6e, 0x76, 0x05, 0xdd, 0xcd, 0xac, 0x79, 0x9b,
|
||||
0xdd, 0xa2, 0x78, 0x14, 0xc5, 0xef, 0xb0, 0x13, 0xd6, 0x7f, 0xe9, 0x5b, 0x2a, 0x35, 0x38, 0x2a,
|
||||
0x3d, 0x9b, 0x4f, 0x6e, 0xe5, 0x22, 0x75, 0x0a, 0x47, 0xef, 0x5d, 0x43, 0xbe, 0x90, 0xc1, 0x3b,
|
||||
0xac, 0x2a, 0x81, 0xf4, 0xaa, 0x2c, 0xab, 0x8d, 0x24, 0x77, 0xc9, 0x67, 0xb7, 0xe5, 0xcc, 0x82,
|
||||
0xfb, 0x1a, 0x5a, 0x48, 0x39, 0x0e, 0xdf, 0xfe, 0x78, 0x89, 0x9c, 0xd3, 0x19, 0x8e, 0x85, 0x87,
|
||||
0xd4, 0x4e, 0x57, 0x08, 0xc1, 0xff, 0x88, 0x1c, 0xb8, 0xe0, 0x0a, 0xe9, 0x70, 0x14, 0xee, 0xe5,
|
||||
0xef, 0xad, 0x05, 0x9f, 0xcb, 0xe2, 0xc8, 0x42, 0x81, 0x46, 0xfa, 0x48, 0xca, 0x9a, 0xb3, 0x9b,
|
||||
0x49, 0x16, 0x08, 0x69, 0x02, 0x70, 0x81, 0xe2, 0x12, 0x85, 0x67, 0xea, 0x79, 0x8f, 0xc7, 0x12,
|
||||
0xc8, 0x59, 0x96, 0x0c, 0x2e, 0x5a, 0x96, 0x31, 0x54, 0x82, 0x22, 0x97, 0xb4, 0x33, 0x07, 0xa9,
|
||||
0x12, 0x7d, 0x5d, 0xd1, 0x14, 0x95, 0xf1, 0xb1, 0x4b, 0xf1, 0x02, 0x45, 0xac, 0x78, 0xce, 0xb9,
|
||||
0x14, 0x93, 0xd0, 0xfa, 0x4b, 0x31, 0xcd, 0xc6, 0x22, 0xa8, 0x69, 0x28, 0x3b, 0xc2, 0x38, 0xbe,
|
||||
0xce, 0xdb, 0x93, 0xf1, 0x7f, 0x1b, 0xb7, 0xe4, 0xfd, 0xfc, 0xbb, 0x5f, 0x5f, 0xcd, 0x4c, 0x31,
|
||||
0x5f, 0x4c, 0x65, 0x4f, 0x2f, 0x40, 0x9f, 0x9b, 0x2c, 0xfc, 0xd5, 0x53, 0x9b, 0xb4, 0xe7, 0x8f,
|
||||
0xee, 0x45, 0x1e, 0xee, 0x74, 0x5a, 0xf1, 0x3f, 0xbd, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x05,
|
||||
0xc9, 0x1e, 0x16, 0x02, 0x0f, 0x00, 0x00,
|
||||
// 1295 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xed, 0x72, 0xda, 0x46,
|
||||
0x14, 0x35, 0xe0, 0xcf, 0x0b, 0x06, 0x67, 0xc7, 0x8e, 0x29, 0xc9, 0xb4, 0x84, 0xb6, 0x31, 0xce,
|
||||
0x07, 0x78, 0xc8, 0x4c, 0x9a, 0xe6, 0x9f, 0x0d, 0xa9, 0xc3, 0xb4, 0x9e, 0x49, 0x44, 0xd2, 0xe9,
|
||||
0x57, 0x46, 0x15, 0xd2, 0x0d, 0xd6, 0x58, 0x68, 0xb1, 0x76, 0x89, 0xed, 0x9f, 0x7d, 0x82, 0xbe,
|
||||
0x53, 0xfb, 0x00, 0x7d, 0x88, 0xbe, 0x48, 0x67, 0xb5, 0x92, 0x90, 0x84, 0x84, 0xe5, 0xa4, 0xff,
|
||||
0xd8, 0xd5, 0xd1, 0x39, 0xf7, 0x9e, 0xbb, 0xba, 0xbb, 0x0b, 0x6c, 0x39, 0x94, 0x72, 0x55, 0xa7,
|
||||
0xd4, 0x31, 0x5a, 0x13, 0x87, 0x72, 0x4a, 0x6e, 0x8f, 0x4d, 0xeb, 0xc3, 0x94, 0xc9, 0x51, 0x4b,
|
||||
0x3c, 0x76, 0x9f, 0xd6, 0x4a, 0x3a, 0x1d, 0x8f, 0xa9, 0x2d, 0xe7, 0x6b, 0xa5, 0x30, 0xaa, 0x56,
|
||||
0x36, 0x6d, 0x8e, 0x8e, 0xad, 0x59, 0xde, 0xb8, 0x38, 0x71, 0xe8, 0xe5, 0x95, 0x37, 0xd8, 0x32,
|
||||
0x34, 0xae, 0x85, 0x25, 0x6a, 0x15, 0xe4, 0xba, 0xa1, 0x8e, 0x91, 0x6b, 0x72, 0xa2, 0xa1, 0xc2,
|
||||
0xce, 0xa1, 0x65, 0x51, 0xfd, 0x8d, 0x39, 0x46, 0xc6, 0xb5, 0xf1, 0x44, 0xc1, 0xf3, 0x29, 0x32,
|
||||
0x4e, 0x0e, 0x60, 0x79, 0xa8, 0x31, 0xac, 0xe6, 0xea, 0xb9, 0x66, 0xb1, 0x73, 0xb7, 0x15, 0x89,
|
||||
0xcd, 0x0b, 0xe8, 0x84, 0x8d, 0x8e, 0x34, 0x86, 0x8a, 0x8b, 0x24, 0xdb, 0xb0, 0xa2, 0xd3, 0xa9,
|
||||
0xcd, 0xab, 0x85, 0x7a, 0xae, 0xb9, 0xa9, 0xc8, 0x41, 0xe3, 0x8f, 0x1c, 0xdc, 0x8e, 0x2b, 0xb0,
|
||||
0x09, 0xb5, 0x19, 0x92, 0x27, 0xb0, 0xca, 0xb8, 0xc6, 0xa7, 0xcc, 0x13, 0xb9, 0x93, 0x28, 0x32,
|
||||
0x70, 0x21, 0x8a, 0x07, 0x25, 0x77, 0x61, 0x83, 0xfb, 0x4c, 0xd5, 0x7c, 0x3d, 0xd7, 0x5c, 0x56,
|
||||
0x66, 0x13, 0x29, 0x31, 0xfc, 0x04, 0x65, 0x37, 0x84, 0x7e, 0xef, 0x7f, 0xc8, 0x2e, 0x1f, 0x66,
|
||||
0xb6, 0xa0, 0x12, 0x30, 0x7f, 0x4a, 0x56, 0x65, 0xc8, 0xf7, 0x7b, 0x2e, 0x75, 0x41, 0xc9, 0xf7,
|
||||
0x7b, 0x29, 0x79, 0xfc, 0x95, 0x87, 0x52, 0x7f, 0x3c, 0xa1, 0x0e, 0x57, 0x90, 0x4d, 0x2d, 0xfe,
|
||||
0x71, 0x5a, 0xbb, 0xb0, 0xc6, 0x35, 0x76, 0xa6, 0x9a, 0x86, 0x27, 0xb8, 0x2a, 0x86, 0x7d, 0x83,
|
||||
0x7c, 0x01, 0x45, 0xb1, 0x60, 0x6c, 0x6a, 0xa0, 0x78, 0x58, 0x70, 0x1f, 0x82, 0x3f, 0xd5, 0x37,
|
||||
0xc8, 0x53, 0x58, 0x11, 0x1c, 0x58, 0x5d, 0xae, 0xe7, 0x9a, 0xe5, 0x4e, 0x3d, 0x51, 0x4d, 0x06,
|
||||
0x28, 0x34, 0x51, 0x91, 0x70, 0x52, 0x83, 0x75, 0x86, 0xa3, 0x31, 0xda, 0x9c, 0x55, 0x57, 0xea,
|
||||
0x85, 0x66, 0x41, 0x09, 0xc6, 0xe4, 0x33, 0x58, 0xd7, 0xa6, 0x9c, 0xaa, 0xa6, 0xc1, 0xaa, 0xab,
|
||||
0xee, 0xb3, 0x35, 0x31, 0xee, 0x1b, 0x8c, 0xdc, 0x81, 0x0d, 0x87, 0x5e, 0xa8, 0xd2, 0x88, 0x35,
|
||||
0x37, 0x9a, 0x75, 0x87, 0x5e, 0x74, 0xc5, 0x98, 0x7c, 0x03, 0x2b, 0xa6, 0xfd, 0x9e, 0xb2, 0xea,
|
||||
0x7a, 0xbd, 0xd0, 0x2c, 0x76, 0xee, 0x25, 0xc6, 0xf2, 0x3d, 0x5e, 0xfd, 0xa8, 0x59, 0x53, 0x7c,
|
||||
0xa5, 0x99, 0x8e, 0x22, 0xf1, 0x8d, 0x3f, 0x73, 0xb0, 0xdb, 0x43, 0xa6, 0x3b, 0xe6, 0x10, 0x07,
|
||||
0x5e, 0x14, 0x1f, 0xbf, 0x2c, 0x1a, 0x50, 0xd2, 0xa9, 0x65, 0xa1, 0xce, 0x4d, 0x6a, 0x07, 0x25,
|
||||
0x8c, 0xcc, 0x91, 0xcf, 0x01, 0xbc, 0x74, 0xfb, 0x3d, 0x56, 0x2d, 0xb8, 0x49, 0x86, 0x66, 0x1a,
|
||||
0x53, 0xa8, 0x78, 0x81, 0x08, 0xe2, 0xbe, 0xfd, 0x9e, 0xce, 0xd1, 0xe6, 0x12, 0x68, 0xeb, 0x50,
|
||||
0x9c, 0x68, 0x0e, 0x37, 0x23, 0xca, 0xe1, 0x29, 0xf1, 0xad, 0x04, 0x32, 0x5e, 0x39, 0x67, 0x13,
|
||||
0x8d, 0x7f, 0xf3, 0x50, 0xf2, 0x74, 0x85, 0x26, 0x23, 0x3d, 0xd8, 0x10, 0x39, 0xa9, 0xc2, 0x27,
|
||||
0xcf, 0x82, 0xbd, 0x56, 0x72, 0x4f, 0x6a, 0xc5, 0x02, 0x56, 0xd6, 0x87, 0x7e, 0xe8, 0x3d, 0x28,
|
||||
0x9a, 0xb6, 0x81, 0x97, 0xaa, 0x2c, 0x4f, 0xde, 0x2d, 0xcf, 0x97, 0x51, 0x1e, 0xd1, 0x85, 0x5a,
|
||||
0x81, 0xb6, 0x81, 0x97, 0x2e, 0x07, 0x98, 0xfe, 0x4f, 0x46, 0x10, 0x6e, 0xe1, 0x25, 0x77, 0x34,
|
||||
0x35, 0xcc, 0x55, 0x70, 0xb9, 0xbe, 0xbd, 0x26, 0x26, 0x97, 0xa0, 0xf5, 0x42, 0xbc, 0x1d, 0x70,
|
||||
0xb3, 0x17, 0x36, 0x77, 0xae, 0x94, 0x0a, 0x46, 0x67, 0x6b, 0xbf, 0xc3, 0x76, 0x12, 0x90, 0x6c,
|
||||
0x41, 0xe1, 0x0c, 0xaf, 0x3c, 0xdb, 0xc5, 0x4f, 0xd2, 0x81, 0x95, 0x0f, 0x62, 0x29, 0xb9, 0x3e,
|
||||
0xcf, 0xad, 0x0d, 0x37, 0xa1, 0x59, 0x26, 0x12, 0xfa, 0x3c, 0xff, 0x2c, 0xd7, 0xf8, 0x3b, 0x0f,
|
||||
0xd5, 0xf9, 0xe5, 0xf6, 0x29, 0xbd, 0x22, 0xcb, 0x92, 0x1b, 0xc1, 0xa6, 0x57, 0xe8, 0x88, 0x75,
|
||||
0x47, 0x69, 0xd6, 0xa5, 0x45, 0x18, 0xf1, 0x54, 0x7a, 0x58, 0x62, 0xa1, 0xa9, 0x1a, 0xc2, 0xad,
|
||||
0x39, 0x48, 0x82, 0x7b, 0xcf, 0xa3, 0xee, 0x7d, 0x95, 0xa5, 0x84, 0x21, 0x17, 0x3b, 0xff, 0xec,
|
||||
0xc2, 0x86, 0x42, 0x29, 0xef, 0x0a, 0x14, 0x99, 0x00, 0x39, 0x46, 0xde, 0xa5, 0xe3, 0x09, 0xb5,
|
||||
0xd1, 0x96, 0xbd, 0x86, 0x91, 0x83, 0x28, 0x69, 0xb0, 0x31, 0xce, 0x43, 0xbd, 0xcf, 0xbd, 0x76,
|
||||
0x3f, 0xe5, 0x8d, 0x18, 0xbc, 0xb1, 0x44, 0xc6, 0xae, 0xa2, 0xd8, 0xc2, 0xde, 0x98, 0xfa, 0x59,
|
||||
0xf7, 0x54, 0xb3, 0x6d, 0xb4, 0x16, 0x29, 0xc6, 0xa0, 0xbe, 0x62, 0xec, 0x3b, 0xf0, 0x06, 0x03,
|
||||
0xee, 0x98, 0xf6, 0xc8, 0xf7, 0xbc, 0xb1, 0x44, 0xce, 0x61, 0xfb, 0x18, 0x5d, 0x75, 0x93, 0x71,
|
||||
0x53, 0x67, 0xbe, 0x60, 0x27, 0x5d, 0x70, 0x0e, 0x7c, 0x43, 0x49, 0x15, 0xb6, 0xba, 0x0e, 0x6a,
|
||||
0x1c, 0xbb, 0xc1, 0x3a, 0x22, 0x8f, 0x12, 0x5f, 0x8d, 0xc3, 0x7c, 0xa1, 0x45, 0x8b, 0xb7, 0xb1,
|
||||
0x44, 0x7e, 0x85, 0x72, 0xcf, 0xa1, 0x93, 0x10, 0xfd, 0x83, 0x44, 0xfa, 0x28, 0x28, 0x23, 0xb9,
|
||||
0x0a, 0x9b, 0x2f, 0x35, 0x16, 0xe2, 0xde, 0x4f, 0xe4, 0x8e, 0x60, 0x7c, 0xea, 0x7b, 0x89, 0xd0,
|
||||
0x23, 0x4a, 0xad, 0x90, 0x3d, 0x17, 0x40, 0xfc, 0x6f, 0x24, 0xa4, 0xd2, 0x4a, 0xce, 0x60, 0x0e,
|
||||
0xe8, 0x4b, 0xb5, 0x33, 0xe3, 0x03, 0xe1, 0xb7, 0x50, 0x94, 0x86, 0x1f, 0x5a, 0xa6, 0xc6, 0xc8,
|
||||
0xde, 0x82, 0x92, 0xb8, 0x88, 0x8c, 0x86, 0xbd, 0x86, 0x0d, 0x61, 0xb4, 0x24, 0xfd, 0x3a, 0xb5,
|
||||
0x10, 0x37, 0xa1, 0x1c, 0x00, 0x1c, 0x5a, 0x1c, 0x1d, 0xc9, 0x79, 0x3f, 0x91, 0x73, 0x06, 0xc8,
|
||||
0x48, 0x6a, 0x43, 0x65, 0x70, 0x2a, 0xf6, 0x7c, 0xdf, 0x1a, 0x46, 0x1e, 0x26, 0x2f, 0xe8, 0x28,
|
||||
0xca, 0xa7, 0x7f, 0x94, 0x0d, 0x1c, 0xd8, 0xfd, 0x0e, 0x2a, 0xd2, 0xcc, 0x57, 0xfe, 0x3e, 0x9a,
|
||||
0xa2, 0x17, 0x43, 0x65, 0x4c, 0xe7, 0x67, 0xd8, 0x14, 0xb6, 0xce, 0xc8, 0xf7, 0x53, 0xad, 0xbf,
|
||||
0x29, 0xf5, 0x3b, 0x28, 0xbd, 0xd4, 0xd8, 0x8c, 0xb9, 0x99, 0xf6, 0x05, 0xcc, 0x11, 0x67, 0xfa,
|
||||
0x00, 0xce, 0xa0, 0x2c, 0x5c, 0x0b, 0x5e, 0x66, 0x29, 0x9f, 0x6f, 0x14, 0xe4, 0x4b, 0x3c, 0xcc,
|
||||
0x84, 0x0d, 0xc4, 0x6c, 0xa8, 0xc4, 0x76, 0xa4, 0x94, 0x2a, 0xc4, 0x50, 0x8b, 0xab, 0x3e, 0x07,
|
||||
0x0e, 0xf4, 0x10, 0x4a, 0x22, 0x16, 0x7f, 0xf7, 0x4b, 0xf1, 0x2e, 0x0c, 0xf1, 0x95, 0xf6, 0x33,
|
||||
0x20, 0x43, 0x4d, 0x64, 0x2b, 0xbe, 0xd1, 0x92, 0x76, 0xf6, 0x2d, 0x59, 0x2a, 0x1e, 0xdc, 0x74,
|
||||
0x0f, 0x0f, 0x37, 0x11, 0xf7, 0x88, 0xb2, 0xb0, 0x89, 0xb8, 0x88, 0x8c, 0x4b, 0xee, 0x14, 0x36,
|
||||
0x7d, 0x51, 0x49, 0xbc, 0xbf, 0xd0, 0xf7, 0x08, 0xf5, 0x83, 0x2c, 0xd0, 0x20, 0x01, 0xaf, 0x5d,
|
||||
0x49, 0x95, 0xf4, 0x76, 0x75, 0x93, 0xe0, 0xcf, 0xbd, 0x4b, 0x61, 0x70, 0x2f, 0x25, 0x8f, 0xd3,
|
||||
0x9c, 0x4d, 0xbc, 0x21, 0xd7, 0x5a, 0x59, 0xe1, 0x41, 0x16, 0xbf, 0xc1, 0x9a, 0x77, 0x5b, 0x8c,
|
||||
0xb7, 0xc7, 0xd8, 0xcb, 0xc1, 0x45, 0xb5, 0xb6, 0x77, 0x2d, 0x2e, 0x60, 0xd7, 0x60, 0xe7, 0xed,
|
||||
0xc4, 0x10, 0x5b, 0xb3, 0x3c, 0x00, 0xf8, 0x47, 0x90, 0x78, 0x55, 0x66, 0xc7, 0x9c, 0x28, 0xee,
|
||||
0x84, 0x8d, 0xae, 0xf3, 0xcc, 0x82, 0x5d, 0x05, 0x2d, 0xd4, 0x18, 0xf6, 0x5e, 0xff, 0x70, 0x82,
|
||||
0x8c, 0x69, 0x23, 0x1c, 0x70, 0x07, 0xb5, 0x71, 0xfc, 0x68, 0x22, 0xff, 0x86, 0x48, 0x01, 0x67,
|
||||
0xac, 0x90, 0x0e, 0x3b, 0xde, 0x5a, 0xfe, 0xce, 0x9a, 0xb2, 0x53, 0x71, 0x2a, 0xb3, 0x90, 0xa3,
|
||||
0x11, 0xef, 0x05, 0xe2, 0x86, 0xda, 0x4a, 0x44, 0x66, 0x48, 0x49, 0x05, 0x38, 0x46, 0x7e, 0x82,
|
||||
0xdc, 0x31, 0xf5, 0xb4, 0x5d, 0x6b, 0x06, 0x48, 0x29, 0x4b, 0x02, 0x2e, 0x28, 0xcb, 0x00, 0x56,
|
||||
0xe5, 0x95, 0x98, 0x34, 0x12, 0x5f, 0xf2, 0x2f, 0xf4, 0x8b, 0x4e, 0x6b, 0xc1, 0xa5, 0x3f, 0xd4,
|
||||
0x8d, 0x8f, 0x91, 0x87, 0xae, 0xda, 0x29, 0xdd, 0x38, 0x0a, 0x5a, 0xdc, 0x8d, 0xe3, 0xd8, 0x50,
|
||||
0x06, 0x25, 0x05, 0xc5, 0x03, 0x2f, 0x8f, 0xd4, 0xd3, 0x7b, 0xf8, 0xbf, 0x89, 0x6b, 0x7c, 0x3f,
|
||||
0x7a, 0xf6, 0xcb, 0xd3, 0x91, 0xc9, 0x4f, 0xa7, 0x43, 0xf1, 0xa4, 0x2d, 0xa1, 0x8f, 0x4d, 0xea,
|
||||
0xfd, 0x6a, 0xfb, 0x8b, 0xb4, 0xed, 0xbe, 0xdd, 0x0e, 0x34, 0x26, 0xc3, 0xe1, 0xaa, 0x3b, 0xf5,
|
||||
0xe4, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4f, 0x2c, 0xbd, 0x42, 0x41, 0x13, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
|
|
@ -482,6 +725,7 @@ type RootCoordClient interface {
|
|||
ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error)
|
||||
DescribeSegment(ctx context.Context, in *milvuspb.DescribeSegmentRequest, opts ...grpc.CallOption) (*milvuspb.DescribeSegmentResponse, error)
|
||||
ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequest, opts ...grpc.CallOption) (*milvuspb.ShowSegmentsResponse, error)
|
||||
DescribeSegments(ctx context.Context, in *DescribeSegmentsRequest, opts ...grpc.CallOption) (*DescribeSegmentsResponse, error)
|
||||
CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
|
||||
DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRequest, opts ...grpc.CallOption) (*milvuspb.DescribeIndexResponse, error)
|
||||
DropIndex(ctx context.Context, in *milvuspb.DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
|
||||
|
|
@ -659,6 +903,15 @@ func (c *rootCoordClient) ShowSegments(ctx context.Context, in *milvuspb.ShowSeg
|
|||
return out, nil
|
||||
}
|
||||
|
||||
func (c *rootCoordClient) DescribeSegments(ctx context.Context, in *DescribeSegmentsRequest, opts ...grpc.CallOption) (*DescribeSegmentsResponse, error) {
|
||||
out := new(DescribeSegmentsResponse)
|
||||
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/DescribeSegments", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *rootCoordClient) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
|
||||
out := new(commonpb.Status)
|
||||
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/CreateIndex", in, out, opts...)
|
||||
|
|
@ -832,6 +1085,7 @@ type RootCoordServer interface {
|
|||
ShowPartitions(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)
|
||||
DescribeSegment(context.Context, *milvuspb.DescribeSegmentRequest) (*milvuspb.DescribeSegmentResponse, error)
|
||||
ShowSegments(context.Context, *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)
|
||||
DescribeSegments(context.Context, *DescribeSegmentsRequest) (*DescribeSegmentsResponse, error)
|
||||
CreateIndex(context.Context, *milvuspb.CreateIndexRequest) (*commonpb.Status, error)
|
||||
DescribeIndex(context.Context, *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
|
||||
DropIndex(context.Context, *milvuspb.DropIndexRequest) (*commonpb.Status, error)
|
||||
|
|
@ -903,6 +1157,9 @@ func (*UnimplementedRootCoordServer) DescribeSegment(ctx context.Context, req *m
|
|||
func (*UnimplementedRootCoordServer) ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method ShowSegments not implemented")
|
||||
}
|
||||
func (*UnimplementedRootCoordServer) DescribeSegments(ctx context.Context, req *DescribeSegmentsRequest) (*DescribeSegmentsResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method DescribeSegments not implemented")
|
||||
}
|
||||
func (*UnimplementedRootCoordServer) CreateIndex(ctx context.Context, req *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method CreateIndex not implemented")
|
||||
}
|
||||
|
|
@ -1250,6 +1507,24 @@ func _RootCoord_ShowSegments_Handler(srv interface{}, ctx context.Context, dec f
|
|||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _RootCoord_DescribeSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(DescribeSegmentsRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(RootCoordServer).DescribeSegments(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/milvus.proto.rootcoord.RootCoord/DescribeSegments",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(RootCoordServer).DescribeSegments(ctx, req.(*DescribeSegmentsRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _RootCoord_CreateIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(milvuspb.CreateIndexRequest)
|
||||
if err := dec(in); err != nil {
|
||||
|
|
@ -1538,6 +1813,10 @@ var _RootCoord_serviceDesc = grpc.ServiceDesc{
|
|||
MethodName: "ShowSegments",
|
||||
Handler: _RootCoord_ShowSegments_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "DescribeSegments",
|
||||
Handler: _RootCoord_DescribeSegments_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "CreateIndex",
|
||||
Handler: _RootCoord_CreateIndex_Handler,
|
||||
|
|
|
|||
|
|
@ -874,6 +874,10 @@ func (coord *RootCoordMock) ShowSegments(ctx context.Context, req *milvuspb.Show
|
|||
}, nil
|
||||
}
|
||||
|
||||
func (coord *RootCoordMock) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
panic("implement me")
|
||||
}
|
||||
|
||||
func (coord *RootCoordMock) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
|
||||
code := coord.state.Load().(internalpb.StateCode)
|
||||
if code != internalpb.StateCode_Healthy {
|
||||
|
|
|
|||
|
|
@ -6,6 +6,8 @@ import (
|
|||
"fmt"
|
||||
"path"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
|
||||
|
||||
"go.uber.org/zap"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/log"
|
||||
|
|
@ -191,7 +193,7 @@ func (broker *globalMetaBroker) getIndexFilePaths(ctx context.Context, buildID i
|
|||
return pathResponse.FilePaths, nil
|
||||
}
|
||||
|
||||
func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID UniqueID, indexInfo *querypb.VecFieldIndexInfo) error {
|
||||
func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID UniqueID, indexInfo *querypb.FieldIndexInfo) error {
|
||||
if !indexInfo.EnableIndex {
|
||||
log.Debug(fmt.Sprintf("fieldID %d of segment %d don't has index", indexInfo.FieldID, segmentID))
|
||||
return nil
|
||||
|
|
@ -267,41 +269,148 @@ func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID Un
|
|||
return nil
|
||||
}
|
||||
|
||||
func (broker *globalMetaBroker) getIndexInfo(ctx context.Context, collectionID UniqueID, segmentID UniqueID, schema *schemapb.CollectionSchema) ([]*querypb.VecFieldIndexInfo, error) {
|
||||
// TODO:: collection has multi vec field, and build index for every vec field, get indexInfo by fieldID
|
||||
// Currently, each collection can only have one vector field
|
||||
vecFieldIDs := funcutil.GetVecFieldIDs(schema)
|
||||
if len(vecFieldIDs) != 1 {
|
||||
err := fmt.Errorf("collection %d has multi vec field, num of vec fields = %d", collectionID, len(vecFieldIDs))
|
||||
log.Error("get index info failed",
|
||||
zap.Int64("collectionID", collectionID),
|
||||
zap.Int64("segmentID", segmentID),
|
||||
// Better to let index params key appear in the file paths first.
|
||||
func (broker *globalMetaBroker) loadIndexExtraInfo(ctx context.Context, fieldPathInfo *indexpb.IndexFilePathInfo) (*extraIndexInfo, error) {
|
||||
indexCodec := storage.NewIndexFileBinlogCodec()
|
||||
for _, indexFilePath := range fieldPathInfo.IndexFilePaths {
|
||||
// get index params when detecting indexParamPrefix
|
||||
if path.Base(indexFilePath) == storage.IndexParamsKey {
|
||||
content, err := broker.cm.MultiRead([]string{indexFilePath})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(content) <= 0 {
|
||||
return nil, fmt.Errorf("failed to read index file binlog, path: %s", indexFilePath)
|
||||
}
|
||||
|
||||
indexPiece := content[0]
|
||||
_, indexParams, indexName, _, err := indexCodec.Deserialize([]*storage.Blob{{Key: storage.IndexParamsKey, Value: indexPiece}})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &extraIndexInfo{
|
||||
indexName: indexName,
|
||||
indexParams: funcutil.Map2KeyValuePair(indexParams),
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
return nil, errors.New("failed to load index extra info")
|
||||
}
|
||||
|
||||
func (broker *globalMetaBroker) describeSegments(ctx context.Context, collectionID UniqueID, segmentIDs []UniqueID) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
resp, err := broker.rootCoord.DescribeSegments(ctx, &rootcoordpb.DescribeSegmentsRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_DescribeSegments,
|
||||
},
|
||||
CollectionID: collectionID,
|
||||
SegmentIDs: segmentIDs,
|
||||
})
|
||||
if err != nil {
|
||||
log.Error("failed to describe segments",
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64s("segments", segmentIDs),
|
||||
zap.Error(err))
|
||||
return nil, err
|
||||
}
|
||||
indexInfo := &querypb.VecFieldIndexInfo{
|
||||
FieldID: vecFieldIDs[0],
|
||||
}
|
||||
// check the buildID of the segment's index whether exist on rootCoord
|
||||
enableIndex, buildID, err := broker.getIndexBuildID(ctx, collectionID, segmentID)
|
||||
|
||||
log.Debug("describe segments successfully",
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64s("segments", segmentIDs))
|
||||
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// return: segment_id -> segment_index_infos
|
||||
func (broker *globalMetaBroker) getFullIndexInfos(ctx context.Context, collectionID UniqueID, segmentIDs []UniqueID) (map[UniqueID][]*querypb.FieldIndexInfo, error) {
|
||||
resp, err := broker.describeSegments(ctx, collectionID, segmentIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// if the segment.EnableIndex == false, then load the segment immediately
|
||||
if !enableIndex {
|
||||
indexInfo.EnableIndex = false
|
||||
} else {
|
||||
indexInfo.BuildID = buildID
|
||||
indexInfo.EnableIndex = true
|
||||
err = broker.parseIndexInfo(ctx, segmentID, indexInfo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
ret := make(map[UniqueID][]*querypb.FieldIndexInfo)
|
||||
for _, segmentID := range segmentIDs {
|
||||
infos, ok := resp.GetSegmentInfos()[segmentID]
|
||||
if !ok {
|
||||
log.Warn("segment not found",
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64("segment", segmentID))
|
||||
return nil, fmt.Errorf("segment not found, collection: %d, segment: %d", collectionID, segmentID)
|
||||
}
|
||||
|
||||
if _, ok := ret[segmentID]; !ok {
|
||||
ret[segmentID] = make([]*querypb.FieldIndexInfo, 0, len(infos.IndexInfos))
|
||||
}
|
||||
|
||||
for _, info := range infos.IndexInfos {
|
||||
extraInfo, ok := infos.GetExtraIndexInfos()[info.IndexID]
|
||||
indexInfo := &querypb.FieldIndexInfo{
|
||||
FieldID: info.FieldID,
|
||||
EnableIndex: info.EnableIndex,
|
||||
IndexName: "",
|
||||
IndexID: info.IndexID,
|
||||
BuildID: info.BuildID,
|
||||
IndexParams: nil,
|
||||
IndexFilePaths: nil,
|
||||
IndexSize: 0,
|
||||
}
|
||||
|
||||
if !info.EnableIndex {
|
||||
ret[segmentID] = append(ret[segmentID], indexInfo)
|
||||
continue
|
||||
}
|
||||
|
||||
paths, err := broker.getIndexFilePaths(ctx, info.BuildID)
|
||||
if err != nil {
|
||||
log.Error("failed to get index file paths",
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64("segment", segmentID),
|
||||
zap.Int64("buildID", info.BuildID),
|
||||
zap.Error(err))
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(paths) <= 0 || len(paths[0].IndexFilePaths) <= 0 {
|
||||
log.Warn("index not ready", zap.Int64("index_build_id", info.BuildID))
|
||||
return nil, fmt.Errorf("index not ready, index build id: %d", info.BuildID)
|
||||
}
|
||||
|
||||
indexInfo.IndexFilePaths = paths[0].IndexFilePaths
|
||||
indexInfo.IndexSize = int64(paths[0].SerializedSize)
|
||||
|
||||
if ok {
|
||||
indexInfo.IndexName = extraInfo.IndexName
|
||||
indexInfo.IndexParams = extraInfo.IndexParams
|
||||
} else {
|
||||
// get index name, index params from binlog.
|
||||
extra, err := broker.loadIndexExtraInfo(ctx, paths[0])
|
||||
if err != nil {
|
||||
log.Error("failed to load index extra info",
|
||||
zap.Int64("index build id", info.BuildID),
|
||||
zap.Error(err))
|
||||
return nil, err
|
||||
}
|
||||
indexInfo.IndexName = extra.indexName
|
||||
indexInfo.IndexParams = extra.indexParams
|
||||
}
|
||||
|
||||
ret[segmentID] = append(ret[segmentID], indexInfo)
|
||||
}
|
||||
}
|
||||
log.Debug("get index info success", zap.Int64("collectionID", collectionID), zap.Int64("segmentID", segmentID), zap.Bool("enableIndex", enableIndex))
|
||||
|
||||
return []*querypb.VecFieldIndexInfo{indexInfo}, nil
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (broker *globalMetaBroker) getIndexInfo(ctx context.Context, collectionID UniqueID, segmentID UniqueID, schema *schemapb.CollectionSchema) ([]*querypb.FieldIndexInfo, error) {
|
||||
segmentIndexInfos, err := broker.getFullIndexInfos(ctx, collectionID, []UniqueID{segmentID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if infos, ok := segmentIndexInfos[segmentID]; ok {
|
||||
return infos, nil
|
||||
}
|
||||
return nil, fmt.Errorf("failed to get segment index infos, collection: %d, segment: %d", collectionID, segmentID)
|
||||
}
|
||||
|
||||
func (broker *globalMetaBroker) generateSegmentLoadInfo(ctx context.Context,
|
||||
|
|
|
|||
|
|
@ -30,6 +30,14 @@ import (
|
|||
"github.com/milvus-io/milvus/internal/proto/querypb"
|
||||
)
|
||||
|
||||
type extraIndexInfo struct {
|
||||
indexID UniqueID
|
||||
indexName string
|
||||
indexParams []*commonpb.KeyValuePair
|
||||
indexSize uint64
|
||||
indexFilePaths []string
|
||||
}
|
||||
|
||||
// IndexChecker checks index
|
||||
type IndexChecker struct {
|
||||
ctx context.Context
|
||||
|
|
|
|||
|
|
@ -22,6 +22,10 @@ import (
|
|||
"fmt"
|
||||
"sync"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/etcdpb"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/common"
|
||||
"github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/datapb"
|
||||
|
|
@ -256,6 +260,43 @@ func (rc *rootCoordMock) DescribeSegment(ctx context.Context, req *milvuspb.Desc
|
|||
}, nil
|
||||
}
|
||||
|
||||
func (rc *rootCoordMock) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
if rc.returnGrpcError {
|
||||
return nil, errors.New("describe segment failed")
|
||||
}
|
||||
|
||||
if rc.returnError {
|
||||
return &rootcoordpb.DescribeSegmentsResponse{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_UnexpectedError,
|
||||
Reason: "describe segments failed",
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
ret := &rootcoordpb.DescribeSegmentsResponse{
|
||||
Status: &commonpb.Status{
|
||||
ErrorCode: commonpb.ErrorCode_Success,
|
||||
},
|
||||
CollectionID: req.GetCollectionID(),
|
||||
SegmentInfos: make(map[int64]*rootcoordpb.SegmentInfos),
|
||||
}
|
||||
|
||||
for _, segID := range req.GetSegmentIDs() {
|
||||
ret.SegmentInfos[segID] = &rootcoordpb.SegmentInfos{
|
||||
IndexInfos: []*etcdpb.SegmentIndexInfo{
|
||||
{
|
||||
SegmentID: segID,
|
||||
EnableIndex: rc.enableIndex,
|
||||
},
|
||||
},
|
||||
ExtraIndexInfos: nil,
|
||||
}
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
type dataCoordMock struct {
|
||||
types.DataCoord
|
||||
collections []UniqueID
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} {
|
|||
func estimateSegmentSize(segmentLoadInfo *querypb.SegmentLoadInfo) int64 {
|
||||
segmentSize := int64(0)
|
||||
|
||||
vecFieldID2IndexInfo := make(map[int64]*querypb.VecFieldIndexInfo)
|
||||
vecFieldID2IndexInfo := make(map[int64]*querypb.FieldIndexInfo)
|
||||
for _, fieldIndexInfo := range segmentLoadInfo.IndexInfos {
|
||||
if fieldIndexInfo.EnableIndex {
|
||||
fieldID := fieldIndexInfo.FieldID
|
||||
|
|
|
|||
|
|
@ -296,6 +296,21 @@ func (colReplica *collectionReplica) getPartitionIDs(collectionID UniqueID) ([]U
|
|||
return collection.partitionIDs, nil
|
||||
}
|
||||
|
||||
func (colReplica *collectionReplica) getIndexedFieldIDByCollectionIDPrivate(collectionID UniqueID, segment *Segment) ([]FieldID, error) {
|
||||
fields, err := colReplica.getFieldsByCollectionIDPrivate(collectionID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
fieldIDS := make([]FieldID, 0)
|
||||
for _, field := range fields {
|
||||
if segment.hasLoadIndexForIndexedField(field.FieldID) {
|
||||
fieldIDS = append(fieldIDS, field.FieldID)
|
||||
}
|
||||
}
|
||||
return fieldIDS, nil
|
||||
}
|
||||
|
||||
func (colReplica *collectionReplica) getVecFieldIDsByCollectionIDPrivate(collectionID UniqueID) ([]FieldID, error) {
|
||||
fields, err := colReplica.getFieldsByCollectionIDPrivate(collectionID)
|
||||
if err != nil {
|
||||
|
|
@ -720,16 +735,15 @@ func newCollectionReplica(etcdKv *etcdkv.EtcdKV) ReplicaInterface {
|
|||
func (colReplica *collectionReplica) getSegmentInfo(segment *Segment) *querypb.SegmentInfo {
|
||||
var indexName string
|
||||
var indexID int64
|
||||
var indexInfos []*querypb.FieldIndexInfo
|
||||
// TODO:: segment has multi vec column
|
||||
vecFieldIDs, _ := colReplica.getVecFieldIDsByCollectionIDPrivate(segment.collectionID)
|
||||
for _, fieldID := range vecFieldIDs {
|
||||
if segment.hasLoadIndexForVecField(fieldID) {
|
||||
fieldInfo, err := segment.getVectorFieldInfo(fieldID)
|
||||
if err == nil {
|
||||
indexName = fieldInfo.indexInfo.IndexName
|
||||
indexID = fieldInfo.indexInfo.IndexID
|
||||
break
|
||||
}
|
||||
indexedFieldIDs, _ := colReplica.getIndexedFieldIDByCollectionIDPrivate(segment.collectionID, segment)
|
||||
for _, fieldID := range indexedFieldIDs {
|
||||
fieldInfo, err := segment.getIndexedFieldInfo(fieldID)
|
||||
if err == nil {
|
||||
indexName = fieldInfo.indexInfo.IndexName
|
||||
indexID = fieldInfo.indexInfo.IndexID
|
||||
indexInfos = append(indexInfos, fieldInfo.indexInfo)
|
||||
}
|
||||
}
|
||||
info := &querypb.SegmentInfo{
|
||||
|
|
@ -743,6 +757,7 @@ func (colReplica *collectionReplica) getSegmentInfo(segment *Segment) *querypb.S
|
|||
IndexID: indexID,
|
||||
DmChannel: segment.vChannelID,
|
||||
SegmentState: segment.segmentType,
|
||||
IndexInfos: indexInfos,
|
||||
}
|
||||
return info
|
||||
}
|
||||
|
|
|
|||
|
|
@ -244,8 +244,8 @@ func TestCollectionReplica_getSegmentInfosByColID(t *testing.T) {
|
|||
fieldID := vectorFieldIDDs[0]
|
||||
|
||||
indexID := UniqueID(10000)
|
||||
indexInfo := &VectorFieldInfo{
|
||||
indexInfo: &querypb.VecFieldIndexInfo{
|
||||
indexInfo := &IndexedFieldInfo{
|
||||
indexInfo: &querypb.FieldIndexInfo{
|
||||
IndexName: "test-index-name",
|
||||
IndexID: indexID,
|
||||
EnableIndex: true,
|
||||
|
|
@ -259,7 +259,7 @@ func TestCollectionReplica_getSegmentInfosByColID(t *testing.T) {
|
|||
|
||||
segment2, err := newSegment(collection, UniqueID(2), defaultPartitionID, collectionID, "", segmentTypeSealed, true)
|
||||
assert.NoError(t, err)
|
||||
segment2.setVectorFieldInfo(fieldID, indexInfo)
|
||||
segment2.setIndexedFieldInfo(fieldID, indexInfo)
|
||||
err = node.historical.replica.setSegment(segment2)
|
||||
assert.NoError(t, err)
|
||||
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ func (h *historical) retrieve(collID UniqueID, partIDs []UniqueID, vcm storage.C
|
|||
return retrieveResults, retrieveSegmentIDs, retrievePartIDs, err
|
||||
}
|
||||
|
||||
if err = seg.fillVectorFieldsData(collID, vcm, result); err != nil {
|
||||
if err = seg.fillIndexedFieldsData(collID, vcm, result); err != nil {
|
||||
return retrieveResults, retrieveSegmentIDs, retrievePartIDs, err
|
||||
}
|
||||
retrieveResults = append(retrieveResults, result)
|
||||
|
|
|
|||
|
|
@ -341,8 +341,8 @@ func TestImpl_GetSegmentInfo(t *testing.T) {
|
|||
seg, err := node.historical.replica.getSegmentByID(defaultSegmentID)
|
||||
assert.NoError(t, err)
|
||||
|
||||
seg.setVectorFieldInfo(simpleVecField.id, &VectorFieldInfo{
|
||||
indexInfo: &queryPb.VecFieldIndexInfo{
|
||||
seg.setIndexedFieldInfo(simpleVecField.id, &IndexedFieldInfo{
|
||||
indexInfo: &queryPb.FieldIndexInfo{
|
||||
IndexName: "query-node-test",
|
||||
IndexID: UniqueID(0),
|
||||
BuildID: UniqueID(0),
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ func deleteLoadIndexInfo(info *LoadIndexInfo) {
|
|||
C.DeleteLoadIndexInfo(info.cLoadIndexInfo)
|
||||
}
|
||||
|
||||
func (li *LoadIndexInfo) appendIndexInfo(bytesIndex [][]byte, indexInfo *querypb.VecFieldIndexInfo) error {
|
||||
func (li *LoadIndexInfo) appendIndexInfo(bytesIndex [][]byte, indexInfo *querypb.FieldIndexInfo) error {
|
||||
fieldID := indexInfo.FieldID
|
||||
indexParams := funcutil.KeyValuePair2Map(indexInfo.IndexParams)
|
||||
indexPaths := indexInfo.IndexFilePaths
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ func TestLoadIndexInfo(t *testing.T) {
|
|||
loadIndexInfo, err := newLoadIndexInfo()
|
||||
assert.Nil(t, err)
|
||||
|
||||
indexInfo := &querypb.VecFieldIndexInfo{
|
||||
indexInfo := &querypb.FieldIndexInfo{
|
||||
FieldID: UniqueID(0),
|
||||
IndexParams: indexParams,
|
||||
IndexFilePaths: indexPaths,
|
||||
|
|
|
|||
|
|
@ -283,7 +283,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI
|
|||
return err
|
||||
}
|
||||
_, indexParams := genIndexParams(indexType, metricType)
|
||||
indexInfo := &querypb.VecFieldIndexInfo{
|
||||
indexInfo := &querypb.FieldIndexInfo{
|
||||
FieldID: simpleVecField.id,
|
||||
EnableIndex: true,
|
||||
IndexName: indexName,
|
||||
|
|
@ -307,7 +307,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI
|
|||
PartitionID: defaultPartitionID,
|
||||
CollectionID: defaultCollectionID,
|
||||
BinlogPaths: fieldBinlog,
|
||||
IndexInfos: []*querypb.VecFieldIndexInfo{indexInfo},
|
||||
IndexInfos: []*querypb.FieldIndexInfo{indexInfo},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
|
@ -321,7 +321,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI
|
|||
if err != nil {
|
||||
return err
|
||||
}
|
||||
vecFieldInfo, err := segment.getVectorFieldInfo(simpleVecField.id)
|
||||
vecFieldInfo, err := segment.getIndexedFieldInfo(simpleVecField.id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -355,6 +355,11 @@ func generateIndex(segmentID UniqueID) ([]string, error) {
|
|||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer func() {
|
||||
if err := index.Delete(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}()
|
||||
|
||||
err = index.Build(indexcgowrapper.GenFloatVecDataset(indexRowData))
|
||||
if err != nil {
|
||||
|
|
@ -1846,3 +1851,136 @@ func (mm *mockMsgStreamFactory) NewTtMsgStream(ctx context.Context) (msgstream.M
|
|||
func (mm *mockMsgStreamFactory) NewQueryMsgStream(ctx context.Context) (msgstream.MsgStream, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type readAtFunc func(path string, offset int64, length int64) ([]byte, error)
|
||||
type readFunc func(path string) ([]byte, error)
|
||||
|
||||
type mockChunkManager struct {
|
||||
storage.ChunkManager
|
||||
readAt readAtFunc
|
||||
read readFunc
|
||||
}
|
||||
|
||||
type mockChunkManagerOpt func(*mockChunkManager)
|
||||
|
||||
func defaultReadAt(path string, offset int64, length int64) ([]byte, error) {
|
||||
return funcutil.RandomBytes(int(length)), nil
|
||||
}
|
||||
|
||||
func defaultRead(path string) ([]byte, error) {
|
||||
return []byte(path), nil
|
||||
}
|
||||
|
||||
func readBool(maxOffset int64) ([]byte, error) {
|
||||
var arr schemapb.BoolArray
|
||||
for i := int64(0); i <= maxOffset; i++ {
|
||||
arr.Data = append(arr.Data, i%2 == 0)
|
||||
}
|
||||
return proto.Marshal(&arr)
|
||||
}
|
||||
|
||||
func readIllegalBool() ([]byte, error) {
|
||||
return []byte("can convert to bool array"), nil
|
||||
}
|
||||
|
||||
func readString(maxOffset int64) ([]byte, error) {
|
||||
var arr schemapb.StringArray
|
||||
for i := int64(0); i <= maxOffset; i++ {
|
||||
arr.Data = append(arr.Data, funcutil.GenRandomStr())
|
||||
}
|
||||
return proto.Marshal(&arr)
|
||||
}
|
||||
|
||||
func readIllegalString() ([]byte, error) {
|
||||
return []byte("can convert to string array"), nil
|
||||
}
|
||||
|
||||
func readAtEmptyContent() ([]byte, error) {
|
||||
return []byte{}, nil
|
||||
}
|
||||
|
||||
func withReadAt(f readAtFunc) mockChunkManagerOpt {
|
||||
return func(manager *mockChunkManager) {
|
||||
manager.readAt = f
|
||||
}
|
||||
}
|
||||
|
||||
func withRead(f readFunc) mockChunkManagerOpt {
|
||||
return func(manager *mockChunkManager) {
|
||||
manager.read = f
|
||||
}
|
||||
}
|
||||
|
||||
func withDefaultReadAt() mockChunkManagerOpt {
|
||||
return withReadAt(defaultReadAt)
|
||||
}
|
||||
|
||||
func withDefaultRead() mockChunkManagerOpt {
|
||||
return withRead(defaultRead)
|
||||
}
|
||||
|
||||
func withReadErr() mockChunkManagerOpt {
|
||||
return withRead(func(path string) ([]byte, error) {
|
||||
return nil, errors.New("mock")
|
||||
})
|
||||
}
|
||||
|
||||
func withReadAtErr() mockChunkManagerOpt {
|
||||
return withReadAt(func(path string, offset int64, length int64) ([]byte, error) {
|
||||
return nil, errors.New("mock")
|
||||
})
|
||||
}
|
||||
|
||||
func withReadBool(maxOffset int64) mockChunkManagerOpt {
|
||||
return withRead(func(path string) ([]byte, error) {
|
||||
return readBool(maxOffset)
|
||||
})
|
||||
}
|
||||
|
||||
func withReadIllegalBool() mockChunkManagerOpt {
|
||||
return withRead(func(path string) ([]byte, error) {
|
||||
return readIllegalBool()
|
||||
})
|
||||
}
|
||||
|
||||
func withReadString(maxOffset int64) mockChunkManagerOpt {
|
||||
return withRead(func(path string) ([]byte, error) {
|
||||
return readString(maxOffset)
|
||||
})
|
||||
}
|
||||
|
||||
func withReadIllegalString() mockChunkManagerOpt {
|
||||
return withRead(func(path string) ([]byte, error) {
|
||||
return readIllegalString()
|
||||
})
|
||||
}
|
||||
|
||||
func withReadAtEmptyContent() mockChunkManagerOpt {
|
||||
return withReadAt(func(path string, offset int64, length int64) ([]byte, error) {
|
||||
return readAtEmptyContent()
|
||||
})
|
||||
}
|
||||
|
||||
func newMockChunkManager(opts ...mockChunkManagerOpt) storage.ChunkManager {
|
||||
ret := &mockChunkManager{}
|
||||
for _, opt := range opts {
|
||||
if opt != nil {
|
||||
opt(ret)
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func (m *mockChunkManager) ReadAt(path string, offset int64, length int64) ([]byte, error) {
|
||||
if m.readAt != nil {
|
||||
return m.readAt(path, offset, length)
|
||||
}
|
||||
return defaultReadAt(path, offset, length)
|
||||
}
|
||||
|
||||
func (m *mockChunkManager) Read(path string) ([]byte, error) {
|
||||
if m.read != nil {
|
||||
return m.read(path)
|
||||
}
|
||||
return defaultRead(path)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,6 +37,8 @@ import (
|
|||
"sync"
|
||||
"unsafe"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/util/funcutil"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/metrics"
|
||||
"github.com/milvus-io/milvus/internal/util/timerecord"
|
||||
|
||||
|
|
@ -54,7 +56,6 @@ import (
|
|||
"github.com/milvus-io/milvus/internal/proto/segcorepb"
|
||||
"github.com/milvus-io/milvus/internal/storage"
|
||||
"github.com/milvus-io/milvus/internal/util/cgoconverter"
|
||||
"github.com/milvus-io/milvus/internal/util/typeutil"
|
||||
)
|
||||
|
||||
type segmentType = commonpb.SegmentState
|
||||
|
|
@ -69,10 +70,10 @@ const (
|
|||
maxBloomFalsePositive float64 = 0.005
|
||||
)
|
||||
|
||||
// VectorFieldInfo contains binlog info of vector field
|
||||
type VectorFieldInfo struct {
|
||||
// IndexedFieldInfo contains binlog info of vector field
|
||||
type IndexedFieldInfo struct {
|
||||
fieldBinlog *datapb.FieldBinlog
|
||||
indexInfo *querypb.VecFieldIndexInfo
|
||||
indexInfo *querypb.FieldIndexInfo
|
||||
}
|
||||
|
||||
// Segment is a wrapper of the underlying C-structure segment.
|
||||
|
|
@ -98,8 +99,8 @@ type Segment struct {
|
|||
|
||||
idBinlogRowSizes []int64
|
||||
|
||||
vectorFieldMutex sync.RWMutex // guards vectorFieldInfos
|
||||
vectorFieldInfos map[UniqueID]*VectorFieldInfo
|
||||
indexedFieldMutex sync.RWMutex // guards indexedFieldInfos
|
||||
indexedFieldInfos map[UniqueID]*IndexedFieldInfo
|
||||
|
||||
pkFilter *bloom.BloomFilter // bloom filter of pk inside a segment
|
||||
}
|
||||
|
|
@ -149,17 +150,17 @@ func (s *Segment) setOnService(onService bool) {
|
|||
s.onService = onService
|
||||
}
|
||||
|
||||
func (s *Segment) setVectorFieldInfo(fieldID UniqueID, info *VectorFieldInfo) {
|
||||
s.vectorFieldMutex.Lock()
|
||||
defer s.vectorFieldMutex.Unlock()
|
||||
s.vectorFieldInfos[fieldID] = info
|
||||
func (s *Segment) setIndexedFieldInfo(fieldID UniqueID, info *IndexedFieldInfo) {
|
||||
s.indexedFieldMutex.Lock()
|
||||
defer s.indexedFieldMutex.Unlock()
|
||||
s.indexedFieldInfos[fieldID] = info
|
||||
}
|
||||
|
||||
func (s *Segment) getVectorFieldInfo(fieldID UniqueID) (*VectorFieldInfo, error) {
|
||||
s.vectorFieldMutex.RLock()
|
||||
defer s.vectorFieldMutex.RUnlock()
|
||||
if info, ok := s.vectorFieldInfos[fieldID]; ok {
|
||||
return &VectorFieldInfo{
|
||||
func (s *Segment) getIndexedFieldInfo(fieldID UniqueID) (*IndexedFieldInfo, error) {
|
||||
s.indexedFieldMutex.RLock()
|
||||
defer s.indexedFieldMutex.RUnlock()
|
||||
if info, ok := s.indexedFieldInfos[fieldID]; ok {
|
||||
return &IndexedFieldInfo{
|
||||
fieldBinlog: info.fieldBinlog,
|
||||
indexInfo: info.indexInfo,
|
||||
}, nil
|
||||
|
|
@ -167,11 +168,11 @@ func (s *Segment) getVectorFieldInfo(fieldID UniqueID) (*VectorFieldInfo, error)
|
|||
return nil, errors.New("Invalid fieldID " + strconv.Itoa(int(fieldID)))
|
||||
}
|
||||
|
||||
func (s *Segment) hasLoadIndexForVecField(fieldID int64) bool {
|
||||
s.vectorFieldMutex.RLock()
|
||||
defer s.vectorFieldMutex.RUnlock()
|
||||
func (s *Segment) hasLoadIndexForIndexedField(fieldID int64) bool {
|
||||
s.indexedFieldMutex.RLock()
|
||||
defer s.indexedFieldMutex.RUnlock()
|
||||
|
||||
if fieldInfo, ok := s.vectorFieldInfos[fieldID]; ok {
|
||||
if fieldInfo, ok := s.indexedFieldInfos[fieldID]; ok {
|
||||
return fieldInfo.indexInfo != nil && fieldInfo.indexInfo.EnableIndex
|
||||
}
|
||||
|
||||
|
|
@ -207,14 +208,14 @@ func newSegment(collection *Collection, segmentID UniqueID, partitionID UniqueID
|
|||
zap.Int32("segmentType", int32(segType)))
|
||||
|
||||
var segment = &Segment{
|
||||
segmentPtr: segmentPtr,
|
||||
segmentType: segType,
|
||||
segmentID: segmentID,
|
||||
partitionID: partitionID,
|
||||
collectionID: collectionID,
|
||||
vChannelID: vChannelID,
|
||||
onService: onService,
|
||||
vectorFieldInfos: make(map[UniqueID]*VectorFieldInfo),
|
||||
segmentPtr: segmentPtr,
|
||||
segmentType: segType,
|
||||
segmentID: segmentID,
|
||||
partitionID: partitionID,
|
||||
collectionID: collectionID,
|
||||
vChannelID: vChannelID,
|
||||
onService: onService,
|
||||
indexedFieldInfos: make(map[UniqueID]*IndexedFieldInfo),
|
||||
|
||||
pkFilter: bloom.NewWithEstimates(bloomFilterSize, maxBloomFalsePositive),
|
||||
}
|
||||
|
|
@ -356,68 +357,206 @@ func (s *Segment) retrieve(plan *RetrievePlan) (*segcorepb.RetrieveResults, erro
|
|||
return result, nil
|
||||
}
|
||||
|
||||
func (s *Segment) fillVectorFieldsData(collectionID UniqueID,
|
||||
func (s *Segment) getFieldDataPath(indexedFieldInfo *IndexedFieldInfo, offset int64) (dataPath string, offsetInBinlog int64) {
|
||||
offsetInBinlog = offset
|
||||
for index, idBinlogRowSize := range s.idBinlogRowSizes {
|
||||
if offsetInBinlog < idBinlogRowSize {
|
||||
dataPath = indexedFieldInfo.fieldBinlog.Binlogs[index].GetLogPath()
|
||||
break
|
||||
} else {
|
||||
offsetInBinlog -= idBinlogRowSize
|
||||
}
|
||||
}
|
||||
return dataPath, offsetInBinlog
|
||||
}
|
||||
|
||||
func fillBinVecFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
dim := fieldData.GetVectors().GetDim()
|
||||
rowBytes := dim / 8
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
x := fieldData.GetVectors().GetData().(*schemapb.VectorField_BinaryVector)
|
||||
resultLen := dim / 8
|
||||
copy(x.BinaryVector[i*int(resultLen):(i+1)*int(resultLen)], content)
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillFloatVecFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
dim := fieldData.GetVectors().GetDim()
|
||||
rowBytes := dim * 4
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
x := fieldData.GetVectors().GetData().(*schemapb.VectorField_FloatVector)
|
||||
floatResult := make([]float32, dim)
|
||||
buf := bytes.NewReader(content)
|
||||
if err = binary.Read(buf, endian, &floatResult); err != nil {
|
||||
return err
|
||||
}
|
||||
resultLen := dim
|
||||
copy(x.FloatVector.Data[i*int(resultLen):(i+1)*int(resultLen)], floatResult)
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillBoolFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read whole file.
|
||||
// TODO: optimize here.
|
||||
content, err := vcm.Read(dataPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var arr schemapb.BoolArray
|
||||
err = proto.Unmarshal(content, &arr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fieldData.GetScalars().GetBoolData().GetData()[i] = arr.Data[offset]
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillStringFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read whole file.
|
||||
// TODO: optimize here.
|
||||
content, err := vcm.Read(dataPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var arr schemapb.StringArray
|
||||
err = proto.Unmarshal(content, &arr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fieldData.GetScalars().GetStringData().GetData()[i] = arr.Data[offset]
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillInt8FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(1)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var i8 int8
|
||||
if err := funcutil.ReadBinary(endian, content, &i8); err != nil {
|
||||
return err
|
||||
}
|
||||
fieldData.GetScalars().GetIntData().GetData()[i] = int32(i8)
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillInt16FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(2)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var i16 int16
|
||||
if err := funcutil.ReadBinary(endian, content, &i16); err != nil {
|
||||
return err
|
||||
}
|
||||
fieldData.GetScalars().GetIntData().GetData()[i] = int32(i16)
|
||||
return nil
|
||||
}
|
||||
|
||||
func fillInt32FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(4)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetIntData().GetData()[i]))
|
||||
}
|
||||
|
||||
func fillInt64FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(8)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetLongData().GetData()[i]))
|
||||
}
|
||||
|
||||
func fillFloatFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(4)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetFloatData().GetData()[i]))
|
||||
}
|
||||
|
||||
func fillDoubleFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
// read by offset.
|
||||
rowBytes := int64(8)
|
||||
content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetDoubleData().GetData()[i]))
|
||||
}
|
||||
|
||||
func fillFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error {
|
||||
switch fieldData.Type {
|
||||
case schemapb.DataType_BinaryVector:
|
||||
return fillBinVecFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_FloatVector:
|
||||
return fillFloatVecFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Bool:
|
||||
return fillBoolFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_String, schemapb.DataType_VarChar:
|
||||
return fillStringFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Int8:
|
||||
return fillInt8FieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Int16:
|
||||
return fillInt16FieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Int32:
|
||||
return fillInt32FieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Int64:
|
||||
return fillInt64FieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Float:
|
||||
return fillFloatFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
case schemapb.DataType_Double:
|
||||
return fillDoubleFieldData(vcm, dataPath, fieldData, i, offset, endian)
|
||||
default:
|
||||
return fmt.Errorf("invalid data type: %s", fieldData.Type.String())
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Segment) fillIndexedFieldsData(collectionID UniqueID,
|
||||
vcm storage.ChunkManager, result *segcorepb.RetrieveResults) error {
|
||||
|
||||
for _, fieldData := range result.FieldsData {
|
||||
if !typeutil.IsVectorType(fieldData.Type) {
|
||||
// If the vector field doesn't have indexed. Vector data is in memory for
|
||||
// brute force search. No need to download data from remote.
|
||||
if !s.hasLoadIndexForIndexedField(fieldData.FieldId) {
|
||||
continue
|
||||
}
|
||||
|
||||
vecFieldInfo, err := s.getVectorFieldInfo(fieldData.FieldId)
|
||||
indexedFieldInfo, err := s.getIndexedFieldInfo(fieldData.FieldId)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
// If the vector field doesn't have indexed. Vector data is in memory for
|
||||
// brute force search. No need to download data from remote.
|
||||
if !s.hasLoadIndexForVecField(fieldData.FieldId) {
|
||||
continue
|
||||
}
|
||||
|
||||
dim := fieldData.GetVectors().GetDim()
|
||||
log.Debug("FillVectorFieldData", zap.Int64("fieldId", fieldData.FieldId),
|
||||
zap.Any("datatype", fieldData.Type), zap.Int64("dim", dim))
|
||||
|
||||
// TODO: optimize here. Now we'll read a whole file from storage every time we retrieve raw data by offset.
|
||||
for i, offset := range result.Offset {
|
||||
var vecPath string
|
||||
for index, idBinlogRowSize := range s.idBinlogRowSizes {
|
||||
if offset < idBinlogRowSize {
|
||||
vecPath = vecFieldInfo.fieldBinlog.Binlogs[index].GetLogPath()
|
||||
break
|
||||
} else {
|
||||
offset -= idBinlogRowSize
|
||||
}
|
||||
}
|
||||
log.Debug("FillVectorFieldData", zap.String("path", vecPath))
|
||||
dataPath, offsetInBinlog := s.getFieldDataPath(indexedFieldInfo, offset)
|
||||
endian := common.Endian
|
||||
|
||||
switch fieldData.Type {
|
||||
case schemapb.DataType_BinaryVector:
|
||||
rowBytes := dim / 8
|
||||
x := fieldData.GetVectors().GetData().(*schemapb.VectorField_BinaryVector)
|
||||
content, err := vcm.ReadAt(vecPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resultLen := dim / 8
|
||||
copy(x.BinaryVector[i*int(resultLen):(i+1)*int(resultLen)], content)
|
||||
case schemapb.DataType_FloatVector:
|
||||
x := fieldData.GetVectors().GetData().(*schemapb.VectorField_FloatVector)
|
||||
rowBytes := dim * 4
|
||||
content, err := vcm.ReadAt(vecPath, offset*rowBytes, rowBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
floatResult := make([]float32, dim)
|
||||
buf := bytes.NewReader(content)
|
||||
if err = binary.Read(buf, common.Endian, &floatResult); err != nil {
|
||||
return err
|
||||
}
|
||||
resultLen := dim
|
||||
copy(x.FloatVector.Data[i*int(resultLen):(i+1)*int(resultLen)], floatResult)
|
||||
// fill field data that fieldData[i] = dataPath[offsetInBinlog*rowBytes, (offsetInBinlog+1)*rowBytes]
|
||||
if err := fillFieldData(vcm, dataPath, fieldData, i, offsetInBinlog, endian); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -677,7 +816,7 @@ func (s *Segment) segmentLoadDeletedRecord(primaryKeys []IntPrimaryKey, timestam
|
|||
return nil
|
||||
}
|
||||
|
||||
func (s *Segment) segmentLoadIndexData(bytesIndex [][]byte, indexInfo *querypb.VecFieldIndexInfo) error {
|
||||
func (s *Segment) segmentLoadIndexData(bytesIndex [][]byte, indexInfo *querypb.FieldIndexInfo) error {
|
||||
loadIndexInfo, err := newLoadIndexInfo()
|
||||
defer deleteLoadIndexInfo(loadIndexInfo)
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -189,48 +189,43 @@ func (loader *segmentLoader) loadSegmentInternal(segment *Segment,
|
|||
zap.Int64("collectionID", collectionID),
|
||||
zap.Int64("partitionID", partitionID),
|
||||
zap.Int64("segmentID", segmentID))
|
||||
vecFieldIDs, err := loader.historicalReplica.getVecFieldIDsByCollectionID(collectionID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pkFieldID, err := loader.historicalReplica.getPKFieldIDByCollectionID(collectionID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var nonVecFieldBinlogs []*datapb.FieldBinlog
|
||||
var nonIndexedFieldBinlogs []*datapb.FieldBinlog
|
||||
if segment.getType() == segmentTypeSealed {
|
||||
fieldID2IndexInfo := make(map[int64]*querypb.VecFieldIndexInfo)
|
||||
fieldID2IndexInfo := make(map[int64]*querypb.FieldIndexInfo)
|
||||
for _, indexInfo := range loadInfo.IndexInfos {
|
||||
fieldID := indexInfo.FieldID
|
||||
fieldID2IndexInfo[fieldID] = indexInfo
|
||||
}
|
||||
|
||||
vecFieldInfos := make(map[int64]*VectorFieldInfo)
|
||||
indexedFieldInfos := make(map[int64]*IndexedFieldInfo)
|
||||
|
||||
for _, fieldBinlog := range loadInfo.BinlogPaths {
|
||||
fieldID := fieldBinlog.FieldID
|
||||
if funcutil.SliceContain(vecFieldIDs, fieldID) {
|
||||
fieldInfo := &VectorFieldInfo{
|
||||
if indexInfo, ok := fieldID2IndexInfo[fieldID]; ok {
|
||||
fieldInfo := &IndexedFieldInfo{
|
||||
fieldBinlog: fieldBinlog,
|
||||
indexInfo: indexInfo,
|
||||
}
|
||||
if indexInfo, ok := fieldID2IndexInfo[fieldID]; ok {
|
||||
fieldInfo.indexInfo = indexInfo
|
||||
}
|
||||
vecFieldInfos[fieldID] = fieldInfo
|
||||
indexedFieldInfos[fieldID] = fieldInfo
|
||||
} else {
|
||||
nonVecFieldBinlogs = append(nonVecFieldBinlogs, fieldBinlog)
|
||||
nonIndexedFieldBinlogs = append(nonIndexedFieldBinlogs, fieldBinlog)
|
||||
}
|
||||
}
|
||||
|
||||
err = loader.loadVecFieldData(segment, vecFieldInfos)
|
||||
err = loader.loadIndexedFieldData(segment, indexedFieldInfos)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
nonVecFieldBinlogs = loadInfo.BinlogPaths
|
||||
nonIndexedFieldBinlogs = loadInfo.BinlogPaths
|
||||
}
|
||||
err = loader.loadFiledBinlogData(segment, nonVecFieldBinlogs)
|
||||
err = loader.loadFiledBinlogData(segment, nonIndexedFieldBinlogs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -302,7 +297,7 @@ func (loader *segmentLoader) loadFiledBinlogData(segment *Segment, fieldBinlogs
|
|||
}
|
||||
}
|
||||
|
||||
func (loader *segmentLoader) loadVecFieldData(segment *Segment, vecFieldInfos map[int64]*VectorFieldInfo) error {
|
||||
func (loader *segmentLoader) loadIndexedFieldData(segment *Segment, vecFieldInfos map[int64]*IndexedFieldInfo) error {
|
||||
for fieldID, fieldInfo := range vecFieldInfos {
|
||||
if fieldInfo.indexInfo == nil || !fieldInfo.indexInfo.EnableIndex {
|
||||
fieldBinlog := fieldInfo.fieldBinlog
|
||||
|
|
@ -313,21 +308,22 @@ func (loader *segmentLoader) loadVecFieldData(segment *Segment, vecFieldInfos ma
|
|||
log.Debug("load vector field's binlog data done", zap.Int64("segmentID", segment.ID()), zap.Int64("fieldID", fieldID))
|
||||
} else {
|
||||
indexInfo := fieldInfo.indexInfo
|
||||
err := loader.loadVecFieldIndexData(segment, indexInfo)
|
||||
err := loader.loadFieldIndexData(segment, indexInfo)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
log.Debug("load vector field's index data done", zap.Int64("segmentID", segment.ID()), zap.Int64("fieldID", fieldID))
|
||||
}
|
||||
segment.setVectorFieldInfo(fieldID, fieldInfo)
|
||||
segment.setIndexedFieldInfo(fieldID, fieldInfo)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (loader *segmentLoader) loadVecFieldIndexData(segment *Segment, indexInfo *querypb.VecFieldIndexInfo) error {
|
||||
func (loader *segmentLoader) loadFieldIndexData(segment *Segment, indexInfo *querypb.FieldIndexInfo) error {
|
||||
indexBuffer := make([][]byte, 0)
|
||||
indexCodec := storage.NewIndexFileBinlogCodec()
|
||||
filteredPaths := make([]string, 0, len(indexInfo.IndexFilePaths))
|
||||
for _, p := range indexInfo.IndexFilePaths {
|
||||
log.Debug("load index file", zap.String("path", p))
|
||||
indexPiece, err := loader.cm.Read(p)
|
||||
|
|
@ -341,9 +337,11 @@ func (loader *segmentLoader) loadVecFieldIndexData(segment *Segment, indexInfo *
|
|||
return err
|
||||
}
|
||||
indexBuffer = append(indexBuffer, data[0].Value)
|
||||
filteredPaths = append(filteredPaths, p)
|
||||
}
|
||||
}
|
||||
// 2. use index bytes and index path to update segment
|
||||
indexInfo.IndexFilePaths = filteredPaths
|
||||
err := segment.segmentLoadIndexData(indexBuffer, indexInfo)
|
||||
return err
|
||||
}
|
||||
|
|
|
|||
|
|
@ -464,7 +464,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) {
|
|||
// generate index file for segment
|
||||
indexPaths, err := generateIndex(segmentID)
|
||||
assert.NoError(t, err)
|
||||
indexInfo := &querypb.VecFieldIndexInfo{
|
||||
indexInfo := &querypb.FieldIndexInfo{
|
||||
FieldID: simpleVecField.id,
|
||||
EnableIndex: true,
|
||||
IndexName: indexName,
|
||||
|
|
@ -493,7 +493,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) {
|
|||
PartitionID: defaultPartitionID,
|
||||
CollectionID: defaultCollectionID,
|
||||
BinlogPaths: fieldBinlog,
|
||||
IndexInfos: []*querypb.VecFieldIndexInfo{indexInfo},
|
||||
IndexInfos: []*querypb.FieldIndexInfo{indexInfo},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
|
@ -503,7 +503,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) {
|
|||
|
||||
segment, err := node.historical.replica.getSegmentByID(segmentID)
|
||||
assert.NoError(t, err)
|
||||
vecFieldInfo, err := segment.getVectorFieldInfo(simpleVecField.id)
|
||||
vecFieldInfo, err := segment.getIndexedFieldInfo(simpleVecField.id)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, vecFieldInfo)
|
||||
assert.Equal(t, true, vecFieldInfo.indexInfo.EnableIndex)
|
||||
|
|
|
|||
|
|
@ -20,9 +20,12 @@ import (
|
|||
"context"
|
||||
"log"
|
||||
"math"
|
||||
"math/rand"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/storage"
|
||||
|
||||
"github.com/golang/protobuf/proto"
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
|
|
@ -917,7 +920,7 @@ func TestSegment_indexInfo(t *testing.T) {
|
|||
indexID := UniqueID(0)
|
||||
buildID := UniqueID(0)
|
||||
|
||||
indexInfo := &querypb.VecFieldIndexInfo{
|
||||
indexInfo := &querypb.FieldIndexInfo{
|
||||
IndexName: indexName,
|
||||
IndexParams: funcutil.Map2KeyValuePair(indexParam),
|
||||
IndexFilePaths: indexPaths,
|
||||
|
|
@ -925,9 +928,9 @@ func TestSegment_indexInfo(t *testing.T) {
|
|||
BuildID: buildID,
|
||||
}
|
||||
|
||||
seg.setVectorFieldInfo(fieldID, &VectorFieldInfo{indexInfo: indexInfo})
|
||||
seg.setIndexedFieldInfo(fieldID, &IndexedFieldInfo{indexInfo: indexInfo})
|
||||
|
||||
fieldInfo, err := seg.getVectorFieldInfo(fieldID)
|
||||
fieldInfo, err := seg.getIndexedFieldInfo(fieldID)
|
||||
assert.Nil(t, err)
|
||||
info := fieldInfo.indexInfo
|
||||
assert.Equal(t, indexName, info.IndexName)
|
||||
|
|
@ -974,25 +977,25 @@ func TestSegment_BasicMetrics(t *testing.T) {
|
|||
assert.Equal(t, false, resOnService)
|
||||
})
|
||||
|
||||
t.Run("test VectorFieldInfo", func(t *testing.T) {
|
||||
t.Run("test IndexedFieldInfo", func(t *testing.T) {
|
||||
fieldID := rowIDFieldID
|
||||
info := &VectorFieldInfo{
|
||||
info := &IndexedFieldInfo{
|
||||
fieldBinlog: &datapb.FieldBinlog{
|
||||
FieldID: fieldID,
|
||||
Binlogs: []*datapb.Binlog{},
|
||||
},
|
||||
}
|
||||
segment.setVectorFieldInfo(fieldID, info)
|
||||
resInfo, err := segment.getVectorFieldInfo(fieldID)
|
||||
segment.setIndexedFieldInfo(fieldID, info)
|
||||
resInfo, err := segment.getIndexedFieldInfo(fieldID)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, info, resInfo)
|
||||
|
||||
_, err = segment.getVectorFieldInfo(FieldID(1000))
|
||||
_, err = segment.getIndexedFieldInfo(FieldID(1000))
|
||||
assert.Error(t, err)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSegment_fillVectorFieldsData(t *testing.T) {
|
||||
func TestSegment_fillIndexedFieldsData(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
|
||||
|
|
@ -1010,17 +1013,17 @@ func TestSegment_fillVectorFieldsData(t *testing.T) {
|
|||
vecCM, err := genVectorChunkManager(ctx)
|
||||
assert.NoError(t, err)
|
||||
|
||||
t.Run("test fillVectorFieldsData float-vector invalid vectorChunkManager", func(t *testing.T) {
|
||||
t.Run("test fillIndexedFieldsData float-vector invalid vectorChunkManager", func(t *testing.T) {
|
||||
fieldID := FieldID(100)
|
||||
fieldName := "float-vector-field-0"
|
||||
info := &VectorFieldInfo{
|
||||
info := &IndexedFieldInfo{
|
||||
fieldBinlog: &datapb.FieldBinlog{
|
||||
FieldID: fieldID,
|
||||
Binlogs: []*datapb.Binlog{},
|
||||
},
|
||||
indexInfo: &querypb.VecFieldIndexInfo{EnableIndex: true},
|
||||
indexInfo: &querypb.FieldIndexInfo{EnableIndex: true},
|
||||
}
|
||||
segment.setVectorFieldInfo(fieldID, info)
|
||||
segment.setIndexedFieldInfo(fieldID, info)
|
||||
fieldData := []*schemapb.FieldData{
|
||||
{
|
||||
Type: schemapb.DataType_FloatVector,
|
||||
|
|
@ -1043,7 +1046,488 @@ func TestSegment_fillVectorFieldsData(t *testing.T) {
|
|||
Offset: []int64{0},
|
||||
FieldsData: fieldData,
|
||||
}
|
||||
err = segment.fillVectorFieldsData(defaultCollectionID, vecCM, result)
|
||||
err = segment.fillIndexedFieldsData(defaultCollectionID, vecCM, result)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
}
|
||||
|
||||
func Test_getFieldDataPath(t *testing.T) {
|
||||
indexedFieldInfo := &IndexedFieldInfo{
|
||||
fieldBinlog: &datapb.FieldBinlog{
|
||||
FieldID: 0,
|
||||
Binlogs: []*datapb.Binlog{
|
||||
{
|
||||
LogPath: funcutil.GenRandomStr(),
|
||||
},
|
||||
{
|
||||
LogPath: funcutil.GenRandomStr(),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
s := &Segment{
|
||||
idBinlogRowSizes: []int64{10, 15},
|
||||
}
|
||||
|
||||
path, offsetInBinlog := s.getFieldDataPath(indexedFieldInfo, 4)
|
||||
assert.Equal(t, indexedFieldInfo.fieldBinlog.Binlogs[0].LogPath, path)
|
||||
assert.Equal(t, int64(4), offsetInBinlog)
|
||||
|
||||
path, offsetInBinlog = s.getFieldDataPath(indexedFieldInfo, 11)
|
||||
assert.Equal(t, indexedFieldInfo.fieldBinlog.Binlogs[1].LogPath, path)
|
||||
assert.Equal(t, int64(1), offsetInBinlog)
|
||||
}
|
||||
|
||||
func generateBoolArray(numRows int) []bool {
|
||||
ret := make([]bool, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, rand.Int()%2 == 0)
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateInt8Array(numRows int) []int8 {
|
||||
ret := make([]int8, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, int8(rand.Int()))
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateInt16Array(numRows int) []int16 {
|
||||
ret := make([]int16, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, int16(rand.Int()))
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateInt32Array(numRows int) []int32 {
|
||||
ret := make([]int32, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, int32(rand.Int()))
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateInt64Array(numRows int) []int64 {
|
||||
ret := make([]int64, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, int64(rand.Int()))
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateFloat32Array(numRows int) []float32 {
|
||||
ret := make([]float32, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, rand.Float32())
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateStringArray(numRows int) []string {
|
||||
ret := make([]string, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, funcutil.GenRandomStr())
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateFloat64Array(numRows int) []float64 {
|
||||
ret := make([]float64, 0, numRows)
|
||||
for i := 0; i < numRows; i++ {
|
||||
ret = append(ret, rand.Float64())
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateFloatVectors(numRows, dim int) []float32 {
|
||||
total := numRows * dim
|
||||
ret := make([]float32, 0, total)
|
||||
for i := 0; i < total; i++ {
|
||||
ret = append(ret, rand.Float32())
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func generateBinaryVectors(numRows, dim int) []byte {
|
||||
total := (numRows * dim) / 8
|
||||
ret := make([]byte, total)
|
||||
_, err := rand.Read(ret)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func newScalarFieldData(dType schemapb.DataType, fieldName string, numRows int) *schemapb.FieldData {
|
||||
ret := &schemapb.FieldData{
|
||||
Type: dType,
|
||||
FieldName: fieldName,
|
||||
Field: nil,
|
||||
}
|
||||
|
||||
switch dType {
|
||||
case schemapb.DataType_Bool:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_BoolData{
|
||||
BoolData: &schemapb.BoolArray{
|
||||
Data: generateBoolArray(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Int8:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_IntData{
|
||||
IntData: &schemapb.IntArray{
|
||||
Data: generateInt32Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Int16:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_IntData{
|
||||
IntData: &schemapb.IntArray{
|
||||
Data: generateInt32Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Int32:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_IntData{
|
||||
IntData: &schemapb.IntArray{
|
||||
Data: generateInt32Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Int64:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_LongData{
|
||||
LongData: &schemapb.LongArray{
|
||||
Data: generateInt64Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Float:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_FloatData{
|
||||
FloatData: &schemapb.FloatArray{
|
||||
Data: generateFloat32Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_Double:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_DoubleData{
|
||||
DoubleData: &schemapb.DoubleArray{
|
||||
Data: generateFloat64Array(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
case schemapb.DataType_VarChar, schemapb.DataType_String:
|
||||
ret.Field = &schemapb.FieldData_Scalars{
|
||||
Scalars: &schemapb.ScalarField{
|
||||
Data: &schemapb.ScalarField_StringData{
|
||||
StringData: &schemapb.StringArray{
|
||||
Data: generateStringArray(numRows),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
func newFloatVectorFieldData(fieldName string, numRows, dim int) *schemapb.FieldData {
|
||||
return &schemapb.FieldData{
|
||||
Type: schemapb.DataType_FloatVector,
|
||||
FieldName: fieldName,
|
||||
Field: &schemapb.FieldData_Vectors{
|
||||
Vectors: &schemapb.VectorField{
|
||||
Dim: int64(dim),
|
||||
Data: &schemapb.VectorField_FloatVector{
|
||||
FloatVector: &schemapb.FloatArray{
|
||||
Data: generateFloatVectors(numRows, dim),
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func newBinaryVectorFieldData(fieldName string, numRows, dim int) *schemapb.FieldData {
|
||||
return &schemapb.FieldData{
|
||||
Type: schemapb.DataType_BinaryVector,
|
||||
FieldName: fieldName,
|
||||
Field: &schemapb.FieldData_Vectors{
|
||||
Vectors: &schemapb.VectorField{
|
||||
Dim: int64(dim),
|
||||
Data: &schemapb.VectorField_BinaryVector{
|
||||
BinaryVector: generateBinaryVectors(numRows, dim),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func Test_fillBinVecFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newBinaryVectorFieldData("bv", 1, 8)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
offset := int64(100)
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillBinVecFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillBinVecFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillFloatVecFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newFloatVectorFieldData("fv", 1, 8)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
offset := int64(100)
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillFloatVecFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillFloatVecFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillFloatVecFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillBoolFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withReadBool(offset))
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Bool, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillBoolFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadErr())
|
||||
assert.Error(t, fillBoolFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadIllegalBool())
|
||||
assert.Error(t, fillBoolFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillStringFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withReadString(offset))
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_VarChar, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillStringFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadErr())
|
||||
assert.Error(t, fillStringFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadIllegalString())
|
||||
assert.Error(t, fillStringFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillInt8FieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Int8, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillInt8FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillInt8FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillInt8FieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillInt16FieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Int16, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillInt16FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillInt16FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillInt16FieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillInt32FieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Int32, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillInt32FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillInt32FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillInt32FieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillInt64FieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Int64, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillInt64FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillInt64FieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillInt64FieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillFloatFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Float, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillFloatFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillFloatFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillFloatFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillDoubleFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
offset := int64(100)
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
|
||||
f := newScalarFieldData(schemapb.DataType_Double, "f", 1)
|
||||
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
assert.NoError(t, fillDoubleFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtErr())
|
||||
assert.Error(t, fillDoubleFieldData(m, path, f, index, offset, endian))
|
||||
|
||||
m = newMockChunkManager(withReadAtEmptyContent())
|
||||
assert.Error(t, fillDoubleFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
func Test_fillFieldData(t *testing.T) {
|
||||
var m storage.ChunkManager
|
||||
|
||||
fs := []*schemapb.FieldData{
|
||||
newBinaryVectorFieldData("bv", 1, 8),
|
||||
newFloatVectorFieldData("fv", 1, 8),
|
||||
newScalarFieldData(schemapb.DataType_Bool, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_VarChar, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Int8, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Int16, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Int32, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Int64, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Float, "f", 1),
|
||||
newScalarFieldData(schemapb.DataType_Double, "f", 1),
|
||||
}
|
||||
|
||||
offset := int64(100)
|
||||
path := funcutil.GenRandomStr()
|
||||
index := 0
|
||||
endian := common.Endian
|
||||
|
||||
for _, f := range fs {
|
||||
if f.Type == schemapb.DataType_Bool {
|
||||
m = newMockChunkManager(withReadBool(offset))
|
||||
} else if funcutil.SliceContain([]schemapb.DataType{
|
||||
schemapb.DataType_String,
|
||||
schemapb.DataType_VarChar,
|
||||
}, f.Type) {
|
||||
m = newMockChunkManager(withReadString(offset))
|
||||
} else {
|
||||
m = newMockChunkManager(withDefaultReadAt())
|
||||
}
|
||||
|
||||
assert.NoError(t, fillFieldData(m, path, f, index, offset, endian))
|
||||
}
|
||||
|
||||
assert.Error(t, fillFieldData(m, path, &schemapb.FieldData{Type: schemapb.DataType_None}, index, offset, endian))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -975,6 +975,18 @@ func (mt *MetaTable) GetSegmentIndexInfoByID(segID typeutil.UniqueID, fieldID in
|
|||
return pb.SegmentIndexInfo{}, fmt.Errorf("can't find index name = %s on segment = %d, with filed id = %d", idxName, segID, fieldID)
|
||||
}
|
||||
|
||||
func (mt *MetaTable) GetSegmentIndexInfos(segID typeutil.UniqueID) (map[typeutil.UniqueID]pb.SegmentIndexInfo, error) {
|
||||
mt.ddLock.RLock()
|
||||
defer mt.ddLock.RUnlock()
|
||||
|
||||
ret, ok := mt.segID2IndexMeta[segID]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("segment not found in meta, segment: %d", segID)
|
||||
}
|
||||
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
// GetFieldSchema return field schema
|
||||
func (mt *MetaTable) GetFieldSchema(collName string, fieldName string) (schemapb.FieldSchema, error) {
|
||||
mt.ddLock.RLock()
|
||||
|
|
|
|||
|
|
@ -1316,3 +1316,36 @@ func TestFixIssue10540(t *testing.T) {
|
|||
_, err = NewMetaTable(txnKV, skv)
|
||||
assert.Nil(t, err)
|
||||
}
|
||||
|
||||
func TestMetaTable_GetSegmentIndexInfos(t *testing.T) {
|
||||
meta := &MetaTable{
|
||||
segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]pb.SegmentIndexInfo{},
|
||||
}
|
||||
|
||||
segID := typeutil.UniqueID(100)
|
||||
_, err := meta.GetSegmentIndexInfos(segID)
|
||||
assert.Error(t, err)
|
||||
|
||||
meta.segID2IndexMeta[segID] = map[typeutil.UniqueID]pb.SegmentIndexInfo{
|
||||
5: {
|
||||
CollectionID: 1,
|
||||
PartitionID: 2,
|
||||
SegmentID: segID,
|
||||
FieldID: 4,
|
||||
IndexID: 5,
|
||||
BuildID: 6,
|
||||
EnableIndex: true,
|
||||
},
|
||||
}
|
||||
infos, err := meta.GetSegmentIndexInfos(segID)
|
||||
assert.NoError(t, err)
|
||||
indexInfos, ok := infos[5]
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, typeutil.UniqueID(1), indexInfos.GetCollectionID())
|
||||
assert.Equal(t, typeutil.UniqueID(2), indexInfos.GetPartitionID())
|
||||
assert.Equal(t, segID, indexInfos.GetSegmentID())
|
||||
assert.Equal(t, typeutil.UniqueID(4), indexInfos.GetFieldID())
|
||||
assert.Equal(t, typeutil.UniqueID(5), indexInfos.GetIndexID())
|
||||
assert.Equal(t, typeutil.UniqueID(6), indexInfos.GetBuildID())
|
||||
assert.Equal(t, true, indexInfos.GetEnableIndex())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1837,6 +1837,64 @@ func (c *Core) DescribeSegment(ctx context.Context, in *milvuspb.DescribeSegment
|
|||
return t.Rsp, nil
|
||||
}
|
||||
|
||||
func (c *Core) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
metrics.RootCoordDescribeSegmentsCounter.WithLabelValues(metrics.TotalLabel).Inc()
|
||||
|
||||
if code, ok := c.checkHealthy(); !ok {
|
||||
log.Error("failed to describe segments, rootcoord not healthy",
|
||||
zap.String("role", typeutil.RootCoordRole),
|
||||
zap.Int64("msgID", in.GetBase().GetMsgID()),
|
||||
zap.Int64("collection", in.GetCollectionID()),
|
||||
zap.Int64s("segments", in.GetSegmentIDs()))
|
||||
|
||||
return &rootcoordpb.DescribeSegmentsResponse{
|
||||
Status: failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]),
|
||||
}, nil
|
||||
}
|
||||
|
||||
tr := timerecord.NewTimeRecorder("DescribeSegments")
|
||||
|
||||
log.Debug("received request to describe segments",
|
||||
zap.String("role", typeutil.RootCoordRole),
|
||||
zap.Int64("msgID", in.GetBase().GetMsgID()),
|
||||
zap.Int64("collection", in.GetCollectionID()),
|
||||
zap.Int64s("segments", in.GetSegmentIDs()))
|
||||
|
||||
t := &DescribeSegmentsReqTask{
|
||||
baseReqTask: baseReqTask{
|
||||
ctx: ctx,
|
||||
core: c,
|
||||
},
|
||||
Req: in,
|
||||
Rsp: &rootcoordpb.DescribeSegmentsResponse{},
|
||||
}
|
||||
|
||||
if err := executeTask(t); err != nil {
|
||||
log.Error("failed to describe segments",
|
||||
zap.Error(err),
|
||||
zap.String("role", typeutil.RootCoordRole),
|
||||
zap.Int64("msgID", in.GetBase().GetMsgID()),
|
||||
zap.Int64("collection", in.GetCollectionID()),
|
||||
zap.Int64s("segments", in.GetSegmentIDs()))
|
||||
|
||||
return &rootcoordpb.DescribeSegmentsResponse{
|
||||
Status: failStatus(commonpb.ErrorCode_UnexpectedError, "DescribeSegments failed: "+err.Error()),
|
||||
}, nil
|
||||
}
|
||||
|
||||
log.Debug("succeed to describe segments",
|
||||
zap.String("role", typeutil.RootCoordRole),
|
||||
zap.Int64("msgID", in.GetBase().GetMsgID()),
|
||||
zap.Int64("collection", in.GetCollectionID()),
|
||||
zap.Int64s("segments", in.GetSegmentIDs()))
|
||||
|
||||
metrics.RootCoordDescribeSegmentsCounter.WithLabelValues(metrics.SuccessLabel).Inc()
|
||||
metrics.RootCoordDDLReadTypeLatency.WithLabelValues("DescribeSegments").Observe(float64(tr.ElapseSpan().Milliseconds()))
|
||||
|
||||
t.Rsp.Status = succStatus()
|
||||
return t.Rsp, nil
|
||||
}
|
||||
|
||||
// ShowSegments list all segments
|
||||
func (c *Core) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
|
||||
metrics.RootCoordShowSegmentsCounter.WithLabelValues(metrics.TotalLabel).Inc()
|
||||
|
|
|
|||
|
|
@ -2992,3 +2992,88 @@ func TestCore_GetComponentStates(t *testing.T) {
|
|||
assert.NoError(t, err)
|
||||
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
|
||||
}
|
||||
|
||||
func TestCore_DescribeSegments(t *testing.T) {
|
||||
collID := typeutil.UniqueID(1)
|
||||
partID := typeutil.UniqueID(2)
|
||||
segID := typeutil.UniqueID(100)
|
||||
fieldID := typeutil.UniqueID(3)
|
||||
buildID := typeutil.UniqueID(4)
|
||||
indexID := typeutil.UniqueID(1000)
|
||||
indexName := "test_describe_segments_index"
|
||||
|
||||
c := &Core{
|
||||
ctx: context.Background(),
|
||||
}
|
||||
|
||||
// not healthy.
|
||||
c.stateCode.Store(internalpb.StateCode_Abnormal)
|
||||
got1, err := c.DescribeSegments(context.Background(), &rootcoordpb.DescribeSegmentsRequest{})
|
||||
assert.NoError(t, err)
|
||||
assert.NotEqual(t, commonpb.ErrorCode_Success, got1.GetStatus().GetErrorCode())
|
||||
|
||||
// failed to be executed.
|
||||
c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) {
|
||||
return []typeutil.UniqueID{segID}, nil
|
||||
}
|
||||
c.stateCode.Store(internalpb.StateCode_Healthy)
|
||||
shortDuration := time.Nanosecond
|
||||
shortCtx, cancel := context.WithTimeout(c.ctx, shortDuration)
|
||||
defer cancel()
|
||||
time.Sleep(shortDuration)
|
||||
got2, err := c.DescribeSegments(shortCtx, &rootcoordpb.DescribeSegmentsRequest{})
|
||||
assert.NoError(t, err)
|
||||
assert.NotEqual(t, commonpb.ErrorCode_Success, got2.GetStatus().GetErrorCode())
|
||||
|
||||
// success.
|
||||
c.MetaTable = &MetaTable{
|
||||
segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{
|
||||
segID: {
|
||||
indexID: {
|
||||
CollectionID: collID,
|
||||
PartitionID: partID,
|
||||
SegmentID: segID,
|
||||
FieldID: fieldID,
|
||||
IndexID: indexID,
|
||||
BuildID: buildID,
|
||||
EnableIndex: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
indexID2Meta: map[typeutil.UniqueID]etcdpb.IndexInfo{
|
||||
indexID: {
|
||||
IndexName: indexName,
|
||||
IndexID: indexID,
|
||||
IndexParams: nil,
|
||||
},
|
||||
},
|
||||
}
|
||||
infos, err := c.DescribeSegments(context.Background(), &rootcoordpb.DescribeSegmentsRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_DescribeSegments,
|
||||
MsgID: 0,
|
||||
Timestamp: 0,
|
||||
SourceID: 0,
|
||||
},
|
||||
CollectionID: collID,
|
||||
SegmentIDs: []typeutil.UniqueID{segID},
|
||||
})
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, commonpb.ErrorCode_Success, infos.GetStatus().GetErrorCode())
|
||||
assert.Equal(t, 1, len(infos.GetSegmentInfos()))
|
||||
segmentInfo, ok := infos.GetSegmentInfos()[segID]
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, 1, len(segmentInfo.GetIndexInfos()))
|
||||
assert.Equal(t, collID, segmentInfo.GetIndexInfos()[0].GetCollectionID())
|
||||
assert.Equal(t, partID, segmentInfo.GetIndexInfos()[0].GetPartitionID())
|
||||
assert.Equal(t, segID, segmentInfo.GetIndexInfos()[0].GetSegmentID())
|
||||
assert.Equal(t, fieldID, segmentInfo.GetIndexInfos()[0].GetFieldID())
|
||||
assert.Equal(t, indexID, segmentInfo.GetIndexInfos()[0].GetIndexID())
|
||||
assert.Equal(t, buildID, segmentInfo.GetIndexInfos()[0].GetBuildID())
|
||||
assert.Equal(t, true, segmentInfo.GetIndexInfos()[0].GetEnableIndex())
|
||||
|
||||
indexInfo, ok := segmentInfo.GetExtraIndexInfos()[indexID]
|
||||
assert.True(t, ok)
|
||||
assert.Equal(t, indexName, indexInfo.IndexName)
|
||||
assert.Equal(t, indexID, indexInfo.IndexID)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ import (
|
|||
"github.com/milvus-io/milvus/internal/proto/etcdpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/internalpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/milvuspb"
|
||||
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/schemapb"
|
||||
"github.com/milvus-io/milvus/internal/util/funcutil"
|
||||
"github.com/milvus-io/milvus/internal/util/tsoutil"
|
||||
|
|
@ -829,6 +830,88 @@ func (t *ShowSegmentReqTask) Execute(ctx context.Context) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
type DescribeSegmentsReqTask struct {
|
||||
baseReqTask
|
||||
Req *rootcoordpb.DescribeSegmentsRequest
|
||||
Rsp *rootcoordpb.DescribeSegmentsResponse
|
||||
}
|
||||
|
||||
func (t *DescribeSegmentsReqTask) Type() commonpb.MsgType {
|
||||
return t.Req.GetBase().GetMsgType()
|
||||
}
|
||||
|
||||
func (t *DescribeSegmentsReqTask) Execute(ctx context.Context) error {
|
||||
collectionID := t.Req.GetCollectionID()
|
||||
segIDs, err := t.core.CallGetFlushedSegmentsService(ctx, collectionID, -1)
|
||||
if err != nil {
|
||||
log.Error("failed to get flushed segments",
|
||||
zap.Error(err),
|
||||
zap.Int64("collection", collectionID))
|
||||
return err
|
||||
}
|
||||
|
||||
t.Rsp.CollectionID = collectionID
|
||||
t.Rsp.SegmentInfos = make(map[typeutil.UniqueID]*rootcoordpb.SegmentInfos)
|
||||
|
||||
segIDsMap := make(map[typeutil.UniqueID]struct{})
|
||||
for _, segID := range segIDs {
|
||||
segIDsMap[segID] = struct{}{}
|
||||
}
|
||||
|
||||
for _, segID := range t.Req.SegmentIDs {
|
||||
if _, ok := segIDsMap[segID]; !ok {
|
||||
log.Warn("requested segment not found",
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64("segment", segID))
|
||||
return fmt.Errorf("segment not found, collection: %d, segment: %d",
|
||||
collectionID, segID)
|
||||
}
|
||||
|
||||
if _, ok := t.Rsp.SegmentInfos[segID]; !ok {
|
||||
t.Rsp.SegmentInfos[segID] = &rootcoordpb.SegmentInfos{
|
||||
BaseInfo: &rootcoordpb.SegmentBaseInfo{
|
||||
CollectionID: collectionID,
|
||||
PartitionID: 0, // TODO: change this after MetaTable.partID2SegID been fixed.
|
||||
SegmentID: segID,
|
||||
},
|
||||
IndexInfos: nil,
|
||||
ExtraIndexInfos: make(map[typeutil.UniqueID]*etcdpb.IndexInfo),
|
||||
}
|
||||
}
|
||||
|
||||
segmentInfo, err := t.core.MetaTable.GetSegmentIndexInfos(segID)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
for indexID, indexInfo := range segmentInfo {
|
||||
t.Rsp.SegmentInfos[segID].IndexInfos =
|
||||
append(t.Rsp.SegmentInfos[segID].IndexInfos,
|
||||
&etcdpb.SegmentIndexInfo{
|
||||
CollectionID: indexInfo.CollectionID,
|
||||
PartitionID: indexInfo.PartitionID,
|
||||
SegmentID: indexInfo.SegmentID,
|
||||
FieldID: indexInfo.FieldID,
|
||||
IndexID: indexInfo.IndexID,
|
||||
BuildID: indexInfo.BuildID,
|
||||
EnableIndex: indexInfo.EnableIndex,
|
||||
})
|
||||
extraIndexInfo, err := t.core.MetaTable.GetIndexByID(indexID)
|
||||
if err != nil {
|
||||
log.Error("index not found in meta table",
|
||||
zap.Error(err),
|
||||
zap.Int64("indexID", indexID),
|
||||
zap.Int64("collection", collectionID),
|
||||
zap.Int64("segment", segID))
|
||||
return err
|
||||
}
|
||||
t.Rsp.SegmentInfos[segID].ExtraIndexInfos[indexID] = extraIndexInfo
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateIndexReqTask create index request task
|
||||
type CreateIndexReqTask struct {
|
||||
baseReqTask
|
||||
|
|
|
|||
|
|
@ -0,0 +1,115 @@
|
|||
package rootcoord
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/etcdpb"
|
||||
"github.com/milvus-io/milvus/internal/util/typeutil"
|
||||
|
||||
"github.com/milvus-io/milvus/internal/proto/commonpb"
|
||||
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
|
||||
)
|
||||
|
||||
func TestDescribeSegmentReqTask_Type(t *testing.T) {
|
||||
tsk := &DescribeSegmentsReqTask{
|
||||
Req: &rootcoordpb.DescribeSegmentsRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_DescribeSegments,
|
||||
},
|
||||
},
|
||||
}
|
||||
assert.Equal(t, commonpb.MsgType_DescribeSegments, tsk.Type())
|
||||
}
|
||||
|
||||
func TestDescribeSegmentsReqTask_Execute(t *testing.T) {
|
||||
collID := typeutil.UniqueID(1)
|
||||
partID := typeutil.UniqueID(2)
|
||||
segID := typeutil.UniqueID(100)
|
||||
fieldID := typeutil.UniqueID(3)
|
||||
buildID := typeutil.UniqueID(4)
|
||||
indexID := typeutil.UniqueID(1000)
|
||||
indexName := "test_describe_segments_index"
|
||||
|
||||
c := &Core{}
|
||||
|
||||
// failed to get flushed segments.
|
||||
c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) {
|
||||
return nil, errors.New("mock")
|
||||
}
|
||||
tsk := &DescribeSegmentsReqTask{
|
||||
baseReqTask: baseReqTask{
|
||||
core: c,
|
||||
},
|
||||
Req: &rootcoordpb.DescribeSegmentsRequest{
|
||||
Base: &commonpb.MsgBase{
|
||||
MsgType: commonpb.MsgType_DescribeSegments,
|
||||
},
|
||||
CollectionID: collID,
|
||||
SegmentIDs: []typeutil.UniqueID{segID},
|
||||
},
|
||||
Rsp: &rootcoordpb.DescribeSegmentsResponse{},
|
||||
}
|
||||
assert.Error(t, tsk.Execute(context.Background()))
|
||||
|
||||
// requested segment not found in flushed segments.
|
||||
c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) {
|
||||
return []typeutil.UniqueID{}, nil
|
||||
}
|
||||
assert.Error(t, tsk.Execute(context.Background()))
|
||||
|
||||
// segment not found in meta.
|
||||
c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) {
|
||||
return []typeutil.UniqueID{segID}, nil
|
||||
}
|
||||
c.MetaTable = &MetaTable{
|
||||
segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{},
|
||||
}
|
||||
assert.NoError(t, tsk.Execute(context.Background()))
|
||||
|
||||
// index not found in meta.
|
||||
c.MetaTable = &MetaTable{
|
||||
segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{
|
||||
segID: {
|
||||
indexID: {
|
||||
CollectionID: collID,
|
||||
PartitionID: partID,
|
||||
SegmentID: segID,
|
||||
FieldID: fieldID,
|
||||
IndexID: indexID,
|
||||
BuildID: buildID,
|
||||
EnableIndex: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
assert.Error(t, tsk.Execute(context.Background()))
|
||||
|
||||
// success.
|
||||
c.MetaTable = &MetaTable{
|
||||
segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{
|
||||
segID: {
|
||||
indexID: {
|
||||
CollectionID: collID,
|
||||
PartitionID: partID,
|
||||
SegmentID: segID,
|
||||
FieldID: fieldID,
|
||||
IndexID: indexID,
|
||||
BuildID: buildID,
|
||||
EnableIndex: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
indexID2Meta: map[typeutil.UniqueID]etcdpb.IndexInfo{
|
||||
indexID: {
|
||||
IndexName: indexName,
|
||||
IndexID: indexID,
|
||||
IndexParams: nil,
|
||||
},
|
||||
},
|
||||
}
|
||||
assert.NoError(t, tsk.Execute(context.Background()))
|
||||
}
|
||||
|
|
@ -1071,6 +1071,57 @@ func NewIndexFileBinlogCodec() *IndexFileBinlogCodec {
|
|||
return &IndexFileBinlogCodec{}
|
||||
}
|
||||
|
||||
func (codec *IndexFileBinlogCodec) serializeImpl(
|
||||
indexBuildID UniqueID,
|
||||
version int64,
|
||||
collectionID UniqueID,
|
||||
partitionID UniqueID,
|
||||
segmentID UniqueID,
|
||||
fieldID UniqueID,
|
||||
indexName string,
|
||||
indexID UniqueID,
|
||||
key string,
|
||||
value []byte,
|
||||
ts Timestamp,
|
||||
) (*Blob, error) {
|
||||
writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, key)
|
||||
defer writer.Close()
|
||||
|
||||
eventWriter, err := writer.NextIndexFileEventWriter()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer eventWriter.Close()
|
||||
|
||||
err = eventWriter.AddByteToPayload(value)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
eventWriter.SetEventTimestamp(ts, ts)
|
||||
|
||||
writer.SetEventTimeStamp(ts, ts)
|
||||
|
||||
// https://github.com/milvus-io/milvus/issues/9620
|
||||
// len(params) is also not accurate, indexParams is a map
|
||||
writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(value)))
|
||||
|
||||
err = writer.Finish()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
buffer, err := writer.GetBuffer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &Blob{
|
||||
Key: key,
|
||||
//Key: strconv.Itoa(len(datas)),
|
||||
Value: buffer,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Serialize serilizes data as blobs.
|
||||
func (codec *IndexFileBinlogCodec) Serialize(
|
||||
indexBuildID UniqueID,
|
||||
|
|
@ -1091,94 +1142,22 @@ func (codec *IndexFileBinlogCodec) Serialize(
|
|||
|
||||
ts := Timestamp(time.Now().UnixNano())
|
||||
|
||||
for pos := range datas {
|
||||
writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, datas[pos].Key)
|
||||
|
||||
// https://github.com/milvus-io/milvus/issues/9449
|
||||
// store index parameters to extra, in bytes format.
|
||||
params, _ := json.Marshal(indexParams)
|
||||
writer.descriptorEvent.AddExtra(IndexParamsKey, params)
|
||||
|
||||
eventWriter, err := writer.NextIndexFileEventWriter()
|
||||
if err != nil {
|
||||
writer.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = eventWriter.AddByteToPayload(datas[pos].Value)
|
||||
if err != nil {
|
||||
eventWriter.Close()
|
||||
writer.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
eventWriter.SetEventTimestamp(ts, ts)
|
||||
|
||||
writer.SetEventTimeStamp(ts, ts)
|
||||
|
||||
// https://github.com/milvus-io/milvus/issues/9620
|
||||
writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(datas[pos].Value)))
|
||||
|
||||
err = writer.Finish()
|
||||
if err != nil {
|
||||
eventWriter.Close()
|
||||
writer.Close()
|
||||
return nil, err
|
||||
}
|
||||
buffer, err := writer.GetBuffer()
|
||||
if err != nil {
|
||||
eventWriter.Close()
|
||||
writer.Close()
|
||||
return nil, err
|
||||
}
|
||||
|
||||
blobs = append(blobs, &Blob{
|
||||
Key: datas[pos].Key,
|
||||
//Key: strconv.Itoa(pos),
|
||||
Value: buffer,
|
||||
})
|
||||
eventWriter.Close()
|
||||
writer.Close()
|
||||
}
|
||||
|
||||
// save index params
|
||||
writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, IndexParamsKey)
|
||||
eventWriter, err := writer.NextIndexFileEventWriter()
|
||||
if err != nil {
|
||||
writer.Close()
|
||||
return nil, err
|
||||
}
|
||||
defer writer.Close()
|
||||
defer eventWriter.Close()
|
||||
|
||||
// save index params.
|
||||
// querycoord will parse index extra info from binlog, better to let this key appear first.
|
||||
params, _ := json.Marshal(indexParams)
|
||||
err = eventWriter.AddByteToPayload(params)
|
||||
indexParamBlob, err := codec.serializeImpl(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, IndexParamsKey, params, ts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blobs = append(blobs, indexParamBlob)
|
||||
|
||||
eventWriter.SetEventTimestamp(ts, ts)
|
||||
|
||||
writer.SetEventTimeStamp(ts, ts)
|
||||
|
||||
// https://github.com/milvus-io/milvus/issues/9620
|
||||
// len(params) is also not accurate, indexParams is a map
|
||||
writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(params)))
|
||||
|
||||
err = writer.Finish()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
for pos := range datas {
|
||||
blob, err := codec.serializeImpl(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, datas[pos].Key, datas[pos].Value, ts)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blobs = append(blobs, blob)
|
||||
}
|
||||
buffer, err := writer.GetBuffer()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
blobs = append(blobs, &Blob{
|
||||
Key: IndexParamsKey,
|
||||
//Key: strconv.Itoa(len(datas)),
|
||||
Value: buffer,
|
||||
})
|
||||
|
||||
return blobs, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -569,6 +569,8 @@ type RootCoord interface {
|
|||
// error is always nil
|
||||
ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)
|
||||
|
||||
DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error)
|
||||
|
||||
// ReleaseDQLMessageStream notifies RootCoord to release and close the search message stream of specific collection.
|
||||
//
|
||||
// ctx is the request to control request deadline and cancellation.
|
||||
|
|
|
|||
|
|
@ -17,7 +17,9 @@
|
|||
package funcutil
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
|
@ -344,3 +346,9 @@ func GetNumRowOfFieldData(fieldData *schemapb.FieldData) (uint64, error) {
|
|||
|
||||
return fieldNumRows, nil
|
||||
}
|
||||
|
||||
// ReadBinary read byte slice as receiver.
|
||||
func ReadBinary(endian binary.ByteOrder, bs []byte, receiver interface{}) error {
|
||||
buf := bytes.NewReader(bs)
|
||||
return binary.Read(buf, endian, receiver)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ package funcutil
|
|||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
|
@ -399,3 +400,66 @@ func TestGetNumRowsOfBinaryVectorField(t *testing.T) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
func Test_ReadBinary(t *testing.T) {
|
||||
// TODO: test big endian.
|
||||
// low byte in high address, high byte in low address.
|
||||
endian := binary.LittleEndian
|
||||
var bs []byte
|
||||
|
||||
bs = []byte{0x1f}
|
||||
var i8 int8
|
||||
var expectedI8 int8 = 0x1f
|
||||
assert.NoError(t, ReadBinary(endian, bs, &i8))
|
||||
assert.Equal(t, expectedI8, i8)
|
||||
|
||||
bs = []byte{0xff, 0x1f}
|
||||
var i16 int16
|
||||
var expectedI16 int16 = 0x1fff
|
||||
assert.NoError(t, ReadBinary(endian, bs, &i16))
|
||||
assert.Equal(t, expectedI16, i16)
|
||||
|
||||
bs = []byte{0xff, 0xff, 0xff, 0x1f}
|
||||
var i32 int32
|
||||
var expectedI32 int32 = 0x1fffffff
|
||||
assert.NoError(t, ReadBinary(endian, bs, &i32))
|
||||
assert.Equal(t, expectedI32, i32)
|
||||
|
||||
bs = []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f}
|
||||
var i64 int64
|
||||
var expectedI64 int64 = 0x1fffffffffffffff
|
||||
assert.NoError(t, ReadBinary(endian, bs, &i64))
|
||||
assert.Equal(t, expectedI64, i64)
|
||||
|
||||
// hard to compare float-pointing value.
|
||||
|
||||
bs = []byte{0, 0, 0, 0}
|
||||
var f float32
|
||||
// var expectedF32 float32 = 0
|
||||
var expectedF32 float32
|
||||
assert.NoError(t, ReadBinary(endian, bs, &f))
|
||||
assert.Equal(t, expectedF32, f)
|
||||
|
||||
bs = []byte{0, 0, 0, 0, 0, 0, 0, 0}
|
||||
var d float64
|
||||
// var expectedF64 float64 = 0
|
||||
var expectedF64 float64
|
||||
assert.NoError(t, ReadBinary(endian, bs, &d))
|
||||
assert.Equal(t, expectedF64, d)
|
||||
|
||||
bs = []byte{0}
|
||||
var fb bool
|
||||
assert.NoError(t, ReadBinary(endian, bs, &fb))
|
||||
assert.False(t, fb)
|
||||
|
||||
bs = []byte{1}
|
||||
var tb bool
|
||||
assert.NoError(t, ReadBinary(endian, bs, &tb))
|
||||
assert.True(t, tb)
|
||||
|
||||
// float vector
|
||||
bs = []byte{0, 0, 0, 0, 0, 0, 0, 0}
|
||||
var fs = make([]float32, 2)
|
||||
assert.NoError(t, ReadBinary(endian, bs, &fs))
|
||||
assert.ElementsMatch(t, []float32{0, 0}, fs)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,6 +99,10 @@ func (m *RootCoordClient) ShowSegments(ctx context.Context, in *milvuspb.ShowSeg
|
|||
return &milvuspb.ShowSegmentsResponse{}, m.Err
|
||||
}
|
||||
|
||||
func (m *RootCoordClient) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest, opts ...grpc.CallOption) (*rootcoordpb.DescribeSegmentsResponse, error) {
|
||||
return &rootcoordpb.DescribeSegmentsResponse{}, m.Err
|
||||
}
|
||||
|
||||
func (m *RootCoordClient) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
|
||||
return &commonpb.Status{}, m.Err
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue