test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-11-30 02:48:45 +08:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

Add log file info for all kind of segment binlogs (#13606)

Browse Source 
Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
This commit is contained in:
congqixia 2021-12-19 20:00:42 +08:00 committed by GitHub
parent 396685d4b5
commit 1dcd06cc78
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 1089 additions and 812 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/tools/datameta/main.go
View File

@ -112,8 +112,10 @@ func printSegmentInfo(info *datapb.SegmentInfo) {
fmt.Println("**************************************")
fmt.Println("Delta Logs:")
for _, log := range info.GetDeltalogs() {
fmt.Printf("Entries: %d From: %v - To: %v\n", log.RecordEntries, log.TimestampFrom, log.TimestampTo)
fmt.Printf("Path: %v\n", log.DeltaLogPath)
for _, l := range log.GetBinlogs() {
fmt.Printf("Entries: %d From: %v - To: %v\n", l.EntriesNum, l.TimestampFrom, l.TimestampTo)
fmt.Printf("Path: %v\n", l.LogPath)
}
}
}

17
internal/datacoord/compaction_policy.go
View File

@ -23,10 +23,19 @@ func (f singleCompactionFunc) generatePlan(segment *SegmentInfo, timeTravel *tim
}
func chooseAllBinlogs(segment *SegmentInfo, timeTravel *timetravel) *datapb.CompactionPlan {
var deltaLogs []*datapb.DeltaLogInfo
for _, l := range segment.GetDeltalogs() {
if l.TimestampTo < timeTravel.time {
deltaLogs = append(deltaLogs, l)
var deltaLogs []*datapb.FieldBinlog
for _, fieldBinlog := range segment.GetDeltalogs() {
fbl := &datapb.FieldBinlog{
FieldID: fieldBinlog.GetFieldID(),
Binlogs: make([]*datapb.Binlog, 0, len(fieldBinlog.GetBinlogs())),
}
for _, binlog := range fieldBinlog.GetBinlogs() {
if binlog.TimestampTo < timeTravel.time {
fbl.Binlogs = append(fbl.Binlogs, binlog)
}
}
if len(fbl.Binlogs) > 0 {
deltaLogs = append(deltaLogs, fbl)
}
}

51
internal/datacoord/compaction_policy_test.go
View File

@ -7,6 +7,17 @@ import (
"github.com/stretchr/testify/assert"
)
func getFieldBinlogPaths(id int64, paths ...string) *datapb.FieldBinlog {
l := &datapb.FieldBinlog{
FieldID: id,
Binlogs: make([]*datapb.Binlog, 0, len(paths)),
}
for _, path := range paths {
l.Binlogs = append(l.Binlogs, &datapb.Binlog{LogPath: path})
}
return l
}
func Test_greedyMergeCompaction(t *testing.T) {
type args struct {
segments []*SegmentInfo
@ -21,18 +32,18 @@ func Test_greedyMergeCompaction(t *testing.T) {
"test normal merge",
args{
[]*SegmentInfo{
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")}}},
},
&timetravel{1000},
},
[]*datapb.CompactionPlan{
{
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")}},
},
Type: datapb.CompactionType_MergeCompaction,
Timetravel: 1000,
},
@ -42,17 +53,17 @@ func Test_greedyMergeCompaction(t *testing.T) {
"test unmergable segments",
args{
[]*SegmentInfo{
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 99, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 3, NumOfRows: 99, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 1, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []*datapb.Binlog{{LogPath: "log1"}}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 99, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []*datapb.Binlog{{LogPath: "log2"}}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 3, NumOfRows: 99, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []*datapb.Binlog{{LogPath: "log3"}}}}}},
},
&timetravel{1000},
},
[]*datapb.CompactionPlan{
{
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}},
},
Type: datapb.CompactionType_MergeCompaction,
Timetravel: 1000,
@ -63,26 +74,26 @@ func Test_greedyMergeCompaction(t *testing.T) {
"test multi plans",
args{
[]*SegmentInfo{
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 3, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 4, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log4"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 3, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 4, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log4")}}},
},
&timetravel{1000},
},
[]*datapb.CompactionPlan{
{
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}},
},
Type: datapb.CompactionType_MergeCompaction,
Timetravel: 1000,
},
{
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 3, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}},
{SegmentID: 4, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log4"}}}},
{SegmentID: 3, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")}},
{SegmentID: 4, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log4")}},
},
Type: datapb.CompactionType_MergeCompaction,
Timetravel: 1000,
@ -93,8 +104,8 @@ func Test_greedyMergeCompaction(t *testing.T) {
"test empty plan",
args{
[]*SegmentInfo{
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 51, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 1, NumOfRows: 50, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}}},
{SegmentInfo: &datapb.SegmentInfo{ID: 2, NumOfRows: 51, MaxRowNum: 100, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")}}},
},
&timetravel{1000},
},

24
internal/datacoord/compaction_test.go
View File

@ -129,7 +129,7 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
plan: &datapb.CompactionPlan{
PlanID: 1,
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
},
Type: datapb.CompactionType_InnerCompaction,
},
@ -140,7 +140,7 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
client: memkv.NewMemoryKV(),
segments: &SegmentsInfo{
map[int64]*SegmentInfo{
1: {SegmentInfo: &datapb.SegmentInfo{ID: 1, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
1: {SegmentInfo: &datapb.SegmentInfo{ID: 1, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}}},
},
},
},
@ -150,7 +150,7 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
result: &datapb.CompactionResult{
PlanID: 1,
SegmentID: 1,
InsertLogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}},
InsertLogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")},
},
},
false,
@ -160,7 +160,7 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
plan: &datapb.CompactionPlan{
PlanID: 1,
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
},
Type: datapb.CompactionType_InnerCompaction,
},
@ -176,8 +176,9 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
plan: &datapb.CompactionPlan{
PlanID: 1,
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}},
},
Type: datapb.CompactionType_MergeCompaction,
},
@ -188,8 +189,9 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
client: memkv.NewMemoryKV(),
segments: &SegmentsInfo{
map[int64]*SegmentInfo{
1: {SegmentInfo: &datapb.SegmentInfo{ID: 1, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}}},
2: {SegmentInfo: &datapb.SegmentInfo{ID: 2, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}}},
1: {SegmentInfo: &datapb.SegmentInfo{ID: 1, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}}},
2: {SegmentInfo: &datapb.SegmentInfo{ID: 2, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}}},
},
},
},
@ -199,7 +201,7 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
result: &datapb.CompactionResult{
PlanID: 1,
SegmentID: 3,
InsertLogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}},
InsertLogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")},
},
},
false,
@ -209,8 +211,8 @@ func Test_compactionPlanHandler_completeCompaction(t *testing.T) {
plan: &datapb.CompactionPlan{
PlanID: 1,
SegmentBinlogs: []*datapb.CompactionSegmentBinlogs{
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2"}}}},
{SegmentID: 1, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")}},
{SegmentID: 2, FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2")}},
},
Type: datapb.CompactionType_MergeCompaction,
},

10
internal/datacoord/compaction_trigger.go
View File

@ -401,10 +401,12 @@ func (t *compactionTrigger) shouldDoSingleCompaction(segment *SegmentInfo, timet
totalDeletedRows := 0
totalDeleteLogSize := int64(0)
for _, l := range segment.GetDeltalogs() {
if l.TimestampTo < timetravel.time {
totalDeletedRows += int(l.GetRecordEntries())
totalDeleteLogSize += l.GetDeltaLogSize()
for _, fbl := range segment.GetDeltalogs() {
for _, l := range fbl.GetBinlogs() {
if l.TimestampTo < timetravel.time {
totalDeletedRows += int(l.GetEntriesNum())
totalDeleteLogSize += l.GetLogSize()
}
}
}

271
internal/datacoord/compaction_trigger_test.go
View File

@ -95,10 +95,14 @@ func Test_compactionTrigger_forceTriggerCompaction(t *testing.T) {
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log1"}},
getFieldBinlogPaths(1, "log1"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog1"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
},
@ -113,10 +117,14 @@ func Test_compactionTrigger_forceTriggerCompaction(t *testing.T) {
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log2"}},
getFieldBinlogPaths(1, "log2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
},
@ -142,21 +150,29 @@ func Test_compactionTrigger_forceTriggerCompaction(t *testing.T) {
{
SegmentID: 1,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log1"}},
getFieldBinlogPaths(1, "log1"),
},
Field2StatslogPaths: nil,
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog1"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
{
SegmentID: 2,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log2"}},
getFieldBinlogPaths(1, "log2"),
},
Field2StatslogPaths: nil,
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
},
@ -183,10 +199,14 @@ func Test_compactionTrigger_forceTriggerCompaction(t *testing.T) {
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log1"}},
getFieldBinlogPaths(1, "log1"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5},
},
},
},
},
},
@ -212,11 +232,15 @@ func Test_compactionTrigger_forceTriggerCompaction(t *testing.T) {
{
SegmentID: 1,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"log1"}},
getFieldBinlogPaths(1, "log1"),
},
Field2StatslogPaths: nil,
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5},
},
},
},
},
},
@ -294,10 +318,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog1"}},
getFieldBinlogPaths(1, "binlog1"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog1"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
},
@ -312,10 +340,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog2"}},
getFieldBinlogPaths(1, "binlog2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
},
@ -330,10 +362,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog3"}},
getFieldBinlogPaths(1, "binlog3"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog3"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog3"},
},
},
},
},
},
@ -359,10 +395,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
{
SegmentID: 1,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog1"}},
getFieldBinlogPaths(1, "binlog1"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog1"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
},
@ -378,19 +418,27 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
{
SegmentID: 2,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog2"}},
getFieldBinlogPaths(1, "binlog2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
{
SegmentID: 3,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog3"}},
getFieldBinlogPaths(1, "binlog3"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog3"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog3"},
},
},
},
},
},
@ -419,10 +467,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch1",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog1"}},
getFieldBinlogPaths(1, "binlog1"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog1"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
},
@ -437,10 +489,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog2"}},
getFieldBinlogPaths(1, "binlog2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
},
@ -455,10 +511,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushed,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog3"}},
getFieldBinlogPaths(1, "binlog3"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog3"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog1"},
},
},
},
},
},
@ -496,10 +556,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushing,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog2"}},
getFieldBinlogPaths(1, "binlog2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
},
@ -514,10 +578,14 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
InsertChannel: "ch2",
State: commonpb.SegmentState_Flushing,
Binlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog3"}},
getFieldBinlogPaths(1, "binlog3"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog3"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog3"},
},
},
},
},
},
@ -543,19 +611,27 @@ func Test_compactionTrigger_triggerCompaction(t *testing.T) {
{
SegmentID: 2,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog2"}},
getFieldBinlogPaths(1, "binlog2"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog2"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog2"},
},
},
},
},
{
SegmentID: 3,
FieldBinlogs: []*datapb.FieldBinlog{
{FieldID: 1, Binlogs: []string{"binlog3"}},
getFieldBinlogPaths(1, "binlog3"),
},
Deltalogs: []*datapb.DeltaLogInfo{
{RecordEntries: 5, DeltaLogPath: "deltalog3"},
Deltalogs: []*datapb.FieldBinlog{
{
Binlogs: []*datapb.Binlog{
{EntriesNum: 5, LogPath: "deltalog3"},
},
},
},
},
},
@ -655,9 +731,11 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
},
Binlogs: []*datapb.FieldBinlog{},
Statslogs: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 2001,
Binlogs: []*datapb.Binlog{
{EntriesNum: 2001},
},
},
},
CreatedByCompaction: false,
@ -694,9 +772,11 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
SegmentID: 101,
FieldBinlogs: []*datapb.FieldBinlog{},
Field2StatslogPaths: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 2001,
Binlogs: []*datapb.Binlog{
{EntriesNum: 2001},
},
},
},
},
@ -732,16 +812,12 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
},
Binlogs: []*datapb.FieldBinlog{},
Statslogs: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 1000,
TimestampFrom: 10,
TimestampTo: 20,
},
{
RecordEntries: 1001,
TimestampFrom: 30,
TimestampTo: 45,
Binlogs: []*datapb.Binlog{
{EntriesNum: 1000, TimestampFrom: 10, TimestampTo: 20},
{EntriesNum: 1001, TimestampFrom: 30, TimestampTo: 45},
},
},
},
CreatedByCompaction: false,
@ -778,9 +854,11 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
SegmentID: 101,
FieldBinlogs: []*datapb.FieldBinlog{},
Field2StatslogPaths: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 2001,
Binlogs: []*datapb.Binlog{
{EntriesNum: 2001},
},
},
},
},
@ -816,16 +894,19 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
},
Binlogs: []*datapb.FieldBinlog{},
Statslogs: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 1000,
TimestampFrom: 10,
TimestampTo: 20,
DeltaLogSize: 10*1024*1024 + 1,
Binlogs: []*datapb.Binlog{
{
EntriesNum: 1000,
TimestampFrom: 10,
TimestampTo: 20,
LogSize: 10*1024*1024 + 1,
},
},
},
},
CreatedByCompaction: false,
CompactionFrom: []int64{},
},
isCompacting: false,
},
@ -858,12 +939,16 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
SegmentID: 101,
FieldBinlogs: []*datapb.FieldBinlog{},
Field2StatslogPaths: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 1000,
TimestampFrom: 10,
TimestampTo: 20,
DeltaLogSize: 10*1024*1024 + 1,
Binlogs: []*datapb.Binlog{
{
EntriesNum: 1000,
TimestampFrom: 10,
TimestampTo: 20,
LogSize: 10*1024*1024 + 1,
},
},
},
},
},
@ -899,16 +984,12 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
},
Binlogs: []*datapb.FieldBinlog{},
Statslogs: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 1000,
TimestampFrom: 10,
TimestampTo: 20,
},
{
RecordEntries: 1001,
TimestampFrom: 30,
TimestampTo: 45,
Binlogs: []*datapb.Binlog{
{EntriesNum: 1000, TimestampFrom: 10, TimestampTo: 20},
{EntriesNum: 1001, TimestampFrom: 30, TimestampTo: 45},
},
},
},
CreatedByCompaction: false,
@ -945,9 +1026,11 @@ func Test_compactionTrigger_singleTriggerCompaction(t *testing.T) {
SegmentID: 101,
FieldBinlogs: []*datapb.FieldBinlog{},
Field2StatslogPaths: []*datapb.FieldBinlog{},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 2001,
Binlogs: []*datapb.Binlog{
{EntriesNum: 2001},
},
},
},
},

15
internal/datacoord/garbage_collector.go
View File

@ -24,6 +24,7 @@ import (
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/minio/minio-go/v7"
"go.uber.org/zap"
)
@ -113,7 +114,7 @@ func (gc *garbageCollector) scan() {
valid := gc.meta.ListSegmentFiles()
vm := make(map[string]struct{})
for _, k := range valid {
vm[k] = struct{}{}
vm[k.GetLogPath()] = struct{}{}
}
// walk only data cluster related prefixes
@ -165,8 +166,8 @@ func (gc *garbageCollector) isExpire(dropts Timestamp) bool {
return time.Since(droptime) > gc.option.dropTolerance
}
func getLogs(sinfo *SegmentInfo) []string {
var logs []string
func getLogs(sinfo *SegmentInfo) []*datapb.Binlog {
var logs []*datapb.Binlog
for _, flog := range sinfo.GetBinlogs() {
logs = append(logs, flog.GetBinlogs()...)
}
@ -175,16 +176,16 @@ func getLogs(sinfo *SegmentInfo) []string {
logs = append(logs, flog.GetBinlogs()...)
}
for _, dlog := range sinfo.GetDeltalogs() {
logs = append(logs, dlog.GetDeltaLogPath())
for _, flog := range sinfo.GetDeltalogs() {
logs = append(logs, flog.GetBinlogs()...)
}
return logs
}
func (gc *garbageCollector) removeLogs(logs []string) bool {
func (gc *garbageCollector) removeLogs(logs []*datapb.Binlog) bool {
delFlag := true
for _, l := range logs {
err := gc.option.cli.RemoveObject(context.TODO(), gc.option.bucketName, l, minio.RemoveObjectOptions{})
err := gc.option.cli.RemoveObject(context.TODO(), gc.option.bucketName, l.GetLogPath(), minio.RemoveObjectOptions{})
errResp := minio.ToErrorResponse(err)
if errResp.Code != "" && errResp.Code != "NoSuchKey" {
delFlag = false

13
internal/datacoord/garbage_collector_test.go
View File

@ -124,9 +124,9 @@ func Test_garbageCollector_scan(t *testing.T) {
t.Run("hit, no gc", func(t *testing.T) {
segment := buildSegment(1, 10, 100, "ch")
segment.State = commonpb.SegmentState_Flushed
segment.Binlogs = []*datapb.FieldBinlog{{FieldID: 0, Binlogs: []string{inserts[0]}}}
segment.Statslogs = []*datapb.FieldBinlog{{FieldID: 0, Binlogs: []string{stats[0]}}}
segment.Deltalogs = []*datapb.DeltaLogInfo{{DeltaLogPath: delta[0]}}
segment.Binlogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, inserts[0])}
segment.Statslogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, stats[0])}
segment.Deltalogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, delta[0])}
err = meta.AddSegment(segment)
require.NoError(t, err)
@ -153,9 +153,10 @@ func Test_garbageCollector_scan(t *testing.T) {
segment := buildSegment(1, 10, 100, "ch")
segment.State = commonpb.SegmentState_Dropped
segment.DroppedAt = uint64(time.Now().Add(-time.Hour).UnixNano())
segment.Binlogs = []*datapb.FieldBinlog{{FieldID: 0, Binlogs: []string{inserts[0]}}}
segment.Statslogs = []*datapb.FieldBinlog{{FieldID: 0, Binlogs: []string{stats[0]}}}
segment.Deltalogs = []*datapb.DeltaLogInfo{{DeltaLogPath: delta[0]}}
segment.Binlogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, inserts[0])}
segment.Statslogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, stats[0])}
segment.Deltalogs = []*datapb.FieldBinlog{getFieldBinlogPaths(0, delta[0])}
err = meta.AddSegment(segment)
require.NoError(t, err)

79
internal/datacoord/meta.go
View File

@ -209,8 +209,7 @@ func (m *meta) UpdateFlushSegmentsInfo(
segmentID UniqueID,
flushed bool,
dropped bool,
binlogs, statslogs []*datapb.FieldBinlog,
deltalogs []*datapb.DeltaLogInfo,
binlogs, statslogs, deltalogs []*datapb.FieldBinlog,
checkpoints []*datapb.CheckPoint,
startPositions []*datapb.SegmentStartPosition,
) error {
@ -270,7 +269,16 @@ func (m *meta) UpdateFlushSegmentsInfo(
}
clonedSegment.Statslogs = currStatsLogs
// deltalogs
clonedSegment.Deltalogs = append(clonedSegment.Deltalogs, deltalogs...)
currDeltaLogs := clonedSegment.GetDeltalogs()
for _, tDeltaLogs := range deltalogs {
fieldDeltaLogs := getFieldBinlogs(tDeltaLogs.GetFieldID(), currDeltaLogs)
if fieldDeltaLogs == nil {
currDeltaLogs = append(currDeltaLogs, tDeltaLogs)
} else {
fieldDeltaLogs.Binlogs = append(fieldDeltaLogs.Binlogs, tDeltaLogs.Binlogs...)
}
}
clonedSegment.Deltalogs = currDeltaLogs
modSegments[segmentID] = clonedSegment
@ -508,11 +516,11 @@ func (m *meta) ChannelHasRemoveFlag(channel string) bool {
}
// ListSegmentFiles lists all segments' logs
func (m *meta) ListSegmentFiles() []string {
func (m *meta) ListSegmentFiles() []*datapb.Binlog {
m.RLock()
defer m.RUnlock()
var logs []string
var logs []*datapb.Binlog
for _, segment := range m.segments.GetSegments() {
if !isSegmentHealthy(segment) {
@ -527,7 +535,7 @@ func (m *meta) ListSegmentFiles() []string {
}
for _, deltaLog := range segment.GetDeltalogs() {
logs = append(logs, deltaLog.GetDeltaLogPath())
logs = append(logs, deltaLog.Binlogs...)
}
}
return logs
@ -716,12 +724,12 @@ func (m *meta) CompleteMergeCompaction(compactionLogs []*datapb.CompactionSegmen
}
// find new added delta logs when executing compaction
var originDeltalogs []*datapb.DeltaLogInfo
var originDeltalogs []*datapb.FieldBinlog
for _, s := range segments {
originDeltalogs = append(originDeltalogs, s.GetDeltalogs()...)
}
var deletedDeltalogs []*datapb.DeltaLogInfo
var deletedDeltalogs []*datapb.FieldBinlog
for _, l := range compactionLogs {
deletedDeltalogs = append(deletedDeltalogs, l.GetDeltalogs()...)
}
@ -802,14 +810,14 @@ func (m *meta) CompleteInnerCompaction(segmentBinlogs *datapb.CompactionSegmentB
}
func (m *meta) updateBinlogs(origin []*datapb.FieldBinlog, removes []*datapb.FieldBinlog, adds []*datapb.FieldBinlog) []*datapb.FieldBinlog {
fieldBinlogs := make(map[int64]map[string]struct{})
fieldBinlogs := make(map[int64]map[string]*datapb.Binlog)
for _, f := range origin {
fid := f.GetFieldID()
if _, ok := fieldBinlogs[fid]; !ok {
fieldBinlogs[fid] = make(map[string]struct{})
fieldBinlogs[fid] = make(map[string]*datapb.Binlog)
}
for _, p := range f.GetBinlogs() {
fieldBinlogs[fid][p] = struct{}{}
fieldBinlogs[fid][p.GetLogPath()] = p
}
}
@ -819,17 +827,17 @@ func (m *meta) updateBinlogs(origin []*datapb.FieldBinlog, removes []*datapb.Fie
continue
}
for _, p := range f.GetBinlogs() {
delete(fieldBinlogs[fid], p)
delete(fieldBinlogs[fid], p.GetLogPath())
}
}
for _, f := range adds {
fid := f.GetFieldID()
if _, ok := fieldBinlogs[fid]; !ok {
fieldBinlogs[fid] = make(map[string]struct{})
fieldBinlogs[fid] = make(map[string]*datapb.Binlog)
}
for _, p := range f.GetBinlogs() {
fieldBinlogs[fid][p] = struct{}{}
fieldBinlogs[fid][p.GetLogPath()] = p
}
}
@ -839,9 +847,9 @@ func (m *meta) updateBinlogs(origin []*datapb.FieldBinlog, removes []*datapb.Fie
continue
}
binlogs := make([]string, 0, len(logs))
for path := range logs {
binlogs = append(binlogs, path)
binlogs := make([]*datapb.Binlog, 0, len(logs))
for _, log := range logs {
binlogs = append(binlogs, log)
}
field := &datapb.FieldBinlog{FieldID: fid, Binlogs: binlogs}
@ -850,21 +858,32 @@ func (m *meta) updateBinlogs(origin []*datapb.FieldBinlog, removes []*datapb.Fie
return res
}
func (m *meta) updateDeltalogs(origin []*datapb.DeltaLogInfo, removes []*datapb.DeltaLogInfo, adds []*datapb.DeltaLogInfo) []*datapb.DeltaLogInfo {
deltalogs := make(map[string]*datapb.DeltaLogInfo)
for _, d := range origin {
deltalogs[d.GetDeltaLogPath()] = d
func (m *meta) updateDeltalogs(origin []*datapb.FieldBinlog, removes []*datapb.FieldBinlog, adds []*datapb.FieldBinlog) []*datapb.FieldBinlog {
res := make([]*datapb.FieldBinlog, 0, len(origin))
for _, fbl := range origin {
logs := make(map[string]*datapb.Binlog)
for _, d := range fbl.GetBinlogs() {
logs[d.GetLogPath()] = d
}
for _, remove := range removes {
if remove.GetFieldID() == fbl.GetFieldID() {
for _, r := range remove.GetBinlogs() {
delete(logs, r.GetLogPath())
}
}
}
binlogs := make([]*datapb.Binlog, 0, len(logs))
for _, l := range logs {
binlogs = append(binlogs, l)
}
if len(binlogs) > 0 {
res = append(res, &datapb.FieldBinlog{
FieldID: fbl.GetFieldID(),
Binlogs: binlogs,
})
}
}
for _, r := range removes {
delete(deltalogs, r.GetDeltaLogPath())
}
res := make([]*datapb.DeltaLogInfo, 0, len(deltalogs))
for _, log := range deltalogs {
res = append(res, log)
}
res = append(res, adds...)
return res
}

76
internal/datacoord/meta_test.go
View File

@ -236,14 +236,14 @@ func TestUpdateFlushSegmentsInfo(t *testing.T) {
meta, err := newMeta(memkv.NewMemoryKV())
assert.Nil(t, err)
segment1 := &SegmentInfo{SegmentInfo: &datapb.SegmentInfo{ID: 1, State: commonpb.SegmentState_Growing, Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"binlog0"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statslog0"}}}}}
segment1 := &SegmentInfo{SegmentInfo: &datapb.SegmentInfo{ID: 1, State: commonpb.SegmentState_Growing, Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "binlog0")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statslog0")}}}
err = meta.AddSegment(segment1)
assert.Nil(t, err)
err = meta.UpdateFlushSegmentsInfo(1, true, false, []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"binlog1"}}},
[]*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statslog1"}}},
[]*datapb.DeltaLogInfo{{RecordEntries: 1, TimestampFrom: 100, TimestampTo: 200, DeltaLogSize: 1000}},
err = meta.UpdateFlushSegmentsInfo(1, true, false, []*datapb.FieldBinlog{getFieldBinlogPaths(1, "binlog1")},
[]*datapb.FieldBinlog{getFieldBinlogPaths(1, "statslog1")},
[]*datapb.FieldBinlog{{Binlogs: []*datapb.Binlog{{EntriesNum: 1, TimestampFrom: 100, TimestampTo: 200, LogSize: 1000}}}},
[]*datapb.CheckPoint{{SegmentID: 1, NumOfRows: 10}}, []*datapb.SegmentStartPosition{{SegmentID: 1, StartPosition: &internalpb.MsgPosition{MsgID: []byte{1, 2, 3}}}})
assert.Nil(t, err)
@ -251,9 +251,9 @@ func TestUpdateFlushSegmentsInfo(t *testing.T) {
expected := &SegmentInfo{SegmentInfo: &datapb.SegmentInfo{
ID: 1, State: commonpb.SegmentState_Flushing, NumOfRows: 10,
StartPosition: &internalpb.MsgPosition{MsgID: []byte{1, 2, 3}},
Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"binlog0", "binlog1"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statslog0", "statslog1"}}},
Deltalogs: []*datapb.DeltaLogInfo{{RecordEntries: 1, TimestampFrom: 100, TimestampTo: 200, DeltaLogSize: 1000}},
Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "binlog0", "binlog1")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statslog0", "statslog1")},
Deltalogs: []*datapb.FieldBinlog{{Binlogs: []*datapb.Binlog{{EntriesNum: 1, TimestampFrom: 100, TimestampTo: 200, LogSize: 1000}}}},
}}
assert.True(t, proto.Equal(expected, updated))
})
@ -296,9 +296,9 @@ func TestUpdateFlushSegmentsInfo(t *testing.T) {
}
meta.segments.SetSegment(1, segmentInfo)
err = meta.UpdateFlushSegmentsInfo(1, true, false, []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"binlog"}}},
[]*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statslog"}}},
[]*datapb.DeltaLogInfo{{RecordEntries: 1, TimestampFrom: 100, TimestampTo: 200, DeltaLogSize: 1000}},
err = meta.UpdateFlushSegmentsInfo(1, true, false, []*datapb.FieldBinlog{getFieldBinlogPaths(1, "binlog")},
[]*datapb.FieldBinlog{getFieldBinlogPaths(1, "statslog")},
[]*datapb.FieldBinlog{{Binlogs: []*datapb.Binlog{{EntriesNum: 1, TimestampFrom: 100, TimestampTo: 200, LogSize: 1000}}}},
[]*datapb.CheckPoint{{SegmentID: 1, NumOfRows: 10}}, []*datapb.SegmentStartPosition{{SegmentID: 1, StartPosition: &internalpb.MsgPosition{MsgID: []byte{1, 2, 3}}}})
assert.NotNil(t, err)
assert.Equal(t, "mocked fail", err.Error())
@ -357,15 +357,15 @@ func Test_meta_CompleteMergeCompaction(t *testing.T) {
&SegmentsInfo{map[int64]*SegmentInfo{
1: {SegmentInfo: &datapb.SegmentInfo{
ID: 1,
Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1", "log2"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog1", "statlog2"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog1"}, {DeltaLogPath: "deltalog2"}},
Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1", "log2")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog1", "statlog2")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog1", "deltalog2")},
}},
2: {SegmentInfo: &datapb.SegmentInfo{
ID: 2,
Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3", "log4"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog3", "statlog4"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog3"}, {DeltaLogPath: "deltalog4"}},
Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3", "log4")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog3", "statlog4")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog3", "deltalog4")},
}},
}},
},
@ -373,22 +373,22 @@ func Test_meta_CompleteMergeCompaction(t *testing.T) {
[]*datapb.CompactionSegmentBinlogs{
{
SegmentID: 1,
FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1", "log2"}}},
Field2StatslogPaths: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog1", "statlog2"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog1"}, {DeltaLogPath: "deltalog2"}},
FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1", "log2")},
Field2StatslogPaths: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog1", "statlog2")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog1", "deltalog2")},
},
{
SegmentID: 2,
FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3", "log4"}}},
Field2StatslogPaths: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog3", "statlog4"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog3"}, {DeltaLogPath: "deltalog4"}},
FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3", "log4")},
Field2StatslogPaths: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog3", "statlog4")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog3", "deltalog4")},
},
},
&datapb.CompactionResult{
SegmentID: 3,
InsertLogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log5"}}},
Field2StatslogPaths: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statslog5"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog5"}},
InsertLogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log5")},
Field2StatslogPaths: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog5")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog5")},
},
},
false,
@ -443,9 +443,9 @@ func Test_meta_CompleteInnerCompaction(t *testing.T) {
map[int64]*SegmentInfo{
1: {SegmentInfo: &datapb.SegmentInfo{
ID: 1,
Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1", "log2"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog1", "statlog2"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog1"}, {DeltaLogPath: "deltalog2"}},
Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1", "log2")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog1", "statlog2")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog1", "deltalog2")},
}},
},
},
@ -453,24 +453,24 @@ func Test_meta_CompleteInnerCompaction(t *testing.T) {
args{
&datapb.CompactionSegmentBinlogs{
SegmentID: 1,
FieldBinlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log1"}}},
Field2StatslogPaths: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog1"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog1"}},
FieldBinlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log1")},
Field2StatslogPaths: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog1")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog1")},
},
&datapb.CompactionResult{
SegmentID: 1,
InsertLogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log3"}}},
Field2StatslogPaths: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog3"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog3"}},
InsertLogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log3")},
Field2StatslogPaths: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog3")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog3")},
},
},
false,
&SegmentInfo{
SegmentInfo: &datapb.SegmentInfo{
ID: 1,
Binlogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"log2", "log3"}}},
Statslogs: []*datapb.FieldBinlog{{FieldID: 1, Binlogs: []string{"statlog2", "statlog3"}}},
Deltalogs: []*datapb.DeltaLogInfo{{DeltaLogPath: "deltalog2"}, {DeltaLogPath: "deltalog3"}},
Binlogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "log2", "log3")},
Statslogs: []*datapb.FieldBinlog{getFieldBinlogPaths(1, "statlog2", "statlog3")},
Deltalogs: []*datapb.FieldBinlog{getFieldBinlogPaths(0, "deltalog2", "deltalog3")},
},
},
},

4
internal/datacoord/segment_info.go
View File

@ -168,7 +168,7 @@ func (s *SegmentsInfo) SetFlushTime(segmentID UniqueID, t time.Time) {
// AddSegmentBinlogs adds binlogs for segment
// if the segment is not found, do nothing
// uses `Clone` since internal SegmentInfo's Binlogs is changed
func (s *SegmentsInfo) AddSegmentBinlogs(segmentID UniqueID, field2Binlogs map[UniqueID][]string) {
func (s *SegmentsInfo) AddSegmentBinlogs(segmentID UniqueID, field2Binlogs map[UniqueID][]*datapb.Binlog) {
if segment, ok := s.segments[segmentID]; ok {
s.segments[segmentID] = segment.Clone(addSegmentBinlogs(field2Binlogs))
}
@ -292,7 +292,7 @@ func SetIsCompacting(isCompacting bool) SegmentInfoOption {
}
}
func addSegmentBinlogs(field2Binlogs map[UniqueID][]string) SegmentInfoOption {
func addSegmentBinlogs(field2Binlogs map[UniqueID][]*datapb.Binlog) SegmentInfoOption {
return func(segment *SegmentInfo) {
for fieldID, binlogPaths := range field2Binlogs {
found := false

2
internal/datacoord/segment_manager.go
View File

@ -369,7 +369,7 @@ func (s *SegmentManager) SealAllSegments(ctx context.Context, collectionID Uniqu
defer sp.Finish()
s.mu.Lock()
defer s.mu.Unlock()
ret := make([]UniqueID, 0)
var ret []UniqueID
for _, id := range s.segments {
info := s.meta.GetSegment(id)
if info == nil {

103
internal/datacoord/server_test.go
View File

@ -19,6 +19,7 @@ package datacoord
import (
"context"
"errors"
"fmt"
"math/rand"
"os"
"path"
@ -333,9 +334,13 @@ func TestGetInsertBinlogPaths(t *testing.T) {
Binlogs: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"dev/datacoord/testsegment/1/part1",
"dev/datacoord/testsegment/1/part2",
Binlogs: []*datapb.Binlog{
{
LogPath: "dev/datacoord/testsegment/1/part1",
},
{
LogPath: "dev/datacoord/testsegment/1/part2",
},
},
},
},
@ -360,9 +365,13 @@ func TestGetInsertBinlogPaths(t *testing.T) {
Binlogs: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"dev/datacoord/testsegment/1/part1",
"dev/datacoord/testsegment/1/part2",
Binlogs: []*datapb.Binlog{
{
LogPath: "dev/datacoord/testsegment/1/part1",
},
{
LogPath: "dev/datacoord/testsegment/1/part2",
},
},
},
},
@ -786,9 +795,13 @@ func TestSaveBinlogPaths(t *testing.T) {
Field2BinlogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/by-dev/test/0/1/2/1/Allo1",
"/by-dev/test/0/1/2/1/Allo2",
Binlogs: []*datapb.Binlog{
{
LogPath: "/by-dev/test/0/1/2/1/Allo1",
},
{
LogPath: "/by-dev/test/0/1/2/1/Allo2",
},
},
},
},
@ -817,8 +830,8 @@ func TestSaveBinlogPaths(t *testing.T) {
assert.NotNil(t, fieldBinlogs)
assert.EqualValues(t, 2, len(fieldBinlogs.GetBinlogs()))
assert.EqualValues(t, 1, fieldBinlogs.GetFieldID())
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", fieldBinlogs.GetBinlogs()[0])
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", fieldBinlogs.GetBinlogs()[1])
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo1", fieldBinlogs.GetBinlogs()[0].GetLogPath())
assert.EqualValues(t, "/by-dev/test/0/1/2/1/Allo2", fieldBinlogs.GetBinlogs()[1].GetLogPath())
segmentInfo := svr.meta.GetSegment(0)
assert.NotNil(t, segmentInfo)
@ -935,25 +948,37 @@ func TestDropVirtualChannel(t *testing.T) {
Field2BinlogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/by-dev/test/0/1/2/1/Allo1",
"/by-dev/test/0/1/2/1/Allo2",
Binlogs: []*datapb.Binlog{
{
LogPath: "/by-dev/test/0/1/2/1/Allo1",
},
{
LogPath: "/by-dev/test/0/1/2/1/Allo2",
},
},
},
},
Field2StatslogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/by-dev/test/0/1/2/1/stats1",
"/by-dev/test/0/1/2/1/stats2",
Binlogs: []*datapb.Binlog{
{
LogPath: "/by-dev/test/0/1/2/1/stats1",
},
{
LogPath: "/by-dev/test/0/1/2/1/stats2",
},
},
},
},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
RecordEntries: 1,
DeltaLogPath: "/by-dev/test/0/1/2/1/delta1",
Binlogs: []*datapb.Binlog{
{
EntriesNum: 1,
LogPath: "/by-dev/test/0/1/2/1/delta1",
},
},
},
},
CheckPoint: &internalpb.MsgPosition{
@ -1611,27 +1636,39 @@ func TestGetRecoveryInfo(t *testing.T) {
Field2BinlogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/binlog/file1",
"/binlog/file2",
Binlogs: []*datapb.Binlog{
{
LogPath: "/binlog/file1",
},
{
LogPath: "/binlog/file2",
},
},
},
},
Field2StatslogPaths: []*datapb.FieldBinlog{
{
FieldID: 1,
Binlogs: []string{
"/stats_log/file1",
"/stats_log/file2",
Binlogs: []*datapb.Binlog{
{
LogPath: "/stats_log/file1",
},
{
LogPath: "/stats_log/file2",
},
},
},
},
Deltalogs: []*datapb.DeltaLogInfo{
Deltalogs: []*datapb.FieldBinlog{
{
TimestampFrom: 0,
TimestampTo: 1,
DeltaLogPath: "/stats_log/file1",
DeltaLogSize: 1,
Binlogs: []*datapb.Binlog{
{
TimestampFrom: 0,
TimestampTo: 1,
LogPath: "/stats_log/file1",
LogSize: 1,
},
},
},
},
}
@ -1659,7 +1696,9 @@ func TestGetRecoveryInfo(t *testing.T) {
assert.EqualValues(t, 0, resp.GetBinlogs()[0].GetSegmentID())
assert.EqualValues(t, 1, len(resp.GetBinlogs()[0].GetFieldBinlogs()))
assert.EqualValues(t, 1, resp.GetBinlogs()[0].GetFieldBinlogs()[0].GetFieldID())
assert.ElementsMatch(t, []string{"/binlog/file1", "/binlog/file2"}, resp.GetBinlogs()[0].GetFieldBinlogs()[0].GetBinlogs())
for i, binlog := range resp.GetBinlogs()[0].GetFieldBinlogs()[0].GetBinlogs() {
assert.Equal(t, fmt.Sprintf("/binlog/file%d", i+1), binlog.GetLogPath())
}
})
t.Run("with dropped segments", func(t *testing.T) {
svr := newTestServer(t, nil)

17
internal/datacoord/services.go
View File

@ -213,7 +213,12 @@ func (s *Server) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsert
paths := make([]*internalpb.StringList, 0, len(binlogs))
for _, field := range binlogs {
fids = append(fids, field.GetFieldID())
paths = append(paths, &internalpb.StringList{Values: field.GetBinlogs()})
binlogs := field.GetBinlogs()
p := make([]string, 0, len(binlogs))
for _, log := range binlogs {
p = append(p, log.GetLogPath())
}
paths = append(paths, &internalpb.StringList{Values: p})
}
resp.Status.ErrorCode = commonpb.ErrorCode_Success
resp.FieldIDs = fids
@ -500,7 +505,7 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
segmentIDs := s.meta.GetSegmentsIDOfPartition(collectionID, partitionID)
segment2Binlogs := make(map[UniqueID][]*datapb.FieldBinlog)
segment2StatsBinlogs := make(map[UniqueID][]*datapb.FieldBinlog)
segment2DeltaBinlogs := make(map[UniqueID][]*datapb.DeltaLogInfo)
segment2DeltaBinlogs := make(map[UniqueID][]*datapb.FieldBinlog)
segmentsNumOfRows := make(map[UniqueID]int64)
flushedIDs := make(map[int64]struct{})
@ -526,7 +531,7 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
flushedIDs[id] = struct{}{}
}
field2Binlog := make(map[UniqueID][]string)
field2Binlog := make(map[UniqueID][]*datapb.Binlog)
for _, field := range binlogs {
field2Binlog[field.GetFieldID()] = append(field2Binlog[field.GetFieldID()], field.GetBinlogs()...)
}
@ -542,7 +547,7 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
segmentsNumOfRows[id] = segment.NumOfRows
statsBinlogs := segment.GetStatslogs()
field2StatsBinlog := make(map[UniqueID][]string)
field2StatsBinlog := make(map[UniqueID][]*datapb.Binlog)
for _, field := range statsBinlogs {
field2StatsBinlog[field.GetFieldID()] = append(field2StatsBinlog[field.GetFieldID()], field.GetBinlogs()...)
}
@ -555,7 +560,9 @@ func (s *Server) GetRecoveryInfo(ctx context.Context, req *datapb.GetRecoveryInf
segment2StatsBinlogs[id] = append(segment2StatsBinlogs[id], fieldBinlogs)
}
segment2DeltaBinlogs[id] = append(segment2DeltaBinlogs[id], segment.GetDeltalogs()...)
if len(segment.GetDeltalogs()) > 0 {
segment2DeltaBinlogs[id] = append(segment2DeltaBinlogs[id], segment.GetDeltalogs()...)
}
}
binlogs := make([]*datapb.SegmentBinlogs, 0, len(segment2Binlogs))

32
internal/datanode/binlog_io.go
View File

@ -104,7 +104,7 @@ func (b *binlogIO) download(ctx context.Context, paths []string) ([]*Blob, error
type cpaths struct {
inPaths []*datapb.FieldBinlog
statsPaths []*datapb.FieldBinlog
deltaInfo *datapb.DeltaLogInfo
deltaInfo []*datapb.FieldBinlog
}
func (b *binlogIO) upload(
@ -114,11 +114,7 @@ func (b *binlogIO) upload(
dData *DeleteData,
meta *etcdpb.CollectionMeta) (*cpaths, error) {
var p = &cpaths{
inPaths: make([]*datapb.FieldBinlog, 0),
statsPaths: make([]*datapb.FieldBinlog, 0),
deltaInfo: &datapb.DeltaLogInfo{},
}
p := &cpaths{}
kvs := make(map[string]string)
@ -156,8 +152,16 @@ func (b *binlogIO) upload(
}
kvs[k] = bytes.NewBuffer(v).String()
p.deltaInfo.RecordEntries = uint64(len(v))
p.deltaInfo.DeltaLogPath = k
p.deltaInfo = append(p.deltaInfo, &datapb.FieldBinlog{
//Field id shall be primary key id
Binlogs: []*datapb.Binlog{
{
EntriesNum: dData.RowCount,
LogPath: k,
LogSize: int64(len(v)),
},
},
})
}
var err = errStart
@ -234,7 +238,11 @@ func (b *binlogIO) genInsertBlobs(data *InsertData, partID, segID UniqueID, meta
kvs[key] = bytes.NewBuffer(blob.GetValue()).String()
inpaths = append(inpaths, &datapb.FieldBinlog{
FieldID: fID,
Binlogs: []string{key},
Binlogs: []*datapb.Binlog{
{
LogPath: key,
},
},
})
}
@ -248,7 +256,11 @@ func (b *binlogIO) genInsertBlobs(data *InsertData, partID, segID UniqueID, meta
kvs[key] = bytes.NewBuffer(blob.GetValue()).String()
statspaths = append(statspaths, &datapb.FieldBinlog{
FieldID: fID,
Binlogs: []string{key},
Binlogs: []*datapb.Binlog{
{
LogPath: key,
},
},
})
}

11
internal/datanode/binlog_io_test.go
View File

@ -44,15 +44,16 @@ func TestBinlogIOInterfaceMethods(t *testing.T) {
iData := genInsertData()
dData := &DeleteData{
Pks: []int64{888},
Tss: []uint64{666666},
RowCount: 1,
Pks: []int64{888},
Tss: []uint64{666666},
}
p, err := b.upload(context.TODO(), 1, 10, []*InsertData{iData}, dData, meta)
assert.NoError(t, err)
assert.Equal(t, 11, len(p.inPaths))
assert.Equal(t, 3, len(p.statsPaths))
assert.NotNil(t, p.deltaInfo.GetDeltaLogPath())
assert.NotNil(t, p.deltaInfo)
ctx, cancel := context.WithCancel(context.Background())
cancel()
@ -243,8 +244,8 @@ func TestBinlogIOInnerMethods(t *testing.T) {
log.Debug("test paths",
zap.Any("kvs no.", len(kvs)),
zap.String("insert paths field0", pin[0].GetBinlogs()[0]),
zap.String("stats paths field0", pstats[0].GetBinlogs()[0]))
zap.String("insert paths field0", pin[0].GetBinlogs()[0].GetLogPath()),
zap.String("stats paths field0", pstats[0].GetBinlogs()[0].GetLogPath()))
})
t.Run("Test genInsertBlobs error", func(t *testing.T) {

64
internal/datanode/compactor.go
View File

@ -127,8 +127,10 @@ func (t *compactionTask) mergeDeltalogs(dBlobs map[UniqueID][]*Blob, timetravelT
delData: &DeleteData{
Pks: make([]UniqueID, 0),
Tss: make([]Timestamp, 0)},
tsFrom: math.MaxUint64,
tsTo: 0,
Binlog: datapb.Binlog{
TimestampFrom: math.MaxUint64,
TimestampTo: 0,
},
}
)
@ -150,12 +152,12 @@ func (t *compactionTask) mergeDeltalogs(dBlobs map[UniqueID][]*Blob, timetravelT
dbuff.delData.Append(pk, ts)
if ts < dbuff.tsFrom {
dbuff.tsFrom = ts
if Timestamp(ts) < dbuff.TimestampFrom {
dbuff.TimestampFrom = Timestamp(ts)
}
if ts > dbuff.tsTo {
dbuff.tsTo = ts
if Timestamp(ts) > dbuff.TimestampTo {
dbuff.TimestampTo = Timestamp(ts)
}
}
}
@ -343,7 +345,7 @@ func (t *compactionTask) compact() error {
for idx := 0; idx < fieldNum; idx++ {
ps := make([]string, 0, fieldNum)
for _, f := range s.GetFieldBinlogs() {
ps = append(ps, f.GetBinlogs()[idx])
ps = append(ps, f.GetBinlogs()[idx].GetLogPath())
}
g.Go(func() error {
@ -369,20 +371,22 @@ func (t *compactionTask) compact() error {
segID := s.GetSegmentID()
for _, d := range s.GetDeltalogs() {
path := d.GetDeltaLogPath()
g.Go(func() error {
bs, err := t.download(gCtx, []string{path})
if err != nil {
log.Warn("download deltalogs wrong")
return err
}
for _, l := range d.GetBinlogs() {
path := l.GetLogPath()
g.Go(func() error {
bs, err := t.download(gCtx, []string{path})
if err != nil {
log.Warn("download deltalogs wrong")
return err
}
dmu.Lock()
dblobs[segID] = append(dblobs[segID], bs...)
dmu.Unlock()
dmu.Lock()
dblobs[segID] = append(dblobs[segID], bs...)
dmu.Unlock()
return nil
})
return nil
})
}
}
}
@ -410,13 +414,13 @@ func (t *compactionTask) compact() error {
return err
}
var deltaLogs []*datapb.DeltaLogInfo
if len(cpaths.deltaInfo.GetDeltaLogPath()) > 0 {
cpaths.deltaInfo.DeltaLogSize = deltaBuf.size
cpaths.deltaInfo.TimestampFrom = deltaBuf.tsFrom
cpaths.deltaInfo.TimestampTo = deltaBuf.tsTo
deltaLogs = append(deltaLogs, cpaths.deltaInfo)
for _, fbl := range cpaths.deltaInfo {
for _, deltaLogInfo := range fbl.GetBinlogs() {
deltaLogInfo.LogSize = deltaBuf.GetLogSize()
deltaLogInfo.TimestampFrom = deltaBuf.GetTimestampFrom()
deltaLogInfo.TimestampTo = deltaBuf.GetTimestampTo()
deltaLogInfo.EntriesNum = deltaBuf.GetEntriesNum()
}
}
pack := &datapb.CompactionResult{
@ -424,8 +428,8 @@ func (t *compactionTask) compact() error {
SegmentID: targetSegID,
InsertLogs: cpaths.inPaths,
Field2StatslogPaths: cpaths.statsPaths,
Deltalogs: cpaths.deltaInfo,
NumOfRows: numRows,
Deltalogs: deltaLogs,
}
status, err := t.dc.CompleteCompaction(ctxTimeout, pack)
@ -460,9 +464,9 @@ func (t *compactionTask) compact() error {
ti.injectDone(true)
log.Info("compaction done", zap.Int64("planID", t.plan.GetPlanID()),
zap.Any("num of binlog paths", len(cpaths.inPaths)),
zap.Any("num of stats paths", len(cpaths.statsPaths)),
zap.Any("deltalog paths", cpaths.deltaInfo.GetDeltaLogPath()),
zap.Int("num of binlog paths", len(cpaths.inPaths)),
zap.Int("num of stats paths", len(cpaths.statsPaths)),
zap.Int("num of delta paths", len(cpaths.deltaInfo)),
)
return nil
}

10
internal/datanode/compactor_test.go
View File

@ -155,7 +155,7 @@ func TestCompactionTaskInnerMethods(t *testing.T) {
pk2ts, db, err := task.mergeDeltalogs(test.dBlobs, test.timetravel)
assert.NoError(t, err)
assert.Equal(t, 3, len(pk2ts))
assert.Equal(t, int64(3), db.size)
assert.Equal(t, int64(3), db.GetEntriesNum())
assert.Equal(t, int64(3), db.delData.RowCount)
assert.ElementsMatch(t, []UniqueID{1, 4, 5}, db.delData.Pks)
assert.ElementsMatch(t, []Timestamp{30000, 50000, 50000}, db.delData.Tss)
@ -228,7 +228,7 @@ func TestCompactionTaskInnerMethods(t *testing.T) {
pk2ts, db, err := task.mergeDeltalogs(dBlobs, test.timetravel)
assert.NoError(t, err)
assert.Equal(t, test.expectedpk2ts, len(pk2ts))
assert.Equal(t, test.expecteddb, int(db.size))
assert.Equal(t, test.expecteddb, int(db.GetEntriesNum()))
})
}
})
@ -355,7 +355,7 @@ func TestCompactorInterfaceMethods(t *testing.T) {
SegmentID: segID,
FieldBinlogs: cpaths.inPaths,
Field2StatslogPaths: cpaths.statsPaths,
Deltalogs: []*datapb.DeltaLogInfo{cpaths.deltaInfo},
Deltalogs: cpaths.deltaInfo,
},
},
StartTime: 0,
@ -460,13 +460,13 @@ func TestCompactorInterfaceMethods(t *testing.T) {
SegmentID: segID1,
FieldBinlogs: cpaths1.inPaths,
Field2StatslogPaths: cpaths1.statsPaths,
Deltalogs: []*datapb.DeltaLogInfo{cpaths1.deltaInfo},
Deltalogs: cpaths1.deltaInfo,
},
{
SegmentID: segID2,
FieldBinlogs: cpaths2.inPaths,
Field2StatslogPaths: cpaths2.statsPaths,
Deltalogs: []*datapb.DeltaLogInfo{cpaths2.deltaInfo},
Deltalogs: cpaths2.deltaInfo,
},
},
StartTime: 0,

29
internal/datanode/flow_graph_delete_node.go
View File

@ -26,6 +26,7 @@ import (
"github.com/milvus-io/milvus/internal/common"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/msgstream"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/storage"
"github.com/milvus-io/milvus/internal/util/trace"
"github.com/opentracing/opentracing-go"
@ -51,33 +52,31 @@ type deleteNode struct {
// DelDataBuf buffers insert data, monitoring buffer size and limit
// size and limit both indicate numOfRows
type DelDataBuf struct {
delData *DeleteData
size int64
tsFrom Timestamp
tsTo Timestamp
fileSize int64
filePath string
datapb.Binlog
delData *DeleteData
}
func (ddb *DelDataBuf) updateSize(size int64) {
ddb.size += size
ddb.EntriesNum += size
}
func (ddb *DelDataBuf) updateTimeRange(tr TimeRange) {
if tr.timestampMin < ddb.tsFrom {
ddb.tsFrom = tr.timestampMin
if tr.timestampMin < ddb.TimestampFrom {
ddb.TimestampFrom = tr.timestampMin
}
if tr.timestampMax > ddb.tsTo {
ddb.tsTo = tr.timestampMax
if tr.timestampMax > ddb.TimestampTo {
ddb.TimestampTo = tr.timestampMax
}
}
func newDelDataBuf() *DelDataBuf {
return &DelDataBuf{
delData: &DeleteData{},
size: 0,
tsFrom: math.MaxUint64,
tsTo: 0,
Binlog: datapb.Binlog{
EntriesNum: 0,
TimestampFrom: math.MaxUint64,
TimestampTo: 0,
},
}
}
@ -155,7 +154,7 @@ func (dn *deleteNode) showDelBuf() {
delDataBuf, _ := v.(*DelDataBuf)
log.Debug("delta buffer status",
zap.Int64("segID", segID),
zap.Int64("size", delDataBuf.size),
zap.Int64("size", delDataBuf.GetEntriesNum()),
zap.String("vchannel", dn.channelName))
// TODO control the printed length
length := len(delDataBuf.delData.Pks)

9
internal/datanode/flow_graph_insert_buffer_node.go
View File

@ -97,15 +97,6 @@ type segmentCheckPoint struct {
pos internalpb.MsgPosition
}
type segmentFlushUnit struct {
collID UniqueID
segID UniqueID
field2Path map[UniqueID]string
checkPoint map[UniqueID]segmentCheckPoint
startPositions []*datapb.SegmentStartPosition
flushed bool
}
// BufferData buffers insert data, monitoring buffer size and limit
// size and limit both indicate numOfRows
type BufferData struct {

73
internal/datanode/flush_manager.go
View File

@ -54,9 +54,9 @@ type flushManager interface {
// segmentFlushPack contains result to save into meta
type segmentFlushPack struct {
segmentID UniqueID
insertLogs map[UniqueID]string
statsLogs map[UniqueID]string
deltaLogs []*DelDataBuf
insertLogs map[UniqueID]*datapb.Binlog
statsLogs map[UniqueID]*datapb.Binlog
deltaLogs []*datapb.Binlog
pos *internalpb.MsgPosition
flushed bool
dropped bool
@ -162,7 +162,7 @@ func (q *orderFlushQueue) postTask(pack *segmentFlushPack, postInjection postInj
}
// enqueueInsertBuffer put insert buffer data into queue
func (q *orderFlushQueue) enqueueInsertFlush(task flushInsertTask, binlogs, statslogs map[UniqueID]string, flushed bool, dropped bool, pos *internalpb.MsgPosition) {
func (q *orderFlushQueue) enqueueInsertFlush(task flushInsertTask, binlogs, statslogs map[UniqueID]*datapb.Binlog, flushed bool, dropped bool, pos *internalpb.MsgPosition) {
q.getFlushTaskRunner(pos).runFlushInsert(task, binlogs, statslogs, flushed, dropped, pos)
}
@ -257,7 +257,7 @@ func (m *rendezvousFlushManager) getFlushQueue(segmentID UniqueID) *orderFlushQu
return queue
}
func (m *rendezvousFlushManager) handleInsertTask(segmentID UniqueID, task flushInsertTask, binlogs, statslogs map[UniqueID]string, flushed bool, dropped bool, pos *internalpb.MsgPosition) {
func (m *rendezvousFlushManager) handleInsertTask(segmentID UniqueID, task flushInsertTask, binlogs, statslogs map[UniqueID]*datapb.Binlog, flushed bool, dropped bool, pos *internalpb.MsgPosition) {
// in dropping mode
if m.dropping.Load() {
r := &flushTaskRunner{
@ -313,7 +313,7 @@ func (m *rendezvousFlushManager) flushBufferData(data *BufferData, segmentID Uni
if data == nil || data.buffer == nil {
//m.getFlushQueue(segmentID).enqueueInsertFlush(&flushBufferInsertTask{},
// map[UniqueID]string{}, map[UniqueID]string{}, flushed, dropped, pos)
m.handleInsertTask(segmentID, &flushBufferInsertTask{}, map[UniqueID]string{}, map[UniqueID]string{},
m.handleInsertTask(segmentID, &flushBufferInsertTask{}, map[UniqueID]*datapb.Binlog{}, map[UniqueID]*datapb.Binlog{},
flushed, dropped, pos)
return nil
}
@ -336,9 +336,8 @@ func (m *rendezvousFlushManager) flushBufferData(data *BufferData, segmentID Uni
return err
}
field2Insert := make(map[UniqueID]string, len(binLogs))
field2Insert := make(map[UniqueID]*datapb.Binlog, len(binLogs))
kvs := make(map[string]string, len(binLogs))
paths := make([]string, 0, len(binLogs))
field2Logidx := make(map[UniqueID]UniqueID, len(binLogs))
for idx, blob := range binLogs {
fieldID, err := strconv.ParseInt(blob.GetKey(), 10, 64)
@ -353,13 +352,18 @@ func (m *rendezvousFlushManager) flushBufferData(data *BufferData, segmentID Uni
k := JoinIDPath(collID, partID, segmentID, fieldID, logidx)
key := path.Join(Params.InsertBinlogRootPath, k)
paths = append(paths, key)
kvs[key] = string(blob.Value[:])
field2Insert[fieldID] = key
field2Insert[fieldID] = &datapb.Binlog{
EntriesNum: data.size,
TimestampFrom: 0, //TODO
TimestampTo: 0, //TODO,
LogPath: key,
LogSize: int64(len(blob.Value)),
}
field2Logidx[fieldID] = logidx
}
field2Stats := make(map[UniqueID]string)
field2Stats := make(map[UniqueID]*datapb.Binlog)
// write stats binlog
for _, blob := range statsBinlogs {
fieldID, err := strconv.ParseInt(blob.GetKey(), 10, 64)
@ -374,16 +378,17 @@ func (m *rendezvousFlushManager) flushBufferData(data *BufferData, segmentID Uni
k := JoinIDPath(collID, partID, segmentID, fieldID, logidx)
key := path.Join(Params.StatsBinlogRootPath, k)
kvs[key] = string(blob.Value[:])
field2Stats[fieldID] = key
kvs[key] = string(blob.Value)
field2Stats[fieldID] = &datapb.Binlog{
EntriesNum: 0,
TimestampFrom: 0, //TODO
TimestampTo: 0, //TODO,
LogPath: key,
LogSize: int64(len(blob.Value)),
}
}
m.updateSegmentCheckPoint(segmentID)
/*
m.getFlushQueue(segmentID).enqueueInsertFlush(&flushBufferInsertTask{
BaseKV: m.BaseKV,
data: kvs,
}, field2Insert, field2Stats, flushed, dropped, pos)*/
m.handleInsertTask(segmentID, &flushBufferInsertTask{
BaseKV: m.BaseKV,
data: kvs,
@ -397,9 +402,6 @@ func (m *rendezvousFlushManager) flushDelData(data *DelDataBuf, segmentID Unique
// del signal with empty data
if data == nil || data.delData == nil {
/*
m.getFlushQueue(segmentID).enqueueDelFlush(&flushBufferDeleteTask{}, nil, pos)
*/
m.handleDeleteTask(segmentID, &flushBufferDeleteTask{}, nil, pos)
return nil
}
@ -425,14 +427,9 @@ func (m *rendezvousFlushManager) flushDelData(data *DelDataBuf, segmentID Unique
blobKey := JoinIDPath(collID, partID, segmentID, logID)
blobPath := path.Join(Params.DeleteBinlogRootPath, blobKey)
kvs := map[string]string{blobPath: string(blob.Value[:])}
data.fileSize = int64(len(blob.Value))
data.filePath = blobPath
data.LogSize = int64(len(blob.Value))
data.LogPath = blobPath
log.Debug("delete blob path", zap.String("path", blobPath))
/*
m.getFlushQueue(segmentID).enqueueDelFlush(&flushBufferDeleteTask{
BaseKV: m.BaseKV,
data: kvs,
}, data, pos)*/
m.handleDeleteTask(segmentID, &flushBufferDeleteTask{
BaseKV: m.BaseKV,
data: kvs,
@ -607,7 +604,7 @@ func dropVirtualChannelFunc(dsService *dataSyncService, opts ...retry.Option) fl
if fieldBinlogs == nil {
segment.Field2BinlogPaths = append(segment.Field2BinlogPaths, &datapb.FieldBinlog{
FieldID: k,
Binlogs: []string{v},
Binlogs: []*datapb.Binlog{v},
})
} else {
fieldBinlogs.Binlogs = append(fieldBinlogs.Binlogs, v)
@ -618,15 +615,15 @@ func dropVirtualChannelFunc(dsService *dataSyncService, opts ...retry.Option) fl
if fieldStatsLogs == nil {
segment.Field2StatslogPaths = append(segment.Field2StatslogPaths, &datapb.FieldBinlog{
FieldID: k,
Binlogs: []string{v},
Binlogs: []*datapb.Binlog{v},
})
} else {
fieldStatsLogs.Binlogs = append(fieldStatsLogs.Binlogs, v)
}
}
for _, delData := range pack.deltaLogs {
segment.Deltalogs = append(segment.Deltalogs, &datapb.DeltaLogInfo{RecordEntries: uint64(delData.size), TimestampFrom: delData.tsFrom, TimestampTo: delData.tsTo, DeltaLogPath: delData.filePath, DeltaLogSize: delData.fileSize})
}
segment.Deltalogs = append(segment.Deltalogs, &datapb.FieldBinlog{
Binlogs: pack.deltaLogs,
})
updates, _ := dsService.replica.getSegmentStatisticsUpdates(pack.segmentID)
segment.NumOfRows = updates.GetNumRows()
if pack.pos != nil {
@ -683,17 +680,15 @@ func flushNotifyFunc(dsService *dataSyncService, opts ...retry.Option) notifyMet
}
fieldInsert := []*datapb.FieldBinlog{}
fieldStats := []*datapb.FieldBinlog{}
deltaInfos := []*datapb.DeltaLogInfo{}
deltaInfos := []*datapb.FieldBinlog{}
checkPoints := []*datapb.CheckPoint{}
for k, v := range pack.insertLogs {
fieldInsert = append(fieldInsert, &datapb.FieldBinlog{FieldID: k, Binlogs: []string{v}})
fieldInsert = append(fieldInsert, &datapb.FieldBinlog{FieldID: k, Binlogs: []*datapb.Binlog{v}})
}
for k, v := range pack.statsLogs {
fieldStats = append(fieldStats, &datapb.FieldBinlog{FieldID: k, Binlogs: []string{v}})
}
for _, delData := range pack.deltaLogs {
deltaInfos = append(deltaInfos, &datapb.DeltaLogInfo{RecordEntries: uint64(delData.size), TimestampFrom: delData.tsFrom, TimestampTo: delData.tsTo, DeltaLogPath: delData.filePath, DeltaLogSize: delData.fileSize})
fieldStats = append(fieldStats, &datapb.FieldBinlog{FieldID: k, Binlogs: []*datapb.Binlog{v}})
}
deltaInfos = append(deltaInfos, &datapb.FieldBinlog{Binlogs: pack.deltaLogs})
// only current segment checkpoint info,
updates, _ := dsService.replica.getSegmentStatisticsUpdates(pack.segmentID)

23
internal/datanode/flush_manager_test.go
View File

@ -25,6 +25,7 @@ import (
"time"
memkv "github.com/milvus-io/milvus/internal/kv/mem"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/retry"
"github.com/stretchr/testify/assert"
@ -81,7 +82,7 @@ func TestOrderFlushQueue_Execute(t *testing.T) {
wg.Done()
}(ids[i])
go func(id []byte) {
q.enqueueInsertFlush(&emptyFlushTask{}, map[UniqueID]string{}, map[UniqueID]string{}, false, false, &internalpb.MsgPosition{
q.enqueueInsertFlush(&emptyFlushTask{}, map[UniqueID]*datapb.Binlog{}, map[UniqueID]*datapb.Binlog{}, false, false, &internalpb.MsgPosition{
MsgID: id,
})
wg.Done()
@ -119,7 +120,7 @@ func TestOrderFlushQueue_Order(t *testing.T) {
q.enqueueDelFlush(&emptyFlushTask{}, &DelDataBuf{}, &internalpb.MsgPosition{
MsgID: ids[i],
})
q.enqueueInsertFlush(&emptyFlushTask{}, map[UniqueID]string{}, map[UniqueID]string{}, false, false, &internalpb.MsgPosition{
q.enqueueInsertFlush(&emptyFlushTask{}, map[UniqueID]*datapb.Binlog{}, map[UniqueID]*datapb.Binlog{}, false, false, &internalpb.MsgPosition{
MsgID: ids[i],
})
wg.Done()
@ -532,9 +533,9 @@ func TestFlushNotifyFunc(t *testing.T) {
t.Run("normal run", func(t *testing.T) {
assert.NotPanics(t, func() {
notifyFunc(&segmentFlushPack{
insertLogs: map[UniqueID]string{1: "/dev/test/id"},
statsLogs: map[UniqueID]string{1: "/dev/test/id-stats"},
deltaLogs: []*DelDataBuf{{filePath: "/dev/test/del"}},
insertLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/id"}},
statsLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/id-stats"}},
deltaLogs: []*datapb.Binlog{{LogPath: "/dev/test/del"}},
flushed: true,
})
})
@ -589,9 +590,9 @@ func TestDropVirtualChannelFunc(t *testing.T) {
dropFunc([]*segmentFlushPack{
{
segmentID: 1,
insertLogs: map[UniqueID]string{1: "/dev/test/id"},
statsLogs: map[UniqueID]string{1: "/dev/test/id-stats"},
deltaLogs: []*DelDataBuf{{filePath: "/dev/test/del"}},
insertLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/id"}},
statsLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/id-stats"}},
deltaLogs: []*datapb.Binlog{{LogPath: "/dev/test/del"}},
pos: &internalpb.MsgPosition{
ChannelName: "vchan_01",
MsgID: []byte{1, 2, 3},
@ -600,9 +601,9 @@ func TestDropVirtualChannelFunc(t *testing.T) {
},
{
segmentID: 1,
insertLogs: map[UniqueID]string{1: "/dev/test/id_2"},
statsLogs: map[UniqueID]string{1: "/dev/test/id-stats-2"},
deltaLogs: []*DelDataBuf{{filePath: "/dev/test/del-2"}},
insertLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/idi_2"}},
statsLogs: map[UniqueID]*datapb.Binlog{1: {LogPath: "/dev/test/id-stats-2"}},
deltaLogs: []*datapb.Binlog{{LogPath: "/dev/test/del-2"}},
pos: &internalpb.MsgPosition{
ChannelName: "vchan_01",
MsgID: []byte{1, 2, 3},

20
internal/datanode/flush_task.go
View File

@ -23,6 +23,7 @@ import (
"github.com/milvus-io/milvus/internal/kv"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/retry"
"go.uber.org/zap"
@ -57,9 +58,9 @@ type flushTaskRunner struct {
injectSignal <-chan *taskInjection
segmentID UniqueID
insertLogs map[UniqueID]string
statsLogs map[UniqueID]string
deltaLogs []*DelDataBuf
insertLogs map[UniqueID]*datapb.Binlog
statsLogs map[UniqueID]*datapb.Binlog
deltaLogs []*datapb.Binlog //[]*DelDataBuf
pos *internalpb.MsgPosition
flushed bool
dropped bool
@ -121,7 +122,7 @@ func (t *flushTaskRunner) init(f notifyMetaFunc, postFunc taskPostFunc, signal <
// runFlushInsert executei flush insert task with once and retry
func (t *flushTaskRunner) runFlushInsert(task flushInsertTask,
binlogs, statslogs map[UniqueID]string, flushed bool, dropped bool, pos *internalpb.MsgPosition, opts ...retry.Option) {
binlogs, statslogs map[UniqueID]*datapb.Binlog, flushed bool, dropped bool, pos *internalpb.MsgPosition, opts ...retry.Option) {
t.insertOnce.Do(func() {
t.insertLogs = binlogs
t.statsLogs = statslogs
@ -144,9 +145,16 @@ func (t *flushTaskRunner) runFlushInsert(task flushInsertTask,
func (t *flushTaskRunner) runFlushDel(task flushDeleteTask, deltaLogs *DelDataBuf, opts ...retry.Option) {
t.deleteOnce.Do(func() {
if deltaLogs == nil {
t.deltaLogs = []*DelDataBuf{}
t.deltaLogs = nil //[]*DelDataBuf{}
} else {
t.deltaLogs = []*DelDataBuf{deltaLogs}
t.deltaLogs = []*datapb.Binlog{
{
LogSize: deltaLogs.GetLogSize(),
LogPath: deltaLogs.GetLogPath(),
TimestampFrom: deltaLogs.GetTimestampFrom(),
TimestampTo: deltaLogs.GetTimestampTo(),
},
}
}
go func() {
err := retry.Do(context.Background(), func() error {

6
internal/datanode/segment_replica.go
View File

@ -401,12 +401,14 @@ func (replica *SegmentReplica) initPKBloomFilter(s *Segment, statsBinlogs []*dat
}
// filter stats binlog files which is pk field stats log
bloomFilterFiles := make([]string, 0)
var bloomFilterFiles []string
for _, binlog := range statsBinlogs {
if binlog.FieldID != pkField {
continue
}
bloomFilterFiles = append(bloomFilterFiles, binlog.Binlogs...)
for _, log := range binlog.GetBinlogs() {
bloomFilterFiles = append(bloomFilterFiles, log.GetLogPath())
}
}
values, err := replica.minIOKV.MultiLoad(bloomFilterFiles)

2
internal/datanode/segment_replica_test.go
View File

@ -91,7 +91,7 @@ func (kv *mockMinioKVStatsError) MultiLoad(keys []string) ([]string, error) {
func getSimpleFieldBinlog() *datapb.FieldBinlog {
return &datapb.FieldBinlog{
FieldID: 106,
Binlogs: []string{"test"},
Binlogs: []*datapb.Binlog{{LogPath: "test"}},
}
}

23
internal/proto/data_coord.proto
View File

@ -210,7 +210,8 @@ message SegmentInfo {
// binlogs consist of insert binlogs
repeated FieldBinlog binlogs = 11;
repeated FieldBinlog statslogs = 12;
repeated DeltaLogInfo deltalogs = 13;
// deltalogs consists of delete binlogs. FieldID is not used yet since delete is always applied on primary key
repeated FieldBinlog deltalogs = 13;
bool createdByCompaction = 14;
repeated int64 compactionFrom = 15;
@ -231,7 +232,7 @@ message SaveBinlogPathsRequest {
repeated SegmentStartPosition start_positions = 6;
bool flushed = 7;
repeated FieldBinlog field2StatslogPaths = 8;
repeated DeltaLogInfo deltalogs = 9;
repeated FieldBinlog deltalogs = 9;
bool dropped = 10;
}
@ -283,12 +284,20 @@ message SegmentBinlogs {
repeated FieldBinlog fieldBinlogs = 2;
int64 num_of_rows = 3;
repeated FieldBinlog statslogs = 4;
repeated DeltaLogInfo deltalogs = 5;
repeated FieldBinlog deltalogs = 5;
}
message FieldBinlog{
int64 fieldID = 1;
repeated string binlogs = 2;
repeated Binlog binlogs = 2;
}
message Binlog {
int64 entries_num = 1;
uint64 timestamp_from = 2;
uint64 timestamp_to = 3;
string log_path = 4;
int64 log_size = 5;
}
message GetRecoveryInfoResponse {
@ -335,7 +344,7 @@ message CompactionSegmentBinlogs {
int64 segmentID = 1;
repeated FieldBinlog fieldBinlogs = 2;
repeated FieldBinlog field2StatslogPaths = 3;
repeated DeltaLogInfo deltalogs = 4;
repeated FieldBinlog deltalogs = 4;
}
message CompactionPlan {
@ -354,7 +363,7 @@ message CompactionResult {
int64 num_of_rows = 3;
repeated FieldBinlog insert_logs = 4;
repeated FieldBinlog field2StatslogPaths = 5;
repeated DeltaLogInfo deltalogs = 6;
repeated FieldBinlog deltalogs = 6;
}
// Deprecated
@ -383,7 +392,7 @@ message DropVirtualChannelSegment {
int64 collectionID = 2;
repeated FieldBinlog field2BinlogPaths = 3;
repeated FieldBinlog field2StatslogPaths = 4;
repeated DeltaLogInfo deltalogs = 5;
repeated FieldBinlog deltalogs = 5;
internal.MsgPosition startPosition = 6;
internal.MsgPosition checkPoint = 7;
int64 numOfRows = 8;

552
internal/proto/datapb/data_coord.pb.go
View File

@ -1374,15 +1374,16 @@ type SegmentInfo struct {
StartPosition *internalpb.MsgPosition `protobuf:"bytes,9,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"`
DmlPosition *internalpb.MsgPosition `protobuf:"bytes,10,opt,name=dml_position,json=dmlPosition,proto3" json:"dml_position,omitempty"`
// binlogs consist of insert binlogs
Binlogs []*FieldBinlog `protobuf:"bytes,11,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
Statslogs []*FieldBinlog `protobuf:"bytes,12,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,13,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
CreatedByCompaction bool `protobuf:"varint,14,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"`
CompactionFrom []int64 `protobuf:"varint,15,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
DroppedAt uint64 `protobuf:"varint,16,opt,name=dropped_at,json=droppedAt,proto3" json:"dropped_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Binlogs []*FieldBinlog `protobuf:"bytes,11,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
Statslogs []*FieldBinlog `protobuf:"bytes,12,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
// deltalogs consists of delete binlogs. FieldID is not used yet since delete is always applied on primary key
Deltalogs []*FieldBinlog `protobuf:"bytes,13,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
CreatedByCompaction bool `protobuf:"varint,14,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"`
CompactionFrom []int64 `protobuf:"varint,15,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
DroppedAt uint64 `protobuf:"varint,16,opt,name=dropped_at,json=droppedAt,proto3" json:"dropped_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SegmentInfo) Reset() { *m = SegmentInfo{} }
@ -1494,7 +1495,7 @@ func (m *SegmentInfo) GetStatslogs() []*FieldBinlog {
return nil
}
func (m *SegmentInfo) GetDeltalogs() []*DeltaLogInfo {
func (m *SegmentInfo) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -1578,7 +1579,7 @@ type SaveBinlogPathsRequest struct {
StartPositions []*SegmentStartPosition `protobuf:"bytes,6,rep,name=start_positions,json=startPositions,proto3" json:"start_positions,omitempty"`
Flushed bool `protobuf:"varint,7,opt,name=flushed,proto3" json:"flushed,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,8,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
Deltalogs []*FieldBinlog `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
Dropped bool `protobuf:"varint,10,opt,name=dropped,proto3" json:"dropped,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -1666,7 +1667,7 @@ func (m *SaveBinlogPathsRequest) GetField2StatslogPaths() []*FieldBinlog {
return nil
}
func (m *SaveBinlogPathsRequest) GetDeltalogs() []*DeltaLogInfo {
func (m *SaveBinlogPathsRequest) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2027,14 +2028,14 @@ func (m *DataNodeInfo) GetChannels() []*ChannelStatus {
}
type SegmentBinlogs struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"`
NumOfRows int64 `protobuf:"varint,3,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
Statslogs []*FieldBinlog `protobuf:"bytes,4,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"`
NumOfRows int64 `protobuf:"varint,3,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
Statslogs []*FieldBinlog `protobuf:"bytes,4,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
Deltalogs []*FieldBinlog `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SegmentBinlogs) Reset() { *m = SegmentBinlogs{} }
@ -2090,7 +2091,7 @@ func (m *SegmentBinlogs) GetStatslogs() []*FieldBinlog {
return nil
}
func (m *SegmentBinlogs) GetDeltalogs() []*DeltaLogInfo {
func (m *SegmentBinlogs) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2098,11 +2099,11 @@ func (m *SegmentBinlogs) GetDeltalogs() []*DeltaLogInfo {
}
type FieldBinlog struct {
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
Binlogs []string `protobuf:"bytes,2,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
Binlogs []*Binlog `protobuf:"bytes,2,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FieldBinlog) Reset() { *m = FieldBinlog{} }
@ -2137,13 +2138,84 @@ func (m *FieldBinlog) GetFieldID() int64 {
return 0
}
func (m *FieldBinlog) GetBinlogs() []string {
func (m *FieldBinlog) GetBinlogs() []*Binlog {
if m != nil {
return m.Binlogs
}
return nil
}
type Binlog struct {
EntriesNum int64 `protobuf:"varint,1,opt,name=entries_num,json=entriesNum,proto3" json:"entries_num,omitempty"`
TimestampFrom uint64 `protobuf:"varint,2,opt,name=timestamp_from,json=timestampFrom,proto3" json:"timestamp_from,omitempty"`
TimestampTo uint64 `protobuf:"varint,3,opt,name=timestamp_to,json=timestampTo,proto3" json:"timestamp_to,omitempty"`
LogPath string `protobuf:"bytes,4,opt,name=log_path,json=logPath,proto3" json:"log_path,omitempty"`
LogSize int64 `protobuf:"varint,5,opt,name=log_size,json=logSize,proto3" json:"log_size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Binlog) Reset() { *m = Binlog{} }
func (m *Binlog) String() string { return proto.CompactTextString(m) }
func (*Binlog) ProtoMessage() {}
func (*Binlog) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{34}
}
func (m *Binlog) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Binlog.Unmarshal(m, b)
}
func (m *Binlog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Binlog.Marshal(b, m, deterministic)
}
func (m *Binlog) XXX_Merge(src proto.Message) {
xxx_messageInfo_Binlog.Merge(m, src)
}
func (m *Binlog) XXX_Size() int {
return xxx_messageInfo_Binlog.Size(m)
}
func (m *Binlog) XXX_DiscardUnknown() {
xxx_messageInfo_Binlog.DiscardUnknown(m)
}
var xxx_messageInfo_Binlog proto.InternalMessageInfo
func (m *Binlog) GetEntriesNum() int64 {
if m != nil {
return m.EntriesNum
}
return 0
}
func (m *Binlog) GetTimestampFrom() uint64 {
if m != nil {
return m.TimestampFrom
}
return 0
}
func (m *Binlog) GetTimestampTo() uint64 {
if m != nil {
return m.TimestampTo
}
return 0
}
func (m *Binlog) GetLogPath() string {
if m != nil {
return m.LogPath
}
return ""
}
func (m *Binlog) GetLogSize() int64 {
if m != nil {
return m.LogSize
}
return 0
}
type GetRecoveryInfoResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Channels []*VchannelInfo `protobuf:"bytes,2,rep,name=channels,proto3" json:"channels,omitempty"`
@ -2157,7 +2229,7 @@ func (m *GetRecoveryInfoResponse) Reset() { *m = GetRecoveryInfoResponse
func (m *GetRecoveryInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GetRecoveryInfoResponse) ProtoMessage() {}
func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{34}
return fileDescriptor_82cd95f524594f49, []int{35}
}
func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error {
@ -2212,7 +2284,7 @@ func (m *GetRecoveryInfoRequest) Reset() { *m = GetRecoveryInfoRequest{}
func (m *GetRecoveryInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetRecoveryInfoRequest) ProtoMessage() {}
func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{35}
return fileDescriptor_82cd95f524594f49, []int{36}
}
func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error {
@ -2267,7 +2339,7 @@ func (m *GetFlushedSegmentsRequest) Reset() { *m = GetFlushedSegmentsReq
func (m *GetFlushedSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*GetFlushedSegmentsRequest) ProtoMessage() {}
func (*GetFlushedSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{36}
return fileDescriptor_82cd95f524594f49, []int{37}
}
func (m *GetFlushedSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -2321,7 +2393,7 @@ func (m *GetFlushedSegmentsResponse) Reset() { *m = GetFlushedSegmentsRe
func (m *GetFlushedSegmentsResponse) String() string { return proto.CompactTextString(m) }
func (*GetFlushedSegmentsResponse) ProtoMessage() {}
func (*GetFlushedSegmentsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{37}
return fileDescriptor_82cd95f524594f49, []int{38}
}
func (m *GetFlushedSegmentsResponse) XXX_Unmarshal(b []byte) error {
@ -2368,7 +2440,7 @@ func (m *SegmentFlushCompletedMsg) Reset() { *m = SegmentFlushCompletedM
func (m *SegmentFlushCompletedMsg) String() string { return proto.CompactTextString(m) }
func (*SegmentFlushCompletedMsg) ProtoMessage() {}
func (*SegmentFlushCompletedMsg) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{38}
return fileDescriptor_82cd95f524594f49, []int{39}
}
func (m *SegmentFlushCompletedMsg) XXX_Unmarshal(b []byte) error {
@ -2416,7 +2488,7 @@ func (m *ChannelWatchInfo) Reset() { *m = ChannelWatchInfo{} }
func (m *ChannelWatchInfo) String() string { return proto.CompactTextString(m) }
func (*ChannelWatchInfo) ProtoMessage() {}
func (*ChannelWatchInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{39}
return fileDescriptor_82cd95f524594f49, []int{40}
}
func (m *ChannelWatchInfo) XXX_Unmarshal(b []byte) error {
@ -2459,20 +2531,20 @@ func (m *ChannelWatchInfo) GetState() ChannelWatchState {
}
type CompactionSegmentBinlogs struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,3,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,4,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,3,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*FieldBinlog `protobuf:"bytes,4,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CompactionSegmentBinlogs) Reset() { *m = CompactionSegmentBinlogs{} }
func (m *CompactionSegmentBinlogs) String() string { return proto.CompactTextString(m) }
func (*CompactionSegmentBinlogs) ProtoMessage() {}
func (*CompactionSegmentBinlogs) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{40}
return fileDescriptor_82cd95f524594f49, []int{41}
}
func (m *CompactionSegmentBinlogs) XXX_Unmarshal(b []byte) error {
@ -2514,7 +2586,7 @@ func (m *CompactionSegmentBinlogs) GetField2StatslogPaths() []*FieldBinlog {
return nil
}
func (m *CompactionSegmentBinlogs) GetDeltalogs() []*DeltaLogInfo {
func (m *CompactionSegmentBinlogs) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2538,7 +2610,7 @@ func (m *CompactionPlan) Reset() { *m = CompactionPlan{} }
func (m *CompactionPlan) String() string { return proto.CompactTextString(m) }
func (*CompactionPlan) ProtoMessage() {}
func (*CompactionPlan) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{41}
return fileDescriptor_82cd95f524594f49, []int{42}
}
func (m *CompactionPlan) XXX_Unmarshal(b []byte) error {
@ -2609,22 +2681,22 @@ func (m *CompactionPlan) GetChannel() string {
}
type CompactionResult struct {
PlanID int64 `protobuf:"varint,1,opt,name=planID,proto3" json:"planID,omitempty"`
SegmentID int64 `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
NumOfRows int64 `protobuf:"varint,3,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
InsertLogs []*FieldBinlog `protobuf:"bytes,4,rep,name=insert_logs,json=insertLogs,proto3" json:"insert_logs,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,5,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,6,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
PlanID int64 `protobuf:"varint,1,opt,name=planID,proto3" json:"planID,omitempty"`
SegmentID int64 `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
NumOfRows int64 `protobuf:"varint,3,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
InsertLogs []*FieldBinlog `protobuf:"bytes,4,rep,name=insert_logs,json=insertLogs,proto3" json:"insert_logs,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,5,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*FieldBinlog `protobuf:"bytes,6,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CompactionResult) Reset() { *m = CompactionResult{} }
func (m *CompactionResult) String() string { return proto.CompactTextString(m) }
func (*CompactionResult) ProtoMessage() {}
func (*CompactionResult) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{42}
return fileDescriptor_82cd95f524594f49, []int{43}
}
func (m *CompactionResult) XXX_Unmarshal(b []byte) error {
@ -2680,7 +2752,7 @@ func (m *CompactionResult) GetField2StatslogPaths() []*FieldBinlog {
return nil
}
func (m *CompactionResult) GetDeltalogs() []*DeltaLogInfo {
func (m *CompactionResult) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2700,7 +2772,7 @@ func (m *SegmentFieldBinlogMeta) Reset() { *m = SegmentFieldBinlogMeta{}
func (m *SegmentFieldBinlogMeta) String() string { return proto.CompactTextString(m) }
func (*SegmentFieldBinlogMeta) ProtoMessage() {}
func (*SegmentFieldBinlogMeta) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{43}
return fileDescriptor_82cd95f524594f49, []int{44}
}
func (m *SegmentFieldBinlogMeta) XXX_Unmarshal(b []byte) error {
@ -2747,7 +2819,7 @@ func (m *WatchChannelsRequest) Reset() { *m = WatchChannelsRequest{} }
func (m *WatchChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchChannelsRequest) ProtoMessage() {}
func (*WatchChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{44}
return fileDescriptor_82cd95f524594f49, []int{45}
}
func (m *WatchChannelsRequest) XXX_Unmarshal(b []byte) error {
@ -2793,7 +2865,7 @@ func (m *WatchChannelsResponse) Reset() { *m = WatchChannelsResponse{} }
func (m *WatchChannelsResponse) String() string { return proto.CompactTextString(m) }
func (*WatchChannelsResponse) ProtoMessage() {}
func (*WatchChannelsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{45}
return fileDescriptor_82cd95f524594f49, []int{46}
}
func (m *WatchChannelsResponse) XXX_Unmarshal(b []byte) error {
@ -2834,7 +2906,7 @@ func (m *DropVirtualChannelRequest) Reset() { *m = DropVirtualChannelReq
func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelRequest) ProtoMessage() {}
func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{46}
return fileDescriptor_82cd95f524594f49, []int{47}
}
func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error {
@ -2881,7 +2953,7 @@ type DropVirtualChannelSegment struct {
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
Field2BinlogPaths []*FieldBinlog `protobuf:"bytes,3,rep,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
Field2StatslogPaths []*FieldBinlog `protobuf:"bytes,4,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
Deltalogs []*DeltaLogInfo `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
Deltalogs []*FieldBinlog `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
StartPosition *internalpb.MsgPosition `protobuf:"bytes,6,opt,name=startPosition,proto3" json:"startPosition,omitempty"`
CheckPoint *internalpb.MsgPosition `protobuf:"bytes,7,opt,name=checkPoint,proto3" json:"checkPoint,omitempty"`
NumOfRows int64 `protobuf:"varint,8,opt,name=numOfRows,proto3" json:"numOfRows,omitempty"`
@ -2894,7 +2966,7 @@ func (m *DropVirtualChannelSegment) Reset() { *m = DropVirtualChannelSeg
func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelSegment) ProtoMessage() {}
func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{47}
return fileDescriptor_82cd95f524594f49, []int{48}
}
func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error {
@ -2943,7 +3015,7 @@ func (m *DropVirtualChannelSegment) GetField2StatslogPaths() []*FieldBinlog {
return nil
}
func (m *DropVirtualChannelSegment) GetDeltalogs() []*DeltaLogInfo {
func (m *DropVirtualChannelSegment) GetDeltalogs() []*FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2982,7 +3054,7 @@ func (m *DropVirtualChannelResponse) Reset() { *m = DropVirtualChannelRe
func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) }
func (*DropVirtualChannelResponse) ProtoMessage() {}
func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_82cd95f524594f49, []int{48}
return fileDescriptor_82cd95f524594f49, []int{49}
}
func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error {
@ -3047,6 +3119,7 @@ func init() {
proto.RegisterType((*DataNodeInfo)(nil), "milvus.proto.data.DataNodeInfo")
proto.RegisterType((*SegmentBinlogs)(nil), "milvus.proto.data.SegmentBinlogs")
proto.RegisterType((*FieldBinlog)(nil), "milvus.proto.data.FieldBinlog")
proto.RegisterType((*Binlog)(nil), "milvus.proto.data.Binlog")
proto.RegisterType((*GetRecoveryInfoResponse)(nil), "milvus.proto.data.GetRecoveryInfoResponse")
proto.RegisterType((*GetRecoveryInfoRequest)(nil), "milvus.proto.data.GetRecoveryInfoRequest")
proto.RegisterType((*GetFlushedSegmentsRequest)(nil), "milvus.proto.data.GetFlushedSegmentsRequest")
@ -3067,182 +3140,185 @@ func init() {
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 2800 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0xdc, 0xc6,
0xf5, 0x37, 0xf7, 0x22, 0xed, 0x9e, 0xbd, 0x68, 0x3d, 0x72, 0xe4, 0xcd, 0xc6, 0x91, 0x65, 0x26,
0x71, 0x14, 0xc7, 0x91, 0x62, 0xe5, 0x1f, 0xfc, 0x83, 0x26, 0x69, 0x10, 0x59, 0x91, 0xb2, 0xa8,
0xe4, 0x2a, 0x5c, 0xc5, 0x2e, 0x1a, 0xa0, 0x0b, 0x6a, 0x39, 0x5a, 0xb1, 0x5e, 0x92, 0x6b, 0x72,
0x56, 0xb6, 0xf2, 0x12, 0xa3, 0x01, 0x0a, 0xb4, 0x68, 0x9b, 0x14, 0x7d, 0x2d, 0xd0, 0xa2, 0x4f,
0x05, 0xfa, 0x52, 0xf4, 0x31, 0xfd, 0x02, 0x45, 0xfb, 0xde, 0xcf, 0xd0, 0xb7, 0x7e, 0x85, 0x62,
0x2e, 0x1c, 0x5e, 0x96, 0xdc, 0xe5, 0x4a, 0xbe, 0xbc, 0x71, 0x86, 0xe7, 0xcc, 0x39, 0x73, 0xe6,
0x9c, 0xdf, 0x39, 0x67, 0x48, 0x68, 0x18, 0x3a, 0xd1, 0xbb, 0x3d, 0xc7, 0x71, 0x8d, 0xb5, 0xa1,
0xeb, 0x10, 0x07, 0x5d, 0xb4, 0xcc, 0xc1, 0xc9, 0xc8, 0xe3, 0xa3, 0x35, 0xfa, 0xba, 0x55, 0xed,
0x39, 0x96, 0xe5, 0xd8, 0x7c, 0xaa, 0x55, 0x37, 0x6d, 0x82, 0x5d, 0x5b, 0x1f, 0x88, 0x71, 0x35,
0xcc, 0xd0, 0xaa, 0x7a, 0xbd, 0x63, 0x6c, 0xe9, 0x7c, 0xa4, 0x3e, 0x82, 0xea, 0xf6, 0x60, 0xe4,
0x1d, 0x6b, 0xf8, 0xc1, 0x08, 0x7b, 0x04, 0xbd, 0x0d, 0x85, 0x43, 0xdd, 0xc3, 0x4d, 0x65, 0x45,
0x59, 0xad, 0x6c, 0x5c, 0x59, 0x8b, 0xc8, 0x12, 0x52, 0xf6, 0xbc, 0xfe, 0xa6, 0xee, 0x61, 0x8d,
0x51, 0x22, 0x04, 0x05, 0xe3, 0xb0, 0xbd, 0xd5, 0xcc, 0xad, 0x28, 0xab, 0x79, 0x8d, 0x3d, 0x23,
0x15, 0xaa, 0x3d, 0x67, 0x30, 0xc0, 0x3d, 0x62, 0x3a, 0x76, 0x7b, 0xab, 0x59, 0x60, 0xef, 0x22,
0x73, 0xea, 0xef, 0x15, 0xa8, 0x09, 0xd1, 0xde, 0xd0, 0xb1, 0x3d, 0x8c, 0xde, 0x81, 0x39, 0x8f,
0xe8, 0x64, 0xe4, 0x09, 0xe9, 0x2f, 0x25, 0x4a, 0xef, 0x30, 0x12, 0x4d, 0x90, 0x66, 0x12, 0x9f,
0x1f, 0x17, 0x8f, 0x96, 0x01, 0x3c, 0xdc, 0xb7, 0xb0, 0x4d, 0xda, 0x5b, 0x5e, 0xb3, 0xb0, 0x92,
0x5f, 0xcd, 0x6b, 0xa1, 0x19, 0xf5, 0xb7, 0x0a, 0x34, 0x3a, 0xfe, 0xd0, 0xb7, 0xce, 0x25, 0x28,
0xf6, 0x9c, 0x91, 0x4d, 0x98, 0x82, 0x35, 0x8d, 0x0f, 0xd0, 0x35, 0xa8, 0xf6, 0x8e, 0x75, 0xdb,
0xc6, 0x83, 0xae, 0xad, 0x5b, 0x98, 0xa9, 0x52, 0xd6, 0x2a, 0x62, 0xee, 0x8e, 0x6e, 0xe1, 0x4c,
0x1a, 0xad, 0x40, 0x65, 0xa8, 0xbb, 0xc4, 0x8c, 0xd8, 0x2c, 0x3c, 0xa5, 0xfe, 0x51, 0x81, 0xa5,
0x8f, 0x3d, 0xcf, 0xec, 0xdb, 0x63, 0x9a, 0x2d, 0xc1, 0x9c, 0xed, 0x18, 0xb8, 0xbd, 0xc5, 0x54,
0xcb, 0x6b, 0x62, 0x84, 0x5e, 0x82, 0xf2, 0x10, 0x63, 0xb7, 0xeb, 0x3a, 0x03, 0x5f, 0xb1, 0x12,
0x9d, 0xd0, 0x9c, 0x01, 0x46, 0x9f, 0xc1, 0x45, 0x2f, 0xb6, 0x90, 0xd7, 0xcc, 0xaf, 0xe4, 0x57,
0x2b, 0x1b, 0xaf, 0xac, 0x8d, 0x79, 0xd9, 0x5a, 0x5c, 0xa8, 0x36, 0xce, 0xad, 0x3e, 0xce, 0xc1,
0xa2, 0xa4, 0xe3, 0xba, 0xd2, 0x67, 0x6a, 0x39, 0x0f, 0xf7, 0xa5, 0x7a, 0x7c, 0x90, 0xc5, 0x72,
0xd2, 0xe4, 0xf9, 0xb0, 0xc9, 0x33, 0x38, 0x58, 0xdc, 0x9e, 0xc5, 0x31, 0x7b, 0xa2, 0xab, 0x50,
0xc1, 0x8f, 0x86, 0xa6, 0x8b, 0xbb, 0xc4, 0xb4, 0x70, 0x73, 0x6e, 0x45, 0x59, 0x2d, 0x68, 0xc0,
0xa7, 0x0e, 0x4c, 0x2b, 0xec, 0x91, 0xf3, 0x99, 0x3d, 0x52, 0xfd, 0x93, 0x02, 0x97, 0xc7, 0x4e,
0x49, 0xb8, 0xb8, 0x06, 0x0d, 0xb6, 0xf3, 0xc0, 0x32, 0xd4, 0xd9, 0xa9, 0xc1, 0xaf, 0x4f, 0x32,
0x78, 0x40, 0xae, 0x8d, 0xf1, 0x87, 0x94, 0xcc, 0x65, 0x57, 0xf2, 0x3e, 0x5c, 0xde, 0xc1, 0x44,
0x08, 0xa0, 0xef, 0xb0, 0x77, 0x76, 0x08, 0x88, 0xc6, 0x52, 0x6e, 0x2c, 0x96, 0xfe, 0x9a, 0x93,
0xb1, 0xc4, 0x44, 0xb5, 0xed, 0x23, 0x07, 0x5d, 0x81, 0xb2, 0x24, 0x11, 0x5e, 0x11, 0x4c, 0xa0,
0xff, 0x87, 0x22, 0xd5, 0x94, 0xbb, 0x44, 0x7d, 0xe3, 0x5a, 0xf2, 0x9e, 0x42, 0x6b, 0x6a, 0x9c,
0x1e, 0xb5, 0xa1, 0xee, 0x11, 0xdd, 0x25, 0xdd, 0xa1, 0xe3, 0xb1, 0x73, 0x66, 0x8e, 0x53, 0xd9,
0x50, 0xa3, 0x2b, 0x48, 0x88, 0xdc, 0xf3, 0xfa, 0xfb, 0x82, 0x52, 0xab, 0x31, 0x4e, 0x7f, 0x88,
0x3e, 0x81, 0x2a, 0xb6, 0x8d, 0x60, 0xa1, 0x42, 0xe6, 0x85, 0x2a, 0xd8, 0x36, 0xe4, 0x32, 0xc1,
0xf9, 0x14, 0xb3, 0x9f, 0xcf, 0xaf, 0x14, 0x68, 0x8e, 0x1f, 0xd0, 0x79, 0x80, 0xf2, 0x7d, 0xce,
0x84, 0xf9, 0x01, 0x4d, 0x8c, 0x70, 0x79, 0x48, 0x9a, 0x60, 0x51, 0x4d, 0x78, 0x21, 0xd0, 0x86,
0xbd, 0x79, 0x6a, 0xce, 0xf2, 0xb5, 0x02, 0x4b, 0x71, 0x59, 0xe7, 0xd9, 0xf7, 0xff, 0x41, 0xd1,
0xb4, 0x8f, 0x1c, 0x7f, 0xdb, 0xcb, 0x13, 0xe2, 0x8c, 0xca, 0xe2, 0xc4, 0xaa, 0x05, 0x2f, 0xed,
0x60, 0xd2, 0xb6, 0x3d, 0xec, 0x92, 0x4d, 0xd3, 0x1e, 0x38, 0xfd, 0x7d, 0x9d, 0x1c, 0x9f, 0x23,
0x46, 0x22, 0xee, 0x9e, 0x8b, 0xb9, 0xbb, 0xfa, 0x67, 0x05, 0xae, 0x24, 0xcb, 0x13, 0x5b, 0x6f,
0x41, 0xe9, 0xc8, 0xc4, 0x03, 0x83, 0xda, 0x4c, 0x61, 0x36, 0x93, 0x63, 0x1a, 0x2b, 0x43, 0x4a,
0x2c, 0x76, 0x78, 0x2d, 0xc5, 0x41, 0x3b, 0xc4, 0x35, 0xed, 0xfe, 0xae, 0xe9, 0x11, 0x8d, 0xd3,
0x87, 0xec, 0x99, 0xcf, 0xee, 0x99, 0xbf, 0x54, 0x60, 0x79, 0x07, 0x93, 0xdb, 0x12, 0x6a, 0xe9,
0x7b, 0xd3, 0x23, 0x66, 0xcf, 0x7b, 0xba, 0x45, 0x44, 0x42, 0xce, 0x54, 0xbf, 0x51, 0xe0, 0x6a,
0xaa, 0x32, 0xc2, 0x74, 0x02, 0x4a, 0x7c, 0xa0, 0x4d, 0x86, 0x92, 0x1f, 0xe0, 0xd3, 0xbb, 0xfa,
0x60, 0x84, 0xf7, 0x75, 0xd3, 0xe5, 0x50, 0x72, 0x46, 0x60, 0xfd, 0x8b, 0x02, 0x2f, 0xef, 0x60,
0xb2, 0xef, 0xa7, 0x99, 0xe7, 0x68, 0x9d, 0x0c, 0x15, 0xc5, 0x6f, 0xf8, 0x61, 0x26, 0x6a, 0xfb,
0x5c, 0xcc, 0xb7, 0xcc, 0xe2, 0x20, 0x14, 0x90, 0xb7, 0x79, 0x2d, 0x20, 0x8c, 0xa7, 0x3e, 0xce,
0x43, 0xf5, 0xae, 0xa8, 0x0f, 0x58, 0x1a, 0x89, 0xdb, 0x41, 0x49, 0xb6, 0x43, 0xa8, 0xa4, 0x48,
0xaa, 0x32, 0x76, 0xa0, 0xe6, 0x61, 0x7c, 0xff, 0x2c, 0x49, 0xa3, 0x4a, 0x19, 0x25, 0xd8, 0xef,
0xc2, 0xc5, 0x91, 0x7d, 0x44, 0xcb, 0x5a, 0x6c, 0x88, 0x5d, 0xf0, 0xea, 0x72, 0x3a, 0xf2, 0x8c,
0x33, 0xa2, 0x4f, 0x61, 0x21, 0xbe, 0x56, 0x31, 0xd3, 0x5a, 0x71, 0x36, 0xd4, 0x86, 0x86, 0xe1,
0x3a, 0xc3, 0x21, 0x36, 0xba, 0x9e, 0xbf, 0xd4, 0x5c, 0xb6, 0xa5, 0x04, 0x9f, 0xbf, 0x94, 0xfa,
0x0b, 0x05, 0x96, 0xee, 0xe9, 0xa4, 0x77, 0xbc, 0x65, 0x89, 0xc3, 0x39, 0x87, 0x6b, 0x7f, 0x08,
0xe5, 0x13, 0x71, 0x10, 0x3e, 0x7e, 0x5d, 0x4d, 0x50, 0x28, 0x7c, 0xe4, 0x5a, 0xc0, 0xa1, 0xfe,
0x43, 0x81, 0x4b, 0xac, 0x89, 0xf0, 0xb5, 0x7b, 0xf6, 0x41, 0x36, 0xa5, 0x91, 0x40, 0xd7, 0xa1,
0x6e, 0xe9, 0xee, 0xfd, 0x4e, 0x40, 0x53, 0x64, 0x34, 0xb1, 0x59, 0xf5, 0x11, 0x80, 0x18, 0xed,
0x79, 0xfd, 0x33, 0xe8, 0xff, 0x1e, 0xcc, 0x0b, 0xa9, 0x22, 0xde, 0xa6, 0x1d, 0xac, 0x4f, 0xae,
0xfe, 0x53, 0x81, 0x7a, 0x80, 0xa0, 0x2c, 0xaa, 0xea, 0x90, 0x93, 0xb1, 0x94, 0x6b, 0x6f, 0xa1,
0x0f, 0x61, 0x8e, 0xb7, 0x8d, 0x62, 0xed, 0xd7, 0xa2, 0x6b, 0x8b, 0x96, 0x32, 0x04, 0xc3, 0x6c,
0x42, 0x13, 0x4c, 0xd4, 0x46, 0x12, 0x75, 0x78, 0x87, 0x91, 0xd7, 0x42, 0x33, 0xa8, 0x0d, 0x0b,
0xd1, 0xa2, 0xcd, 0x8f, 0x99, 0x95, 0x34, 0xb4, 0xd9, 0xd2, 0x89, 0xce, 0xc0, 0xa6, 0x1e, 0xa9,
0xd9, 0x3c, 0xf5, 0xbf, 0x45, 0xa8, 0x84, 0x76, 0x39, 0xb6, 0x93, 0xf8, 0x91, 0xe6, 0xa6, 0xe3,
0x66, 0x7e, 0xbc, 0x73, 0x78, 0x0d, 0xea, 0x26, 0xcb, 0xd5, 0x5d, 0xe1, 0x8a, 0x0c, 0x5c, 0xcb,
0x5a, 0x8d, 0xcf, 0x8a, 0xb8, 0x40, 0xcb, 0x50, 0xb1, 0x47, 0x56, 0xd7, 0x39, 0xea, 0xba, 0xce,
0x43, 0x4f, 0xb4, 0x20, 0x65, 0x7b, 0x64, 0xfd, 0xf0, 0x48, 0x73, 0x1e, 0x7a, 0x41, 0x95, 0x3b,
0x37, 0x63, 0x95, 0xbb, 0x0c, 0x15, 0x4b, 0x7f, 0x44, 0x57, 0xed, 0xda, 0x23, 0x8b, 0x75, 0x27,
0x79, 0xad, 0x6c, 0xe9, 0x8f, 0x34, 0xe7, 0xe1, 0x9d, 0x91, 0x85, 0x56, 0xa1, 0x31, 0xd0, 0x3d,
0xd2, 0x0d, 0xb7, 0x37, 0x25, 0xd6, 0xde, 0xd4, 0xe9, 0xfc, 0x27, 0x41, 0x8b, 0x33, 0x5e, 0x2f,
0x97, 0xcf, 0x51, 0x2f, 0x1b, 0xd6, 0x20, 0x58, 0x08, 0xb2, 0xd7, 0xcb, 0x86, 0x35, 0x90, 0xcb,
0xbc, 0x07, 0xf3, 0x87, 0xac, 0x02, 0xf2, 0x9a, 0x95, 0x54, 0x84, 0xda, 0xa6, 0xc5, 0x0f, 0x2f,
0x94, 0x34, 0x9f, 0x1c, 0x7d, 0x00, 0x65, 0x96, 0x7a, 0x18, 0x6f, 0x35, 0x13, 0x6f, 0xc0, 0x40,
0xa1, 0xc8, 0xc0, 0x03, 0xa2, 0x33, 0xee, 0x5a, 0x2a, 0x14, 0x6d, 0x51, 0x9a, 0x5d, 0xa7, 0xcf,
0xa1, 0x48, 0x72, 0xa0, 0xb7, 0x61, 0xb1, 0xe7, 0x62, 0x9d, 0x60, 0x63, 0xf3, 0xf4, 0xb6, 0x63,
0x0d, 0x75, 0xe6, 0x4d, 0xcd, 0xfa, 0x8a, 0xb2, 0x5a, 0xd2, 0x92, 0x5e, 0x51, 0x64, 0xe8, 0xc9,
0xd1, 0xb6, 0xeb, 0x58, 0xcd, 0x05, 0x8e, 0x0c, 0xd1, 0x59, 0xf4, 0x32, 0x80, 0x8f, 0xdd, 0x3a,
0x69, 0x36, 0xd8, 0x31, 0x96, 0xc5, 0xcc, 0xc7, 0x44, 0xfd, 0x0a, 0x2e, 0x05, 0x2e, 0x12, 0x3a,
0x8e, 0xf1, 0x93, 0x55, 0xce, 0x7a, 0xb2, 0x93, 0x8b, 0xd7, 0xbf, 0x15, 0x60, 0xa9, 0xa3, 0x9f,
0xe0, 0xa7, 0x5f, 0x27, 0x67, 0x02, 0xe4, 0x5d, 0xb8, 0xc8, 0x4a, 0xe3, 0x8d, 0x90, 0x3e, 0x13,
0x52, 0x70, 0xd8, 0x1b, 0xc6, 0x19, 0xd1, 0x47, 0xb4, 0x76, 0xc0, 0xbd, 0xfb, 0xfb, 0x8e, 0x19,
0xa4, 0xdf, 0x97, 0x13, 0xd6, 0xb9, 0x2d, 0xa9, 0xb4, 0x30, 0x07, 0xda, 0x1f, 0xc7, 0x36, 0x9e,
0x78, 0x5f, 0x9f, 0xd8, 0x80, 0x05, 0xd6, 0x8f, 0x43, 0x1c, 0x6a, 0xc2, 0xbc, 0x48, 0xef, 0x2c,
0xf0, 0x4b, 0x9a, 0x3f, 0x44, 0xfb, 0xb0, 0xc8, 0x77, 0xd0, 0x11, 0x5e, 0xcd, 0x37, 0x5f, 0xca,
0xb4, 0xf9, 0x24, 0xd6, 0x68, 0x50, 0x94, 0x67, 0x0e, 0x8a, 0x26, 0xcc, 0x0b, 0x47, 0x65, 0x68,
0x50, 0xd2, 0xfc, 0x21, 0x6d, 0x23, 0x20, 0x30, 0xd9, 0x94, 0xdb, 0x80, 0xef, 0x43, 0x49, 0x3a,
0x71, 0x2e, 0xb3, 0x13, 0x4b, 0x9e, 0x38, 0x0e, 0xe7, 0x63, 0x38, 0xac, 0xfe, 0x4b, 0x81, 0x6a,
0x78, 0x0b, 0x14, 0xdf, 0x5d, 0xdc, 0x73, 0x5c, 0xa3, 0x8b, 0x6d, 0xe2, 0x9a, 0x98, 0x77, 0x9c,
0x05, 0xad, 0xc6, 0x67, 0x3f, 0xe1, 0x93, 0x94, 0x8c, 0x42, 0xab, 0x47, 0x74, 0x6b, 0xd8, 0x3d,
0xa2, 0x11, 0x9c, 0xe3, 0x64, 0x72, 0x96, 0x05, 0xf0, 0x35, 0xa8, 0x06, 0x64, 0xc4, 0x61, 0xf2,
0x0b, 0x5a, 0x45, 0xce, 0x1d, 0x38, 0xe8, 0x55, 0xa8, 0x33, 0xab, 0x75, 0x07, 0x4e, 0xbf, 0x4b,
0xbb, 0x33, 0x91, 0x50, 0xaa, 0x86, 0x50, 0x8b, 0x1e, 0x47, 0x94, 0xca, 0x33, 0xbf, 0xc4, 0x22,
0xa5, 0x48, 0xaa, 0x8e, 0xf9, 0x25, 0xa6, 0xf9, 0xbc, 0x46, 0xf3, 0xe3, 0x1d, 0xc7, 0xc0, 0x07,
0x67, 0xac, 0x26, 0x32, 0xdc, 0xcc, 0x5d, 0x81, 0xb2, 0xdc, 0x81, 0xd8, 0x52, 0x30, 0x81, 0xb6,
0xa1, 0xee, 0x17, 0x9a, 0x5d, 0xde, 0x3f, 0x14, 0x52, 0xbd, 0x27, 0x94, 0xe1, 0x3c, 0xad, 0xe6,
0xb3, 0xb1, 0xa1, 0xba, 0x0d, 0xd5, 0xf0, 0x6b, 0x2a, 0xb5, 0x13, 0x77, 0x14, 0x39, 0x41, 0xfd,
0xed, 0xce, 0xc8, 0xa2, 0x67, 0x2a, 0xb0, 0xc3, 0x1f, 0xaa, 0x5f, 0x2b, 0x50, 0x13, 0x69, 0xb9,
0x23, 0x6f, 0x8e, 0xd9, 0xd6, 0x14, 0xb6, 0x35, 0xf6, 0x8c, 0xbe, 0x17, 0xbd, 0x76, 0x7a, 0x35,
0x31, 0xce, 0xd9, 0x22, 0xac, 0x02, 0x8e, 0xe4, 0xe4, 0x2c, 0xfd, 0xea, 0x63, 0xea, 0x68, 0xe2,
0x68, 0x98, 0xa3, 0x35, 0x61, 0x5e, 0x37, 0x0c, 0x17, 0x7b, 0x9e, 0xd0, 0xc3, 0x1f, 0xd2, 0x37,
0x27, 0xd8, 0xf5, 0x7c, 0x97, 0xcf, 0x6b, 0xfe, 0x10, 0x7d, 0x00, 0x25, 0x59, 0x32, 0xe7, 0x93,
0xca, 0xa4, 0xb0, 0x9e, 0xa2, 0xbf, 0x92, 0x1c, 0xea, 0x37, 0x39, 0xa8, 0x0b, 0x83, 0x6d, 0x8a,
0xbc, 0x39, 0x39, 0xf8, 0x36, 0xa1, 0x7a, 0x14, 0xc0, 0xc4, 0xa4, 0x7b, 0x94, 0x30, 0x9a, 0x44,
0x78, 0xa6, 0x05, 0x60, 0x34, 0x73, 0x17, 0xce, 0x95, 0xb9, 0x8b, 0xb3, 0x82, 0x94, 0xfa, 0x31,
0x54, 0x42, 0x0b, 0x33, 0x78, 0xe5, 0x57, 0x2b, 0xc2, 0x16, 0xfe, 0x90, 0xbe, 0x39, 0x0c, 0x19,
0xa1, 0x2c, 0x2b, 0x0f, 0xda, 0x87, 0x5c, 0xde, 0xc1, 0x44, 0xc3, 0x3d, 0xe7, 0x04, 0xbb, 0xa7,
0xe7, 0xbf, 0xb5, 0x7a, 0x3f, 0x74, 0xc6, 0x19, 0xdb, 0x22, 0xc9, 0x80, 0xde, 0x0f, 0xf4, 0xcc,
0x27, 0x35, 0xed, 0xe1, 0xa0, 0x13, 0x27, 0x14, 0x6c, 0xe5, 0x5b, 0x7e, 0xff, 0x16, 0xdd, 0xca,
0x59, 0xb3, 0xf9, 0x13, 0xa9, 0xb6, 0xd5, 0xdf, 0x29, 0xf0, 0xe2, 0x0e, 0x26, 0xdb, 0xd1, 0x9e,
0xf6, 0x79, 0x6b, 0x65, 0x41, 0x2b, 0x49, 0xa9, 0xf3, 0x9c, 0x7a, 0x0b, 0x4a, 0xb2, 0x3b, 0xe7,
0x37, 0xa3, 0x72, 0xac, 0xfe, 0x5c, 0x81, 0xa6, 0x90, 0xc2, 0x64, 0xd2, 0x42, 0x72, 0x80, 0x09,
0x36, 0x9e, 0x75, 0xbb, 0xf8, 0x07, 0x05, 0x1a, 0x61, 0x10, 0x64, 0x38, 0xf6, 0x2e, 0x14, 0x59,
0x57, 0x2e, 0x34, 0x98, 0xea, 0xac, 0x9c, 0x9a, 0x46, 0x14, 0x2b, 0x6e, 0x0e, 0x24, 0x5e, 0x8b,
0x61, 0x80, 0xc4, 0xf9, 0x99, 0x91, 0x58, 0xfd, 0x75, 0x0e, 0x9a, 0x41, 0x9d, 0xfd, 0xcc, 0xc1,
0x2e, 0xa5, 0x0a, 0xcb, 0x3f, 0xa1, 0x2a, 0xac, 0x30, 0x33, 0xc0, 0xfd, 0x3d, 0x47, 0x1b, 0x7c,
0xdf, 0x1e, 0xfb, 0x03, 0xdd, 0x46, 0x4b, 0x30, 0x37, 0x1c, 0xe8, 0xc1, 0x85, 0x99, 0x18, 0xa1,
0x8e, 0x4c, 0xdb, 0x51, 0x0b, 0xbc, 0x99, 0x64, 0xff, 0x14, 0x13, 0x6b, 0xb1, 0x25, 0x68, 0x03,
0xc3, 0x4b, 0x60, 0xd6, 0x87, 0x8a, 0x52, 0x81, 0x1f, 0x34, 0x6d, 0x41, 0x6f, 0x02, 0xa2, 0x2f,
0x9c, 0x11, 0xe9, 0x9a, 0x76, 0xd7, 0xc3, 0x3d, 0xc7, 0x36, 0x3c, 0x56, 0xff, 0x14, 0xb5, 0x86,
0x78, 0xd3, 0xb6, 0x3b, 0x7c, 0x1e, 0xbd, 0x0b, 0x05, 0x72, 0x3a, 0xe4, 0x95, 0x4f, 0x3d, 0x11,
0xd9, 0x02, 0xbd, 0x0e, 0x4e, 0x87, 0x58, 0x63, 0xe4, 0x68, 0x19, 0x80, 0x2e, 0x45, 0x5c, 0xfd,
0x04, 0x0f, 0xfc, 0x4f, 0x7d, 0xc1, 0x0c, 0xf5, 0x44, 0xbf, 0x95, 0x9f, 0xe7, 0x89, 0x58, 0x0c,
0xd5, 0xef, 0x72, 0xd0, 0x08, 0x96, 0xd4, 0xb0, 0x37, 0x1a, 0x90, 0x54, 0xfb, 0x4d, 0x6e, 0x5f,
0xa6, 0xa5, 0xc1, 0x8f, 0xa0, 0x22, 0xae, 0x15, 0x66, 0x48, 0x84, 0xc0, 0x59, 0x76, 0x27, 0xb8,
0x5e, 0xf1, 0x09, 0xb9, 0xde, 0xdc, 0xcc, 0xae, 0xd7, 0x81, 0x25, 0x1f, 0xb4, 0x02, 0x49, 0x7b,
0x98, 0xe8, 0x13, 0xd2, 0xec, 0x55, 0xa8, 0xf0, 0x64, 0xc4, 0x0b, 0x61, 0x5e, 0x7a, 0xc2, 0xa1,
0x6c, 0xca, 0xd4, 0x9f, 0xc0, 0x25, 0x16, 0xf4, 0xf1, 0xeb, 0xc7, 0x2c, 0x77, 0xc1, 0xaa, 0x2c,
0x6c, 0x69, 0x11, 0xeb, 0x27, 0xf2, 0xc8, 0x9c, 0xba, 0x0b, 0x2f, 0xc4, 0xd6, 0x3f, 0x07, 0xa8,
0xab, 0xdf, 0x29, 0xf0, 0xe2, 0x96, 0xeb, 0x0c, 0xef, 0x9a, 0x2e, 0x19, 0xe9, 0x83, 0xe8, 0x85,
0xf6, 0xd3, 0x29, 0xcd, 0x3f, 0x0d, 0xe5, 0x11, 0x0e, 0x3b, 0x37, 0x93, 0xce, 0x6c, 0x4c, 0x29,
0x71, 0x54, 0xa1, 0xac, 0xf3, 0x9f, 0x7c, 0x92, 0xf2, 0x82, 0x6e, 0x0a, 0x96, 0x66, 0x49, 0xb3,
0x89, 0xcd, 0x7a, 0xfe, 0xac, 0xcd, 0x7a, 0x8a, 0xfb, 0x17, 0x9e, 0x90, 0xfb, 0xcf, 0x5c, 0x5a,
0xa2, 0x4f, 0x21, 0x7a, 0x93, 0xc2, 0x80, 0xe7, 0x4c, 0x57, 0x30, 0x9b, 0x00, 0xc1, 0xad, 0x82,
0xf8, 0x1d, 0x21, 0xcb, 0x32, 0x21, 0x2e, 0x7a, 0x5c, 0x12, 0x6b, 0xd8, 0x75, 0x60, 0xa4, 0x09,
0xfe, 0x0c, 0x5a, 0x49, 0x6e, 0x7a, 0x0e, 0xd7, 0xbf, 0x71, 0x0b, 0x2e, 0x8e, 0x25, 0x69, 0x54,
0x07, 0xf8, 0xdc, 0xee, 0x89, 0xea, 0xa5, 0x71, 0x01, 0x55, 0xa1, 0xe4, 0xd7, 0x32, 0x0d, 0xe5,
0x46, 0x27, 0x9c, 0xaa, 0x28, 0x7e, 0xa3, 0xcb, 0xb0, 0xf8, 0xb9, 0x6d, 0xe0, 0x23, 0xd3, 0xc6,
0x46, 0xf0, 0xaa, 0x71, 0x01, 0x2d, 0xc2, 0x42, 0xdb, 0xb6, 0xb1, 0x1b, 0x9a, 0x54, 0xe8, 0xe4,
0x1e, 0x76, 0xfb, 0x38, 0x34, 0x99, 0xdb, 0xf8, 0x76, 0x11, 0xca, 0xb4, 0xed, 0xba, 0xed, 0x38,
0xae, 0x81, 0x86, 0x80, 0xd8, 0x37, 0x43, 0x6b, 0xe8, 0xd8, 0xf2, 0xe3, 0x3a, 0x7a, 0x3b, 0xc5,
0x98, 0xe3, 0xa4, 0x22, 0x74, 0x5b, 0xd7, 0x53, 0x38, 0x62, 0xe4, 0xea, 0x05, 0x64, 0x31, 0x89,
0x34, 0xd9, 0x1d, 0x98, 0xbd, 0xfb, 0xfe, 0xed, 0xf0, 0x04, 0x89, 0x31, 0x52, 0x5f, 0x62, 0xec,
0x9b, 0xbd, 0x18, 0xf0, 0x0f, 0xbb, 0xfe, 0x49, 0xa9, 0x17, 0xd0, 0x03, 0xb8, 0xb4, 0x83, 0x49,
0xf0, 0x2d, 0xcf, 0x17, 0xb8, 0x91, 0x2e, 0x70, 0x8c, 0x78, 0x46, 0x91, 0xbb, 0x50, 0x64, 0x55,
0x29, 0x4a, 0x8a, 0x8e, 0xf0, 0x1f, 0x66, 0xad, 0x95, 0x74, 0x02, 0xb9, 0xda, 0x4f, 0x61, 0x21,
0xf6, 0x07, 0x0d, 0x7a, 0x23, 0x81, 0x2d, 0xf9, 0x5f, 0xa8, 0xd6, 0x8d, 0x2c, 0xa4, 0x52, 0x56,
0x1f, 0xea, 0xd1, 0x2f, 0x8e, 0x68, 0x35, 0x81, 0x3f, 0xf1, 0xef, 0x87, 0xd6, 0x1b, 0x19, 0x28,
0xa5, 0x20, 0x0b, 0x1a, 0xf1, 0x3f, 0x3a, 0xd0, 0x8d, 0x89, 0x0b, 0x44, 0xdd, 0xed, 0xcd, 0x4c,
0xb4, 0x52, 0xdc, 0x29, 0x73, 0x82, 0xb1, 0x3f, 0x0a, 0xd0, 0x5a, 0xf2, 0x32, 0x69, 0xbf, 0x3a,
0xb4, 0xd6, 0x33, 0xd3, 0x4b, 0xd1, 0x3f, 0xe3, 0xdd, 0x70, 0xd2, 0x57, 0x79, 0x74, 0x2b, 0x79,
0xb9, 0x09, 0xbf, 0x13, 0xb4, 0x36, 0x66, 0x61, 0x91, 0x4a, 0x7c, 0xc5, 0xda, 0xd8, 0x84, 0x2f,
0xdb, 0xf1, 0xb8, 0xf3, 0xd7, 0x4b, 0xff, 0x64, 0xdf, 0xba, 0x35, 0x03, 0x87, 0x54, 0xc0, 0x89,
0xff, 0x33, 0xe3, 0x87, 0xe1, 0xfa, 0x54, 0xaf, 0x39, 0x5b, 0x0c, 0x7e, 0x01, 0x0b, 0xb1, 0x6b,
0xf8, 0xc4, 0xa8, 0x49, 0xbe, 0xaa, 0x6f, 0x4d, 0x02, 0x74, 0x1e, 0x92, 0xb1, 0x5b, 0x01, 0x94,
0xe2, 0xfd, 0x09, 0x37, 0x07, 0xad, 0x1b, 0x59, 0x48, 0xe5, 0x46, 0x3c, 0x06, 0x97, 0xb1, 0xce,
0x1a, 0xdd, 0x4c, 0x5e, 0x23, 0xf9, 0x56, 0xa0, 0xf5, 0x56, 0x46, 0x6a, 0x29, 0xb4, 0x0b, 0xb0,
0x83, 0xc9, 0x1e, 0x26, 0x2e, 0xf5, 0x91, 0xeb, 0x89, 0x26, 0x0f, 0x08, 0x7c, 0x31, 0xaf, 0x4f,
0xa5, 0x93, 0x02, 0x7e, 0x04, 0xc8, 0xcf, 0x73, 0xa1, 0x8f, 0x40, 0xaf, 0x4c, 0x6c, 0x60, 0x78,
0xb7, 0x31, 0xed, 0x6c, 0x1e, 0x40, 0x63, 0x4f, 0xb7, 0x69, 0xd2, 0x0e, 0xd6, 0xbd, 0x99, 0xa8,
0x58, 0x9c, 0x2c, 0xc5, 0x5a, 0xa9, 0xd4, 0x72, 0x33, 0x0f, 0x65, 0x0e, 0xd5, 0x65, 0x08, 0xe2,
0x38, 0xb6, 0x04, 0xd6, 0x88, 0x11, 0xa6, 0x60, 0xcb, 0x04, 0x7a, 0x29, 0xf8, 0xb1, 0xc2, 0xfe,
0xcc, 0x8a, 0x11, 0xdc, 0x33, 0xc9, 0x31, 0xed, 0x6b, 0xbd, 0x2c, 0x2a, 0x30, 0xc2, 0x19, 0x54,
0x10, 0xf4, 0x52, 0x05, 0x03, 0x6a, 0x91, 0xf6, 0x00, 0x25, 0x7d, 0xc9, 0x49, 0x6a, 0x50, 0x5a,
0xab, 0xd3, 0x09, 0xa5, 0x94, 0x63, 0xa8, 0xf9, 0xfe, 0xca, 0x8d, 0xfb, 0x46, 0x9a, 0xa6, 0x01,
0x4d, 0x4a, 0xb8, 0x25, 0x93, 0x86, 0xc3, 0x6d, 0xbc, 0xf0, 0x43, 0xd9, 0x3a, 0x86, 0x49, 0xe1,
0x96, 0x5e, 0x4d, 0xaa, 0x17, 0x36, 0xfe, 0x5d, 0x80, 0x92, 0x7f, 0x13, 0xfe, 0x1c, 0x2a, 0xb2,
0xe7, 0x50, 0x22, 0x7d, 0x01, 0x0b, 0xb1, 0xdf, 0x66, 0x12, 0x11, 0x34, 0xf9, 0xd7, 0x9a, 0x69,
0x10, 0x70, 0x4f, 0xfc, 0x4c, 0x2f, 0xd1, 0xf2, 0xf5, 0xb4, 0x32, 0x2b, 0x0e, 0x94, 0x53, 0x16,
0x7e, 0xea, 0xb0, 0x78, 0x07, 0x20, 0x04, 0x5b, 0x93, 0xef, 0x73, 0x68, 0x24, 0x4e, 0x51, 0x78,
0xf3, 0x9d, 0x1f, 0xdf, 0xea, 0x9b, 0xe4, 0x78, 0x74, 0x48, 0xdf, 0xac, 0x73, 0xd2, 0xb7, 0x4c,
0x47, 0x3c, 0xad, 0xfb, 0x27, 0xba, 0xce, 0xb8, 0xd7, 0xa9, 0x80, 0xe1, 0xe1, 0xe1, 0x1c, 0x1b,
0xbd, 0xf3, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x14, 0x2c, 0xc2, 0xf3, 0x6e, 0x31, 0x00, 0x00,
// 2842 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5b, 0xdd, 0x6f, 0x1b, 0xc7,
0x11, 0xf7, 0xf1, 0x43, 0x22, 0x87, 0x1f, 0xa2, 0x57, 0x8e, 0x42, 0x33, 0x8e, 0x2c, 0x5f, 0x12,
0x47, 0x76, 0x1c, 0xc9, 0x96, 0x1b, 0x34, 0xa8, 0x93, 0x06, 0x91, 0x65, 0xc9, 0x44, 0x25, 0x57,
0x39, 0x2a, 0x76, 0xd1, 0x14, 0x25, 0x4e, 0xbc, 0x15, 0x75, 0x35, 0xef, 0x8e, 0xbe, 0x5b, 0xca,
0x56, 0x5e, 0x62, 0x34, 0x40, 0x81, 0x16, 0x41, 0x9a, 0xa2, 0xaf, 0x05, 0x5a, 0xf4, 0xa9, 0x45,
0x5f, 0xda, 0xc7, 0xb6, 0xff, 0x40, 0xd0, 0xbe, 0xf7, 0x5f, 0xe8, 0x5b, 0xff, 0x86, 0x62, 0x3f,
0x6e, 0xef, 0x83, 0x47, 0xf2, 0x28, 0xf9, 0xe3, 0x4d, 0xbb, 0x37, 0xb3, 0x33, 0x3b, 0x3b, 0xf3,
0x9b, 0x99, 0xe5, 0x0a, 0x6a, 0x86, 0x4e, 0xf4, 0x76, 0xc7, 0x71, 0x5c, 0x63, 0xa5, 0xef, 0x3a,
0xc4, 0x41, 0x67, 0x2d, 0xb3, 0x77, 0x34, 0xf0, 0xf8, 0x68, 0x85, 0x7e, 0x6e, 0x94, 0x3b, 0x8e,
0x65, 0x39, 0x36, 0x9f, 0x6a, 0x54, 0x4d, 0x9b, 0x60, 0xd7, 0xd6, 0x7b, 0x62, 0x5c, 0x0e, 0x33,
0x34, 0xca, 0x5e, 0xe7, 0x10, 0x5b, 0x3a, 0x1f, 0xa9, 0x4f, 0xa0, 0xbc, 0xd9, 0x1b, 0x78, 0x87,
0x1a, 0x7e, 0x34, 0xc0, 0x1e, 0x41, 0xd7, 0x21, 0xb7, 0xaf, 0x7b, 0xb8, 0xae, 0x2c, 0x29, 0xcb,
0xa5, 0xb5, 0x0b, 0x2b, 0x11, 0x59, 0x42, 0xca, 0x8e, 0xd7, 0x5d, 0xd7, 0x3d, 0xac, 0x31, 0x4a,
0x84, 0x20, 0x67, 0xec, 0x37, 0x37, 0xea, 0x99, 0x25, 0x65, 0x39, 0xab, 0xb1, 0xbf, 0x91, 0x0a,
0xe5, 0x8e, 0xd3, 0xeb, 0xe1, 0x0e, 0x31, 0x1d, 0xbb, 0xb9, 0x51, 0xcf, 0xb1, 0x6f, 0x91, 0x39,
0xf5, 0x77, 0x0a, 0x54, 0x84, 0x68, 0xaf, 0xef, 0xd8, 0x1e, 0x46, 0x37, 0x61, 0xc6, 0x23, 0x3a,
0x19, 0x78, 0x42, 0xfa, 0x6b, 0x89, 0xd2, 0x5b, 0x8c, 0x44, 0x13, 0xa4, 0xa9, 0xc4, 0x67, 0x87,
0xc5, 0xa3, 0x45, 0x00, 0x0f, 0x77, 0x2d, 0x6c, 0x93, 0xe6, 0x86, 0x57, 0xcf, 0x2d, 0x65, 0x97,
0xb3, 0x5a, 0x68, 0x46, 0xfd, 0x8d, 0x02, 0xb5, 0x96, 0x3f, 0xf4, 0xad, 0x73, 0x0e, 0xf2, 0x1d,
0x67, 0x60, 0x13, 0xa6, 0x60, 0x45, 0xe3, 0x03, 0x74, 0x09, 0xca, 0x9d, 0x43, 0xdd, 0xb6, 0x71,
0xaf, 0x6d, 0xeb, 0x16, 0x66, 0xaa, 0x14, 0xb5, 0x92, 0x98, 0xbb, 0xa7, 0x5b, 0x38, 0x95, 0x46,
0x4b, 0x50, 0xea, 0xeb, 0x2e, 0x31, 0x23, 0x36, 0x0b, 0x4f, 0xa9, 0x7f, 0x50, 0x60, 0xe1, 0x63,
0xcf, 0x33, 0xbb, 0xf6, 0x90, 0x66, 0x0b, 0x30, 0x63, 0x3b, 0x06, 0x6e, 0x6e, 0x30, 0xd5, 0xb2,
0x9a, 0x18, 0xa1, 0xd7, 0xa0, 0xd8, 0xc7, 0xd8, 0x6d, 0xbb, 0x4e, 0xcf, 0x57, 0xac, 0x40, 0x27,
0x34, 0xa7, 0x87, 0xd1, 0x27, 0x70, 0xd6, 0x8b, 0x2d, 0xe4, 0xd5, 0xb3, 0x4b, 0xd9, 0xe5, 0xd2,
0xda, 0x1b, 0x2b, 0x43, 0x5e, 0xb6, 0x12, 0x17, 0xaa, 0x0d, 0x73, 0xab, 0x4f, 0x33, 0x30, 0x2f,
0xe9, 0xb8, 0xae, 0xf4, 0x6f, 0x6a, 0x39, 0x0f, 0x77, 0xa5, 0x7a, 0x7c, 0x90, 0xc6, 0x72, 0xd2,
0xe4, 0xd9, 0xb0, 0xc9, 0x53, 0x38, 0x58, 0xdc, 0x9e, 0xf9, 0x21, 0x7b, 0xa2, 0x8b, 0x50, 0xc2,
0x4f, 0xfa, 0xa6, 0x8b, 0xdb, 0xc4, 0xb4, 0x70, 0x7d, 0x66, 0x49, 0x59, 0xce, 0x69, 0xc0, 0xa7,
0xf6, 0x4c, 0x2b, 0xec, 0x91, 0xb3, 0xa9, 0x3d, 0x52, 0xfd, 0xa3, 0x02, 0xaf, 0x0e, 0x9d, 0x92,
0x70, 0x71, 0x0d, 0x6a, 0x6c, 0xe7, 0x81, 0x65, 0xa8, 0xb3, 0x53, 0x83, 0x5f, 0x1e, 0x67, 0xf0,
0x80, 0x5c, 0x1b, 0xe2, 0x0f, 0x29, 0x99, 0x49, 0xaf, 0xe4, 0x43, 0x78, 0x75, 0x0b, 0x13, 0x21,
0x80, 0x7e, 0xc3, 0xde, 0xc9, 0x21, 0x20, 0x1a, 0x4b, 0x99, 0xa1, 0x58, 0xfa, 0x6b, 0x46, 0xc6,
0x12, 0x13, 0xd5, 0xb4, 0x0f, 0x1c, 0x74, 0x01, 0x8a, 0x92, 0x44, 0x78, 0x45, 0x30, 0x81, 0xbe,
0x0b, 0x79, 0xaa, 0x29, 0x77, 0x89, 0xea, 0xda, 0xa5, 0xe4, 0x3d, 0x85, 0xd6, 0xd4, 0x38, 0x3d,
0x6a, 0x42, 0xd5, 0x23, 0xba, 0x4b, 0xda, 0x7d, 0xc7, 0x63, 0xe7, 0xcc, 0x1c, 0xa7, 0xb4, 0xa6,
0x46, 0x57, 0x90, 0x10, 0xb9, 0xe3, 0x75, 0x77, 0x05, 0xa5, 0x56, 0x61, 0x9c, 0xfe, 0x10, 0xdd,
0x81, 0x32, 0xb6, 0x8d, 0x60, 0xa1, 0x5c, 0xea, 0x85, 0x4a, 0xd8, 0x36, 0xe4, 0x32, 0xc1, 0xf9,
0xe4, 0xd3, 0x9f, 0xcf, 0x57, 0x0a, 0xd4, 0x87, 0x0f, 0xe8, 0x34, 0x40, 0x79, 0x8b, 0x33, 0x61,
0x7e, 0x40, 0x63, 0x23, 0x5c, 0x1e, 0x92, 0x26, 0x58, 0x54, 0x13, 0x5e, 0x09, 0xb4, 0x61, 0x5f,
0x9e, 0x9b, 0xb3, 0x7c, 0xa9, 0xc0, 0x42, 0x5c, 0xd6, 0x69, 0xf6, 0xfd, 0x1d, 0xc8, 0x9b, 0xf6,
0x81, 0xe3, 0x6f, 0x7b, 0x71, 0x4c, 0x9c, 0x51, 0x59, 0x9c, 0x58, 0xb5, 0xe0, 0xb5, 0x2d, 0x4c,
0x9a, 0xb6, 0x87, 0x5d, 0xb2, 0x6e, 0xda, 0x3d, 0xa7, 0xbb, 0xab, 0x93, 0xc3, 0x53, 0xc4, 0x48,
0xc4, 0xdd, 0x33, 0x31, 0x77, 0x57, 0xff, 0xa4, 0xc0, 0x85, 0x64, 0x79, 0x62, 0xeb, 0x0d, 0x28,
0x1c, 0x98, 0xb8, 0x67, 0x50, 0x9b, 0x29, 0xcc, 0x66, 0x72, 0x4c, 0x63, 0xa5, 0x4f, 0x89, 0xc5,
0x0e, 0x2f, 0x8d, 0x70, 0xd0, 0x16, 0x71, 0x4d, 0xbb, 0xbb, 0x6d, 0x7a, 0x44, 0xe3, 0xf4, 0x21,
0x7b, 0x66, 0xd3, 0x7b, 0xe6, 0xaf, 0x14, 0x58, 0xdc, 0xc2, 0xe4, 0xb6, 0x84, 0x5a, 0xfa, 0xdd,
0xf4, 0x88, 0xd9, 0xf1, 0x9e, 0x6f, 0x11, 0x91, 0x90, 0x33, 0xd5, 0x5f, 0x2b, 0x70, 0x71, 0xa4,
0x32, 0xc2, 0x74, 0x02, 0x4a, 0x7c, 0xa0, 0x4d, 0x86, 0x92, 0x1f, 0xe0, 0xe3, 0xfb, 0x7a, 0x6f,
0x80, 0x77, 0x75, 0xd3, 0xe5, 0x50, 0x72, 0x42, 0x60, 0xfd, 0x8b, 0x02, 0xaf, 0x6f, 0x61, 0xb2,
0xeb, 0xa7, 0x99, 0x97, 0x68, 0x9d, 0x14, 0x15, 0xc5, 0xd7, 0xfc, 0x30, 0x13, 0xb5, 0x7d, 0x29,
0xe6, 0x5b, 0x64, 0x71, 0x10, 0x0a, 0xc8, 0xdb, 0xbc, 0x16, 0x10, 0xc6, 0x53, 0x9f, 0x66, 0xa1,
0x7c, 0x5f, 0xd4, 0x07, 0x2c, 0x8d, 0xc4, 0xed, 0xa0, 0x24, 0xdb, 0x21, 0x54, 0x52, 0x24, 0x55,
0x19, 0x5b, 0x50, 0xf1, 0x30, 0x7e, 0x78, 0x92, 0xa4, 0x51, 0xa6, 0x8c, 0x12, 0xec, 0xb7, 0xe1,
0xec, 0xc0, 0x3e, 0xa0, 0x65, 0x2d, 0x36, 0xc4, 0x2e, 0x78, 0x75, 0x39, 0x19, 0x79, 0x86, 0x19,
0xd1, 0x5d, 0x98, 0x8b, 0xaf, 0x95, 0x4f, 0xb5, 0x56, 0x9c, 0x0d, 0x35, 0xa1, 0x66, 0xb8, 0x4e,
0xbf, 0x8f, 0x8d, 0xb6, 0xe7, 0x2f, 0x35, 0x93, 0x6e, 0x29, 0xc1, 0xe7, 0x2f, 0xa5, 0xfe, 0x52,
0x81, 0x85, 0x07, 0x3a, 0xe9, 0x1c, 0x6e, 0x58, 0xe2, 0x70, 0x4e, 0xe1, 0xda, 0x1f, 0x42, 0xf1,
0x48, 0x1c, 0x84, 0x8f, 0x5f, 0x17, 0x13, 0x14, 0x0a, 0x1f, 0xb9, 0x16, 0x70, 0xa8, 0xdf, 0x2a,
0x70, 0x8e, 0x35, 0x11, 0xbe, 0x76, 0x2f, 0x3e, 0xc8, 0x26, 0x34, 0x12, 0xe8, 0x32, 0x54, 0x2d,
0xdd, 0x7d, 0xd8, 0x0a, 0x68, 0xf2, 0x8c, 0x26, 0x36, 0xab, 0x3e, 0x01, 0x10, 0xa3, 0x1d, 0xaf,
0x7b, 0x02, 0xfd, 0xdf, 0x87, 0x59, 0x21, 0x55, 0xc4, 0xdb, 0xa4, 0x83, 0xf5, 0xc9, 0xd5, 0x7f,
0x29, 0x50, 0x0d, 0x10, 0x94, 0x45, 0x55, 0x15, 0x32, 0x32, 0x96, 0x32, 0xcd, 0x0d, 0xf4, 0x21,
0xcc, 0xf0, 0xb6, 0x51, 0xac, 0xfd, 0x56, 0x74, 0x6d, 0xd1, 0x52, 0x86, 0x60, 0x98, 0x4d, 0x68,
0x82, 0x89, 0xda, 0x48, 0xa2, 0x0e, 0xef, 0x30, 0xb2, 0x5a, 0x68, 0x06, 0x35, 0x61, 0x2e, 0x5a,
0xb4, 0xf9, 0x31, 0xb3, 0x34, 0x0a, 0x6d, 0x36, 0x74, 0xa2, 0x33, 0xb0, 0xa9, 0x46, 0x6a, 0x36,
0x4f, 0xfd, 0x5f, 0x1e, 0x4a, 0xa1, 0x5d, 0x0e, 0xed, 0x24, 0x7e, 0xa4, 0x99, 0xc9, 0xb8, 0x99,
0x1d, 0xee, 0x1c, 0xde, 0x82, 0xaa, 0xc9, 0x72, 0x75, 0x5b, 0xb8, 0x22, 0x03, 0xd7, 0xa2, 0x56,
0xe1, 0xb3, 0x22, 0x2e, 0xd0, 0x22, 0x94, 0xec, 0x81, 0xd5, 0x76, 0x0e, 0xda, 0xae, 0xf3, 0xd8,
0x13, 0x2d, 0x48, 0xd1, 0x1e, 0x58, 0x3f, 0x3c, 0xd0, 0x9c, 0xc7, 0x5e, 0x50, 0xe5, 0xce, 0x4c,
0x59, 0xe5, 0x2e, 0x42, 0xc9, 0xd2, 0x9f, 0xd0, 0x55, 0xdb, 0xf6, 0xc0, 0x62, 0xdd, 0x49, 0x56,
0x2b, 0x5a, 0xfa, 0x13, 0xcd, 0x79, 0x7c, 0x6f, 0x60, 0xa1, 0x65, 0xa8, 0xf5, 0x74, 0x8f, 0xb4,
0xc3, 0xed, 0x4d, 0x81, 0xb5, 0x37, 0x55, 0x3a, 0x7f, 0x27, 0x68, 0x71, 0x86, 0xeb, 0xe5, 0xe2,
0x29, 0xea, 0x65, 0xc3, 0xea, 0x05, 0x0b, 0x41, 0xfa, 0x7a, 0xd9, 0xb0, 0x7a, 0x72, 0x99, 0xf7,
0x61, 0x76, 0x9f, 0x55, 0x40, 0x5e, 0xbd, 0x34, 0x12, 0xa1, 0x36, 0x69, 0xf1, 0xc3, 0x0b, 0x25,
0xcd, 0x27, 0x47, 0x1f, 0x40, 0x91, 0xa5, 0x1e, 0xc6, 0x5b, 0x4e, 0xc5, 0x1b, 0x30, 0x50, 0x6e,
0x03, 0xf7, 0x88, 0xce, 0xb8, 0x2b, 0xe9, 0xb8, 0x25, 0x03, 0xba, 0x0e, 0xf3, 0x1d, 0x17, 0xeb,
0x04, 0x1b, 0xeb, 0xc7, 0xb7, 0x1d, 0xab, 0xaf, 0x33, 0x67, 0xaa, 0x57, 0x97, 0x94, 0xe5, 0x82,
0x96, 0xf4, 0x89, 0x02, 0x43, 0x47, 0x8e, 0x36, 0x5d, 0xc7, 0xaa, 0xcf, 0x71, 0x60, 0x88, 0xce,
0xa2, 0xd7, 0x01, 0x7c, 0xe8, 0xd6, 0x49, 0xbd, 0xc6, 0x4e, 0xb1, 0x28, 0x66, 0x3e, 0x26, 0xea,
0x17, 0x70, 0x2e, 0xf0, 0x90, 0xd0, 0x69, 0x0c, 0x1f, 0xac, 0x72, 0xd2, 0x83, 0x1d, 0x5f, 0xbb,
0xfe, 0x2d, 0x07, 0x0b, 0x2d, 0xfd, 0x08, 0x3f, 0xff, 0x32, 0x39, 0x15, 0x1e, 0x6f, 0xc3, 0x59,
0x56, 0x19, 0xaf, 0x85, 0xf4, 0x19, 0x93, 0x81, 0xc3, 0xc7, 0x39, 0xcc, 0x88, 0x3e, 0xa2, 0xa5,
0x03, 0xee, 0x3c, 0xdc, 0x75, 0xcc, 0x20, 0xfb, 0xbe, 0x9e, 0xb0, 0xce, 0x6d, 0x49, 0xa5, 0x85,
0x39, 0xd0, 0xee, 0x30, 0xb4, 0xf1, 0xbc, 0xfb, 0xf6, 0xd8, 0xfe, 0x2b, 0xb0, 0x7e, 0x1c, 0xe1,
0x50, 0x1d, 0x66, 0x45, 0x76, 0x67, 0x71, 0x5f, 0xd0, 0xfc, 0x21, 0xda, 0x85, 0x79, 0xbe, 0x83,
0x96, 0x70, 0x6a, 0xbe, 0xf9, 0x42, 0xaa, 0xcd, 0x27, 0xb1, 0x46, 0x63, 0xa2, 0x38, 0x6d, 0x4c,
0xd4, 0x61, 0x56, 0xf8, 0x29, 0xc3, 0x82, 0x82, 0xe6, 0x0f, 0x69, 0x13, 0x01, 0x81, 0xc5, 0x26,
0xdc, 0x05, 0x7c, 0x1f, 0x0a, 0xd2, 0x87, 0x33, 0xa9, 0x7d, 0x58, 0xf2, 0xc4, 0x51, 0x38, 0x1b,
0x43, 0x61, 0xf5, 0xdf, 0x0a, 0x94, 0x37, 0xa8, 0xd2, 0xdb, 0x4e, 0x97, 0xe5, 0x8c, 0xb7, 0xa0,
0xea, 0xe2, 0x8e, 0xe3, 0x1a, 0x6d, 0x6c, 0x13, 0xd7, 0xc4, 0xbc, 0xdf, 0xcc, 0x69, 0x15, 0x3e,
0x7b, 0x87, 0x4f, 0x52, 0x32, 0x0a, 0xac, 0x1e, 0xd1, 0xad, 0x7e, 0xfb, 0x80, 0x06, 0x70, 0x86,
0x93, 0xc9, 0x59, 0x16, 0xbf, 0x97, 0xa0, 0x1c, 0x90, 0x11, 0x87, 0xc9, 0xcf, 0x69, 0x25, 0x39,
0xb7, 0xe7, 0xa0, 0x37, 0xa1, 0xca, 0xac, 0xd6, 0xee, 0x39, 0xdd, 0x36, 0xed, 0xcd, 0x44, 0x3a,
0x29, 0x1b, 0x42, 0x2d, 0x7a, 0x1a, 0x51, 0x2a, 0xcf, 0xfc, 0x1c, 0x8b, 0x84, 0x22, 0xa9, 0x5a,
0xe6, 0xe7, 0x98, 0x66, 0xf3, 0x0a, 0xcd, 0x8e, 0xf7, 0x1c, 0x03, 0xef, 0x9d, 0xb0, 0x96, 0x48,
0x71, 0x2f, 0x77, 0x01, 0x8a, 0x72, 0x07, 0x62, 0x4b, 0xc1, 0x04, 0xda, 0x84, 0xaa, 0x5f, 0x66,
0xb6, 0x79, 0xf7, 0x90, 0x1b, 0x59, 0xdb, 0x85, 0xf2, 0x9b, 0xa7, 0x55, 0x7c, 0x36, 0x36, 0x54,
0x37, 0xa1, 0x1c, 0xfe, 0x4c, 0xa5, 0xb6, 0xe2, 0x8e, 0x22, 0x27, 0xa8, 0xbf, 0xdd, 0x1b, 0x58,
0xf4, 0x4c, 0x05, 0x74, 0xf8, 0x43, 0xf5, 0x4b, 0x05, 0x2a, 0x22, 0x29, 0xb7, 0xe4, 0xbd, 0x31,
0xdb, 0x9a, 0xc2, 0xb6, 0xc6, 0xfe, 0x46, 0xdf, 0x8b, 0x5e, 0x3a, 0xbd, 0x99, 0x18, 0xe6, 0x6c,
0x11, 0x56, 0xff, 0x46, 0x32, 0x72, 0x9a, 0x6e, 0xf5, 0x29, 0x75, 0x34, 0x71, 0x34, 0xcc, 0xd1,
0xea, 0x30, 0xab, 0x1b, 0x86, 0x8b, 0x3d, 0x4f, 0xe8, 0xe1, 0x0f, 0xe9, 0x97, 0x23, 0xec, 0x7a,
0xbe, 0xcb, 0x67, 0x35, 0x7f, 0x88, 0x3e, 0x80, 0x82, 0x2c, 0x98, 0xb3, 0x49, 0x45, 0x52, 0x58,
0x4f, 0xd1, 0x5d, 0x49, 0x0e, 0xf5, 0xeb, 0x0c, 0x54, 0x85, 0xc1, 0xd6, 0x45, 0xd6, 0x1c, 0x1f,
0x7c, 0xeb, 0x50, 0x3e, 0x08, 0xa2, 0x7b, 0xdc, 0x2d, 0x4a, 0x18, 0x04, 0x22, 0x3c, 0x93, 0x02,
0x30, 0x9a, 0xb7, 0x73, 0xa7, 0xca, 0xdb, 0xf9, 0x29, 0x31, 0x4a, 0xfd, 0x09, 0x94, 0x42, 0x5f,
0x18, 0xb8, 0xf2, 0x7b, 0x15, 0x61, 0x0a, 0x7f, 0x88, 0x6e, 0x06, 0x65, 0x09, 0xb7, 0xc1, 0xf9,
0x04, 0x21, 0xb1, 0x8a, 0x44, 0xfd, 0xb3, 0x02, 0x33, 0x62, 0xe5, 0x8b, 0x50, 0x12, 0x68, 0xc2,
0x4a, 0x36, 0xbe, 0x3a, 0x88, 0x29, 0x5a, 0xb3, 0x3d, 0x3b, 0x38, 0x39, 0x0f, 0x85, 0x18, 0x90,
0xcc, 0x0a, 0x44, 0xf7, 0x3f, 0x85, 0xd0, 0x83, 0x7e, 0x62, 0xc0, 0xf1, 0xad, 0xc2, 0xee, 0x84,
0x35, 0xdc, 0x71, 0x8e, 0xb0, 0x7b, 0x7c, 0xfa, 0x9b, 0xb7, 0x5b, 0x21, 0x4f, 0x4d, 0xd9, 0xda,
0x49, 0x06, 0x74, 0x2b, 0x30, 0x77, 0x36, 0xe9, 0xe2, 0x21, 0x0c, 0x1d, 0xc2, 0xcf, 0x02, 0xb3,
0x7f, 0xc3, 0xef, 0x10, 0xa3, 0x5b, 0x39, 0x69, 0x49, 0xf2, 0x4c, 0x3a, 0x06, 0xf5, 0xb7, 0x0a,
0x9c, 0xdf, 0xc2, 0x64, 0x33, 0xda, 0x97, 0xbf, 0x6c, 0xad, 0x2c, 0x68, 0x24, 0x29, 0x75, 0x9a,
0x53, 0x6f, 0x40, 0x41, 0xde, 0x30, 0xf0, 0xdb, 0x5d, 0x39, 0x56, 0x7f, 0xa1, 0x40, 0x5d, 0x48,
0x61, 0x32, 0x69, 0x35, 0xdc, 0xc3, 0x04, 0x1b, 0x2f, 0xba, 0xe5, 0xfd, 0xbd, 0x02, 0xb5, 0x30,
0x94, 0x33, 0x34, 0x7e, 0x0f, 0xf2, 0xec, 0x66, 0x41, 0x68, 0x30, 0xd1, 0x59, 0x39, 0x35, 0x85,
0x0c, 0x56, 0xa1, 0xed, 0xc9, 0xac, 0x23, 0x86, 0x41, 0x3e, 0xc9, 0x4e, 0x9d, 0x4f, 0xd4, 0xaf,
0x32, 0x50, 0x0f, 0x9a, 0x85, 0x17, 0x0e, 0xd9, 0x23, 0x4a, 0xc9, 0xec, 0x33, 0x2a, 0x25, 0x73,
0xd3, 0xc2, 0xf4, 0x3f, 0x33, 0x50, 0x0d, 0xcc, 0xb1, 0xdb, 0xd3, 0x6d, 0xb4, 0x00, 0x33, 0xfd,
0x9e, 0x1e, 0xdc, 0xf9, 0x89, 0x11, 0x6a, 0xc9, 0xda, 0x23, 0x6a, 0x80, 0x77, 0x92, 0xcc, 0x3f,
0xc2, 0xc2, 0x5a, 0x6c, 0x09, 0xda, 0x84, 0xf1, 0x32, 0x9e, 0xb5, 0xd2, 0xa2, 0xde, 0xe1, 0xe7,
0x4c, 0xbb, 0xe8, 0x6b, 0x80, 0xe8, 0x07, 0x67, 0x40, 0xda, 0xa6, 0xdd, 0xf6, 0x70, 0xc7, 0xb1,
0x0d, 0x8f, 0x61, 0x6f, 0x5e, 0xab, 0x89, 0x2f, 0x4d, 0xbb, 0xc5, 0xe7, 0xd1, 0x7b, 0x90, 0x23,
0xc7, 0x7d, 0x0e, 0xc0, 0xd5, 0x44, 0x60, 0x0b, 0xf4, 0xda, 0x3b, 0xee, 0x63, 0x8d, 0x91, 0xa3,
0x45, 0x00, 0xba, 0x14, 0x71, 0xf5, 0x23, 0xdc, 0xf3, 0x7f, 0xad, 0x0c, 0x66, 0xa8, 0x23, 0xfa,
0xb7, 0x11, 0xb3, 0x1c, 0xf5, 0xc5, 0x50, 0xfd, 0x7b, 0x06, 0x6a, 0xc1, 0x92, 0x1a, 0xf6, 0x06,
0x3d, 0x32, 0xd2, 0x7e, 0xe3, 0x5b, 0xb0, 0x49, 0xb9, 0xfc, 0x23, 0x28, 0x89, 0x9b, 0x91, 0x29,
0x0e, 0x1a, 0x38, 0xcb, 0xf6, 0x18, 0xcf, 0xcb, 0x3f, 0x23, 0xcf, 0x9b, 0x99, 0xd6, 0xf3, 0x5a,
0xb0, 0xe0, 0x43, 0x56, 0x40, 0xb0, 0x83, 0x89, 0x3e, 0xa6, 0x56, 0xb8, 0x08, 0x25, 0x9e, 0x8a,
0x78, 0x0e, 0xe6, 0xe5, 0x33, 0xec, 0xcb, 0xbe, 0x52, 0xfd, 0x29, 0x9c, 0x63, 0x21, 0x1f, 0xbf,
0x40, 0x4d, 0x73, 0x9b, 0xad, 0xca, 0xe2, 0x9c, 0x16, 0xe2, 0xdc, 0xbb, 0x8b, 0x5a, 0x64, 0x4e,
0xdd, 0x86, 0x57, 0x62, 0xeb, 0x9f, 0x02, 0xd2, 0xd5, 0x7f, 0x28, 0x70, 0x7e, 0xc3, 0x75, 0xfa,
0xf7, 0x4d, 0x97, 0x0c, 0xf4, 0x5e, 0xf4, 0x4a, 0xfe, 0xf9, 0xb4, 0x17, 0x77, 0x43, 0x59, 0x84,
0x83, 0xce, 0xb5, 0x84, 0x23, 0x1b, 0x56, 0x4a, 0x1c, 0x55, 0x28, 0xe7, 0xfc, 0x37, 0x9b, 0xa4,
0xbc, 0xa0, 0x9b, 0x80, 0xa4, 0x69, 0x92, 0x6c, 0xe2, 0x7d, 0x43, 0xf6, 0xa4, 0xf7, 0x0d, 0x23,
0xbc, 0x3f, 0xf7, 0x8c, 0xbc, 0x7f, 0xda, 0xf2, 0x18, 0xdd, 0x85, 0xe8, 0x5d, 0x10, 0x83, 0x9d,
0x13, 0x5d, 0x22, 0xad, 0x03, 0x04, 0xf7, 0x22, 0xe2, 0x3d, 0x45, 0x9a, 0x65, 0x42, 0x5c, 0xf4,
0xb4, 0x24, 0xd2, 0xb0, 0xfb, 0xcc, 0x48, 0x1f, 0xff, 0x09, 0x34, 0x92, 0xbc, 0xf4, 0x14, 0x9e,
0x7f, 0xf5, 0x06, 0x9c, 0x1d, 0xca, 0xd0, 0xa8, 0x0a, 0xf0, 0xa9, 0xdd, 0x11, 0xa5, 0x4b, 0xed,
0x0c, 0x2a, 0x43, 0xc1, 0x2f, 0x64, 0x6a, 0xca, 0xd5, 0x56, 0x38, 0x51, 0x51, 0xf4, 0x46, 0xaf,
0xc2, 0xfc, 0xa7, 0xb6, 0x81, 0x0f, 0x4c, 0x1b, 0x1b, 0xc1, 0xa7, 0xda, 0x19, 0x34, 0x0f, 0x73,
0x4d, 0xdb, 0xc6, 0x6e, 0x68, 0x52, 0xa1, 0x93, 0x3b, 0xd8, 0xed, 0xe2, 0xd0, 0x64, 0x66, 0xed,
0x9b, 0x79, 0x28, 0xd2, 0xce, 0xf1, 0xb6, 0xe3, 0xb8, 0x06, 0xea, 0x03, 0x62, 0x3f, 0x7a, 0x5a,
0x7d, 0xc7, 0x96, 0xaf, 0x03, 0xd0, 0xf5, 0x11, 0xc6, 0x1c, 0x26, 0x15, 0x91, 0xdb, 0xb8, 0x3c,
0x82, 0x23, 0x46, 0xae, 0x9e, 0x41, 0x16, 0x93, 0x48, 0x53, 0xdd, 0x9e, 0xd9, 0x79, 0xe8, 0x5f,
0x6f, 0x8f, 0x91, 0x18, 0x23, 0xf5, 0x25, 0xc6, 0x1e, 0x1d, 0x88, 0x01, 0xff, 0x65, 0xda, 0x3f,
0x29, 0xf5, 0x0c, 0x7a, 0x04, 0xe7, 0xb6, 0x30, 0x09, 0x7e, 0x8c, 0xf4, 0x05, 0xae, 0x8d, 0x16,
0x38, 0x44, 0x3c, 0xa5, 0xc8, 0x6d, 0xc8, 0xb3, 0x92, 0x14, 0x25, 0x95, 0x7d, 0xe1, 0x27, 0x72,
0x8d, 0xa5, 0xd1, 0x04, 0x72, 0xb5, 0x9f, 0xc1, 0x5c, 0xec, 0x09, 0x10, 0xba, 0x92, 0xc0, 0x96,
0xfc, 0x98, 0xab, 0x71, 0x35, 0x0d, 0xa9, 0x94, 0xd5, 0x85, 0x6a, 0xf4, 0x27, 0x53, 0xb4, 0x9c,
0xc0, 0x9f, 0xf8, 0x7c, 0xa3, 0x71, 0x25, 0x05, 0xa5, 0x14, 0x64, 0x41, 0x2d, 0xfe, 0x24, 0x05,
0x5d, 0x1d, 0xbb, 0x40, 0xd4, 0xdd, 0xde, 0x49, 0x45, 0x2b, 0xc5, 0x1d, 0x33, 0x27, 0x18, 0x7a,
0x12, 0x81, 0x56, 0x92, 0x97, 0x19, 0xf5, 0x56, 0xa3, 0xb1, 0x9a, 0x9a, 0x5e, 0x8a, 0xfe, 0x39,
0x6f, 0x85, 0x93, 0x9e, 0x15, 0xa0, 0x1b, 0xc9, 0xcb, 0x8d, 0x79, 0x0f, 0xd1, 0x58, 0x9b, 0x86,
0x45, 0x2a, 0xf1, 0x05, 0xeb, 0x61, 0x13, 0x7e, 0x9a, 0x8f, 0xc7, 0x9d, 0xbf, 0xde, 0xe8, 0x37,
0x07, 0x8d, 0x1b, 0x53, 0x70, 0x48, 0x05, 0x9c, 0xf8, 0xa3, 0x1f, 0x3f, 0x0c, 0x57, 0x27, 0x7a,
0xcd, 0xc9, 0x62, 0xf0, 0x33, 0x98, 0x8b, 0xfd, 0x90, 0x90, 0x18, 0x35, 0xc9, 0x3f, 0x36, 0x34,
0xc6, 0x01, 0x3a, 0x0f, 0xc9, 0xd8, 0x95, 0x00, 0x1a, 0xe1, 0xfd, 0x09, 0xd7, 0x06, 0x8d, 0xab,
0x69, 0x48, 0xe5, 0x46, 0x3c, 0x06, 0x97, 0xb1, 0xb6, 0x1a, 0x5d, 0x4b, 0x5e, 0x23, 0xf9, 0x4a,
0xa0, 0xf1, 0x6e, 0x4a, 0x6a, 0x29, 0xb4, 0x0d, 0xb0, 0x85, 0xc9, 0x0e, 0x26, 0x2e, 0xf5, 0x91,
0xcb, 0x89, 0x26, 0x0f, 0x08, 0x7c, 0x31, 0x6f, 0x4f, 0xa4, 0x93, 0x02, 0x7e, 0x04, 0xc8, 0xcf,
0x73, 0xa1, 0x9f, 0xb1, 0xde, 0x18, 0xdb, 0xbe, 0xf0, 0x5e, 0x63, 0xd2, 0xd9, 0x3c, 0x82, 0xda,
0x8e, 0x6e, 0xd3, 0xa4, 0x1d, 0xac, 0x7b, 0x2d, 0x51, 0xb1, 0x38, 0xd9, 0x08, 0x6b, 0x8d, 0xa4,
0x96, 0x9b, 0x79, 0x2c, 0x73, 0xa8, 0x2e, 0x43, 0x10, 0xc7, 0xb1, 0x25, 0xb0, 0x46, 0x8c, 0x70,
0x04, 0xb6, 0x8c, 0xa1, 0x97, 0x82, 0x9f, 0x2a, 0xec, 0x69, 0x59, 0x8c, 0xe0, 0x81, 0x49, 0x0e,
0x69, 0x57, 0xeb, 0xa5, 0x51, 0x81, 0x11, 0x4e, 0xa1, 0x82, 0xa0, 0x97, 0x2a, 0x18, 0x50, 0x89,
0x74, 0x07, 0x28, 0xe9, 0xb7, 0xa8, 0xa4, 0xfe, 0xa4, 0xb1, 0x3c, 0x99, 0x50, 0x4a, 0x39, 0x84,
0x8a, 0xef, 0xaf, 0xdc, 0xb8, 0x57, 0x46, 0x69, 0x1a, 0xd0, 0x8c, 0x08, 0xb7, 0x64, 0xd2, 0x70,
0xb8, 0x0d, 0x17, 0x7e, 0x28, 0x5d, 0xc3, 0x30, 0x2e, 0xdc, 0x46, 0x57, 0x93, 0xea, 0x99, 0xb5,
0xff, 0xe4, 0xa0, 0xe0, 0x5f, 0xe6, 0xbf, 0x84, 0x8a, 0xec, 0x25, 0x94, 0x48, 0x9f, 0xc1, 0x5c,
0xec, 0xdd, 0x4f, 0x22, 0x82, 0x26, 0xbf, 0x0d, 0x9a, 0x04, 0x01, 0x0f, 0xc4, 0x7f, 0x03, 0x48,
0xb4, 0x7c, 0x7b, 0x54, 0x99, 0x15, 0x07, 0xca, 0x09, 0x0b, 0x3f, 0x77, 0x58, 0xbc, 0x07, 0x10,
0x82, 0xad, 0xf1, 0xb7, 0x39, 0x34, 0x12, 0x27, 0x28, 0xbc, 0x7e, 0xf3, 0xc7, 0x37, 0xba, 0x26,
0x39, 0x1c, 0xec, 0xd3, 0x2f, 0xab, 0x9c, 0xf4, 0x5d, 0xd3, 0x11, 0x7f, 0xad, 0xfa, 0x27, 0xba,
0xca, 0xb8, 0x57, 0xa9, 0x80, 0xfe, 0xfe, 0xfe, 0x0c, 0x1b, 0xdd, 0xfc, 0x7f, 0x00, 0x00, 0x00,
0xff, 0xff, 0xf4, 0x7a, 0xd1, 0x47, 0x2f, 0x32, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

2
internal/proto/query_coord.proto
View File

@ -189,7 +189,7 @@ message SegmentLoadInfo {
repeated data.FieldBinlog binlog_paths = 6;
int64 num_of_rows = 7;
repeated data.FieldBinlog statslogs = 8;
repeated data.DeltaLogInfo deltalogs = 9;
repeated data.FieldBinlog deltalogs = 9;
repeated int64 compactionFrom = 10; // segmentIDs compacted from
bool enable_index = 11;
repeated index.IndexFilePathInfo index_path_infos = 12;

288
internal/proto/querypb/query_coord.pb.go
View File

@ -1271,7 +1271,7 @@ type SegmentLoadInfo struct {
BinlogPaths []*datapb.FieldBinlog `protobuf:"bytes,6,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"`
NumOfRows int64 `protobuf:"varint,7,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
Statslogs []*datapb.FieldBinlog `protobuf:"bytes,8,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
Deltalogs []*datapb.DeltaLogInfo `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,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"`
EnableIndex bool `protobuf:"varint,11,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"`
IndexPathInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,12,rep,name=index_path_infos,json=indexPathInfos,proto3" json:"index_path_infos,omitempty"`
@ -1361,7 +1361,7 @@ func (m *SegmentLoadInfo) GetStatslogs() []*datapb.FieldBinlog {
return nil
}
func (m *SegmentLoadInfo) GetDeltalogs() []*datapb.DeltaLogInfo {
func (m *SegmentLoadInfo) GetDeltalogs() []*datapb.FieldBinlog {
if m != nil {
return m.Deltalogs
}
@ -2244,148 +2244,148 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2251 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x39, 0x4f, 0x73, 0xdc, 0x48,
0xf5, 0xd6, 0xfc, 0xb3, 0xe7, 0xcd, 0x78, 0x46, 0xee, 0xc4, 0xde, 0xc9, 0xfc, 0x36, 0xd9, 0xac,
0x76, 0x9d, 0xcd, 0xcf, 0xcb, 0xda, 0xc1, 0x01, 0x8a, 0x2d, 0xd8, 0x43, 0x6c, 0x13, 0xaf, 0x49,
0xe2, 0x18, 0xd9, 0x59, 0x8a, 0x54, 0xaa, 0x84, 0x66, 0xd4, 0x1e, 0xab, 0x22, 0xa9, 0x27, 0x6a,
0xcd, 0xda, 0xce, 0x99, 0x03, 0x1c, 0x28, 0x3e, 0x00, 0x14, 0xa7, 0xa5, 0x20, 0x55, 0xec, 0x91,
0x7b, 0x2e, 0x7c, 0x04, 0xae, 0x14, 0x07, 0xf8, 0x08, 0xdc, 0xa9, 0x6e, 0xb5, 0x34, 0xfa, 0xd3,
0xb2, 0xc7, 0x76, 0x79, 0x93, 0xa2, 0xb8, 0x49, 0xaf, 0x5f, 0xbf, 0xf7, 0xfa, 0xfd, 0xef, 0x7e,
0x30, 0xf7, 0x62, 0x84, 0xfd, 0x63, 0xa3, 0x4f, 0x88, 0x6f, 0x2d, 0x0f, 0x7d, 0x12, 0x10, 0x84,
0x5c, 0xdb, 0xf9, 0x72, 0x44, 0xc3, 0xbf, 0x65, 0xbe, 0xde, 0x6d, 0xf6, 0x89, 0xeb, 0x12, 0x2f,
0x84, 0x75, 0x9b, 0x49, 0x8c, 0x6e, 0xcb, 0xf6, 0x02, 0xec, 0x7b, 0xa6, 0x13, 0xad, 0xd2, 0xfe,
0x01, 0x76, 0x4d, 0xf1, 0xa7, 0x5a, 0x66, 0x60, 0x26, 0xe9, 0x77, 0xe7, 0x6c, 0xcf, 0xc2, 0x47,
0x49, 0x90, 0xf6, 0x0b, 0x05, 0x16, 0x76, 0x0f, 0xc8, 0xe1, 0x3a, 0x71, 0x1c, 0xdc, 0x0f, 0x6c,
0xe2, 0x51, 0x1d, 0xbf, 0x18, 0x61, 0x1a, 0xa0, 0x3b, 0x50, 0xe9, 0x99, 0x14, 0x77, 0x94, 0x9b,
0xca, 0xed, 0xc6, 0xea, 0xbb, 0xcb, 0x29, 0xe1, 0x84, 0x54, 0x8f, 0xe8, 0x60, 0xcd, 0xa4, 0x58,
0xe7, 0x98, 0x08, 0x41, 0xc5, 0xea, 0x6d, 0x6d, 0x74, 0x4a, 0x37, 0x95, 0xdb, 0x65, 0x9d, 0x7f,
0xa3, 0x0f, 0x61, 0xb6, 0x1f, 0xd3, 0xde, 0xda, 0xa0, 0x9d, 0xf2, 0xcd, 0xf2, 0xed, 0xb2, 0x9e,
0x06, 0x6a, 0x7f, 0x54, 0xe0, 0x9d, 0x9c, 0x18, 0x74, 0x48, 0x3c, 0x8a, 0xd1, 0x5d, 0xa8, 0xd1,
0xc0, 0x0c, 0x46, 0x54, 0x48, 0xf2, 0x7f, 0x52, 0x49, 0x76, 0x39, 0x8a, 0x2e, 0x50, 0xf3, 0x6c,
0x4b, 0x12, 0xb6, 0xe8, 0xdb, 0x70, 0xd5, 0xf6, 0x1e, 0x61, 0x97, 0xf8, 0xc7, 0xc6, 0x10, 0xfb,
0x7d, 0xec, 0x05, 0xe6, 0x00, 0x47, 0x32, 0x5e, 0x89, 0xd6, 0x76, 0xc6, 0x4b, 0xda, 0x1f, 0x14,
0x98, 0x67, 0x92, 0xee, 0x98, 0x7e, 0x60, 0x5f, 0x82, 0xbe, 0x34, 0x68, 0x26, 0x65, 0xec, 0x94,
0xf9, 0x5a, 0x0a, 0xc6, 0x70, 0x86, 0x11, 0x7b, 0x76, 0xb6, 0x0a, 0x17, 0x37, 0x05, 0xd3, 0xbe,
0x12, 0x86, 0x4d, 0xca, 0x79, 0x11, 0x85, 0x66, 0x79, 0x96, 0xf2, 0x3c, 0xcf, 0xa3, 0xce, 0xd7,
0x0a, 0xcc, 0x3f, 0x24, 0xa6, 0x35, 0x36, 0xfc, 0x37, 0xaf, 0xce, 0xcf, 0xa0, 0x16, 0x06, 0x4e,
0xa7, 0xc2, 0x79, 0x2d, 0xa6, 0x79, 0x89, 0xa0, 0x1a, 0x4b, 0xb8, 0xcb, 0x01, 0xba, 0xd8, 0xa4,
0xfd, 0x4e, 0x81, 0x8e, 0x8e, 0x1d, 0x6c, 0x52, 0xfc, 0x26, 0x4f, 0xb1, 0x00, 0x35, 0x8f, 0x58,
0x78, 0x6b, 0x83, 0x9f, 0xa2, 0xac, 0x8b, 0x3f, 0xed, 0x9f, 0x42, 0xc3, 0x6f, 0xb9, 0xc3, 0x26,
0xac, 0x50, 0x3d, 0x8f, 0x15, 0x5e, 0x8f, 0xad, 0xf0, 0xb6, 0x9f, 0x74, 0x6c, 0xa9, 0x6a, 0xca,
0x52, 0x3f, 0x83, 0x6b, 0xeb, 0x3e, 0x36, 0x03, 0xfc, 0x13, 0x96, 0xf9, 0xd7, 0x0f, 0x4c, 0xcf,
0xc3, 0x4e, 0x74, 0x84, 0x2c, 0x73, 0x45, 0xc2, 0xbc, 0x03, 0xd3, 0x43, 0x9f, 0x1c, 0x1d, 0xc7,
0x72, 0x47, 0xbf, 0xda, 0x9f, 0x14, 0xe8, 0xca, 0x68, 0x5f, 0x24, 0x23, 0x7c, 0x00, 0xb3, 0xa2,
0x84, 0x85, 0xd4, 0x38, 0xcf, 0xba, 0xde, 0x7c, 0x91, 0xe0, 0x80, 0xee, 0xc0, 0xd5, 0x10, 0xc9,
0xc7, 0x74, 0xe4, 0x04, 0x31, 0x6e, 0x99, 0xe3, 0x22, 0xbe, 0xa6, 0xf3, 0x25, 0xb1, 0x43, 0x7b,
0xa5, 0xc0, 0xb5, 0x4d, 0x1c, 0xc4, 0x46, 0x64, 0x5c, 0xf1, 0x5b, 0x9a, 0x64, 0xbf, 0x56, 0xa0,
0x2b, 0x93, 0xf5, 0x22, 0x6a, 0x7d, 0x0a, 0x0b, 0x31, 0x0f, 0xc3, 0xc2, 0xb4, 0xef, 0xdb, 0x43,
0xee, 0xcc, 0x3c, 0xe5, 0x36, 0x56, 0x3f, 0x58, 0xce, 0x77, 0x09, 0xcb, 0x59, 0x09, 0xe6, 0x63,
0x12, 0x1b, 0x09, 0x0a, 0xda, 0xaf, 0x15, 0x98, 0xdf, 0xc4, 0xc1, 0x2e, 0x1e, 0xb8, 0xd8, 0x0b,
0xb6, 0xbc, 0x7d, 0x72, 0x7e, 0xbd, 0xde, 0x00, 0xa0, 0x82, 0x4e, 0x5c, 0x0e, 0x12, 0x90, 0x49,
0x74, 0xcc, 0xbb, 0x8f, 0xac, 0x3c, 0x17, 0xd1, 0xdd, 0x77, 0xa1, 0x6a, 0x7b, 0xfb, 0x24, 0x52,
0xd5, 0x7b, 0x32, 0x55, 0x25, 0x99, 0x85, 0xd8, 0xda, 0x5f, 0xca, 0xb0, 0x70, 0xcf, 0xb2, 0x64,
0x61, 0x77, 0x76, 0xbd, 0x8c, 0xa3, 0xbb, 0x94, 0x8c, 0xee, 0x89, 0x7c, 0x2e, 0x17, 0x52, 0x95,
0x33, 0x84, 0x54, 0xb5, 0x28, 0xa4, 0xd0, 0xf7, 0xe0, 0x9d, 0x81, 0x43, 0x7a, 0xa6, 0x63, 0x50,
0x6c, 0x3a, 0xd8, 0x32, 0x62, 0x33, 0x75, 0x6a, 0xdc, 0x6e, 0xf3, 0xe1, 0xf2, 0x2e, 0x5f, 0x8d,
0x14, 0xb4, 0x81, 0x36, 0x61, 0x96, 0x62, 0xfc, 0xdc, 0x18, 0x12, 0xca, 0x7d, 0xa9, 0x33, 0xcd,
0xb5, 0xa0, 0xa5, 0xb5, 0x10, 0x37, 0xa1, 0x8f, 0xe8, 0x60, 0x47, 0x60, 0xea, 0x4d, 0xb6, 0x31,
0xfa, 0x43, 0x4f, 0x60, 0x41, 0x2a, 0x00, 0xed, 0xcc, 0x4c, 0x66, 0xa8, 0xab, 0x12, 0x01, 0xa9,
0xf6, 0x0f, 0x05, 0xae, 0xe9, 0xd8, 0x25, 0x5f, 0xe2, 0xff, 0x56, 0xd3, 0x69, 0xff, 0x2a, 0xc1,
0xc2, 0x4f, 0xcd, 0xa0, 0x7f, 0xb0, 0xe1, 0x0a, 0x10, 0x7d, 0x33, 0xe7, 0x9b, 0xa4, 0xb0, 0xc5,
0xe1, 0x57, 0x95, 0x59, 0x95, 0x5d, 0x47, 0x96, 0xbf, 0x10, 0x47, 0x4e, 0x84, 0x5f, 0xa2, 0xf2,
0xd7, 0xce, 0x51, 0xf9, 0xd1, 0x3a, 0xcc, 0xe2, 0xa3, 0xbe, 0x33, 0xb2, 0xb0, 0x11, 0x72, 0x9f,
0xe6, 0xdc, 0x6f, 0x48, 0xb8, 0x27, 0x5d, 0xaa, 0x29, 0x36, 0x6d, 0xf1, 0x14, 0xf0, 0x5a, 0x81,
0x6b, 0xa1, 0x9e, 0xb1, 0x13, 0x98, 0x6f, 0x56, 0xd5, 0xb1, 0x1a, 0x2b, 0x67, 0x51, 0xa3, 0xf6,
0x55, 0x05, 0xda, 0xe2, 0x80, 0xac, 0xdf, 0x63, 0x4b, 0xe8, 0x5d, 0xa8, 0x8f, 0x63, 0x3d, 0x6c,
0x19, 0xc6, 0x00, 0x74, 0x13, 0x1a, 0x09, 0xfb, 0x09, 0x49, 0x93, 0xa0, 0x89, 0xc4, 0x8d, 0x0a,
0x6c, 0x25, 0x51, 0x60, 0xaf, 0x03, 0xec, 0x3b, 0x23, 0x7a, 0x60, 0x04, 0xb6, 0x8b, 0x45, 0x9b,
0x53, 0xe7, 0x90, 0x3d, 0xdb, 0xc5, 0xe8, 0x1e, 0x34, 0x7b, 0xb6, 0xe7, 0x90, 0x81, 0x31, 0x34,
0x83, 0x03, 0xca, 0xb3, 0x90, 0xdc, 0x62, 0xf7, 0x6d, 0xec, 0x58, 0x6b, 0x1c, 0x57, 0x6f, 0x84,
0x7b, 0x76, 0xd8, 0x16, 0x74, 0x03, 0x1a, 0xde, 0xc8, 0x35, 0xc8, 0xbe, 0xe1, 0x93, 0x43, 0xca,
0x33, 0x53, 0x59, 0xaf, 0x7b, 0x23, 0xf7, 0xf1, 0xbe, 0x4e, 0x0e, 0x29, 0xfa, 0x21, 0xd4, 0x59,
0x51, 0xa0, 0x0e, 0x19, 0x44, 0x59, 0xe6, 0x34, 0xfa, 0xe3, 0x0d, 0xe8, 0x33, 0xa8, 0x5b, 0xcc,
0x11, 0xf8, 0xee, 0x7a, 0xa1, 0x19, 0xb8, 0xb3, 0x3c, 0x24, 0x03, 0x6e, 0x86, 0xf1, 0x0e, 0x74,
0x0b, 0x5a, 0x7d, 0xe2, 0x0e, 0x4d, 0xae, 0xa2, 0xfb, 0x3e, 0x71, 0x3b, 0xc0, 0xc3, 0x25, 0x03,
0x45, 0xef, 0x43, 0x13, 0x7b, 0x66, 0xcf, 0x61, 0x9e, 0x6b, 0xe1, 0xa3, 0x4e, 0xe3, 0xa6, 0x72,
0x7b, 0x46, 0x6f, 0x84, 0xb0, 0x2d, 0x06, 0x42, 0x8f, 0x41, 0x0d, 0x6f, 0xed, 0x4c, 0x53, 0xc2,
0xc1, 0x9b, 0x5c, 0xa0, 0xc5, 0x6c, 0x1a, 0xb6, 0xf0, 0xd1, 0x32, 0xdf, 0x74, 0xdf, 0x76, 0x30,
0xd3, 0x12, 0x17, 0xab, 0xc5, 0x17, 0xa2, 0x5f, 0xaa, 0xbd, 0x2a, 0xc1, 0x15, 0xe6, 0x1f, 0x51,
0x16, 0x3d, 0xbf, 0x8f, 0x5f, 0x07, 0xb0, 0x68, 0x60, 0xa4, 0xfc, 0xbc, 0x6e, 0xd1, 0x60, 0x3b,
0x74, 0xf5, 0x4f, 0x23, 0x37, 0x2e, 0x17, 0xf7, 0x2d, 0x19, 0x7f, 0xcd, 0x67, 0x84, 0xf3, 0xdc,
0xc8, 0x58, 0x2e, 0xa6, 0x64, 0xe4, 0xf7, 0xb1, 0x91, 0xea, 0xb3, 0x9b, 0x21, 0x70, 0x5b, 0x1e,
0x89, 0x35, 0x49, 0x7f, 0xf2, 0x77, 0x05, 0x16, 0xc4, 0xa5, 0xe2, 0xe2, 0xea, 0x2a, 0x4a, 0x09,
0x51, 0xfc, 0x94, 0x4f, 0x68, 0x50, 0x2b, 0x13, 0x64, 0xe4, 0xaa, 0x24, 0x23, 0xa7, 0x9b, 0xb4,
0x5a, 0xb6, 0x49, 0xd3, 0x7e, 0xa3, 0xc0, 0xc2, 0xe7, 0xa6, 0x67, 0x91, 0xfd, 0xfd, 0x8b, 0x1f,
0x70, 0x1d, 0x9a, 0x74, 0x9c, 0x60, 0x27, 0x6e, 0xc2, 0x52, 0x9b, 0xb4, 0x5f, 0x96, 0x00, 0x31,
0x77, 0x58, 0x33, 0x1d, 0xd3, 0xeb, 0xe3, 0xf3, 0x4b, 0xb3, 0x08, 0xad, 0x94, 0x13, 0xc4, 0x4f,
0x40, 0x49, 0x2f, 0xa0, 0xe8, 0x01, 0xb4, 0x7a, 0x21, 0x2b, 0xc3, 0xc7, 0x26, 0x25, 0x1e, 0xb7,
0x43, 0x6b, 0xf5, 0x43, 0x99, 0xd8, 0x7b, 0xbe, 0x3d, 0x18, 0x60, 0x7f, 0x9d, 0x78, 0x56, 0xd8,
0xe6, 0xcc, 0xf6, 0x22, 0x31, 0xd9, 0x56, 0xf4, 0x1e, 0x34, 0xc6, 0x11, 0x11, 0xd5, 0x48, 0x88,
0x43, 0x82, 0xa2, 0x8f, 0x61, 0x2e, 0xdb, 0x82, 0x45, 0x86, 0x53, 0x69, 0xba, 0xfb, 0xa2, 0xda,
0x6f, 0x15, 0x40, 0x71, 0xd9, 0xe7, 0xc5, 0x89, 0xe7, 0xf4, 0x49, 0x6e, 0x82, 0x37, 0x00, 0xa2,
0x0a, 0x21, 0x0e, 0x5e, 0xd7, 0x13, 0x10, 0x56, 0x17, 0xac, 0x88, 0xb2, 0xb8, 0x8b, 0x8d, 0x01,
0x2c, 0x7e, 0xc2, 0x23, 0x18, 0x0e, 0x31, 0x2d, 0x6c, 0x45, 0xee, 0x17, 0x02, 0x1f, 0x72, 0x98,
0xf6, 0x75, 0x09, 0xd4, 0x64, 0xdb, 0x35, 0xb1, 0x6c, 0x97, 0x73, 0x6f, 0x3c, 0xa1, 0xc7, 0xac,
0x5c, 0xa0, 0xc7, 0xcc, 0xf7, 0xc0, 0xd5, 0xf3, 0xf5, 0xc0, 0xda, 0xef, 0x15, 0x68, 0x67, 0xae,
0x69, 0xd9, 0x02, 0xac, 0xe4, 0x0b, 0xf0, 0xf7, 0xa1, 0xca, 0xaa, 0x12, 0xe6, 0x4a, 0x6a, 0x65,
0xd9, 0xca, 0x2e, 0x7f, 0x7a, 0xb8, 0x01, 0xad, 0xc0, 0x15, 0xc9, 0x63, 0x9c, 0xc8, 0x32, 0x28,
0xff, 0x16, 0xa7, 0xfd, 0xb9, 0x02, 0x8d, 0x84, 0x3e, 0x4e, 0xe9, 0x1d, 0xb2, 0x96, 0x2e, 0x49,
0x2c, 0x9d, 0x39, 0x5e, 0x39, 0x7f, 0xbc, 0x82, 0x47, 0x2b, 0x74, 0x0d, 0x66, 0x5c, 0xec, 0x1a,
0xd4, 0x7e, 0x19, 0x75, 0x0f, 0xd3, 0x2e, 0x76, 0x77, 0xed, 0x97, 0x98, 0x2d, 0xb1, 0xc2, 0xcf,
0xab, 0x7e, 0x98, 0xb3, 0xa7, 0xbd, 0x91, 0xcb, 0x6b, 0xfe, 0x75, 0x80, 0xb0, 0x56, 0x7a, 0xa6,
0x8b, 0x79, 0x4b, 0x50, 0xd7, 0xeb, 0x1c, 0xb2, 0x6d, 0xba, 0x18, 0x75, 0x60, 0x9a, 0xff, 0x6c,
0x6d, 0x74, 0x66, 0xc2, 0x8d, 0xe2, 0x37, 0x1d, 0x0e, 0xf5, 0x6c, 0x38, 0x4c, 0x5a, 0xcd, 0xef,
0xc0, 0x95, 0x3e, 0x7f, 0x63, 0xb1, 0xd6, 0x8e, 0xd7, 0xe3, 0x25, 0x51, 0xd4, 0x65, 0x4b, 0xe8,
0x3e, 0x73, 0x2e, 0xae, 0x51, 0x23, 0xb4, 0x72, 0x93, 0x5b, 0xf9, 0x7d, 0xf9, 0x5d, 0x37, 0xc4,
0x0c, 0x8d, 0x1c, 0x25, 0x4d, 0xfe, 0x97, 0xeb, 0x23, 0x66, 0x27, 0xeb, 0x23, 0x5a, 0x17, 0xe9,
0x23, 0xfe, 0x56, 0x86, 0xd6, 0xb8, 0x02, 0x4f, 0x1c, 0xfd, 0x93, 0xbc, 0x23, 0x6f, 0x83, 0x3a,
0x7e, 0x02, 0xe1, 0x8a, 0x39, 0xb1, 0x89, 0xc8, 0x3e, 0x7e, 0xb4, 0x87, 0x99, 0x30, 0x7b, 0x00,
0xb3, 0x22, 0x7f, 0x18, 0xc9, 0xc6, 0xfa, 0x96, 0x8c, 0x58, 0x3e, 0xe1, 0xea, 0xcd, 0x44, 0xb3,
0x4d, 0xd1, 0xa7, 0x50, 0x67, 0x59, 0xd1, 0x08, 0x8e, 0x87, 0xa1, 0x6f, 0xb6, 0xb2, 0xe5, 0x28,
0x24, 0xc4, 0xd2, 0xe4, 0xde, 0xf1, 0x10, 0xeb, 0x33, 0x8e, 0xf8, 0xba, 0xe8, 0x45, 0xe7, 0x2e,
0xcc, 0xfb, 0x61, 0x33, 0x62, 0x19, 0x29, 0x1d, 0x4e, 0x73, 0x1d, 0x5e, 0x8d, 0x16, 0x77, 0x92,
0xba, 0x2c, 0x48, 0x03, 0x33, 0x85, 0x69, 0xe0, 0xdf, 0x0a, 0xcc, 0x09, 0x57, 0x63, 0x9a, 0x18,
0xf0, 0x0b, 0x12, 0x4b, 0xda, 0xc4, 0x73, 0x6c, 0x2f, 0x6e, 0xa9, 0x84, 0x6d, 0x43, 0xa0, 0x68,
0xa9, 0x3e, 0x87, 0xb6, 0x40, 0x8a, 0x73, 0xef, 0x84, 0x3d, 0x40, 0x2b, 0xdc, 0x17, 0x67, 0xdd,
0x45, 0x68, 0x91, 0xfd, 0xfd, 0x24, 0xbf, 0x30, 0x79, 0xcc, 0x0a, 0xa8, 0x60, 0xf8, 0x63, 0x50,
0x23, 0xb4, 0xb3, 0x66, 0xfb, 0xb6, 0xd8, 0x18, 0x3f, 0x26, 0xfc, 0x4a, 0x81, 0x4e, 0x3a, 0xf7,
0x27, 0x8e, 0x7f, 0xf6, 0xf6, 0xe3, 0x07, 0xe9, 0xa7, 0xa8, 0xc5, 0x13, 0xe4, 0x19, 0xf3, 0x11,
0xfd, 0xef, 0xd2, 0x4b, 0x68, 0xa5, 0x9d, 0x1a, 0x35, 0x61, 0x66, 0x9b, 0x04, 0x3f, 0x3a, 0xb2,
0x69, 0xa0, 0x4e, 0xa1, 0x16, 0xc0, 0x36, 0x09, 0x76, 0x7c, 0x4c, 0xb1, 0x17, 0xa8, 0x0a, 0x02,
0xa8, 0x3d, 0xf6, 0x36, 0x6c, 0xfa, 0x5c, 0x2d, 0xa1, 0x2b, 0xa2, 0xcc, 0x98, 0xce, 0x96, 0x30,
0xae, 0x5a, 0x66, 0xdb, 0xe3, 0xbf, 0x0a, 0x52, 0xa1, 0x19, 0xa3, 0x6c, 0xee, 0x3c, 0x51, 0xab,
0xa8, 0x0e, 0xd5, 0xf0, 0xb3, 0xb6, 0x64, 0x81, 0x9a, 0x6d, 0x73, 0x18, 0xcd, 0x27, 0xde, 0x03,
0x8f, 0x1c, 0xc6, 0x20, 0x75, 0x0a, 0x35, 0x60, 0x5a, 0xb4, 0x8e, 0xaa, 0x82, 0xda, 0xd0, 0x48,
0x74, 0x6d, 0x6a, 0x89, 0x01, 0x36, 0xfd, 0x61, 0x5f, 0xf4, 0x6f, 0xa1, 0x08, 0xcc, 0x6a, 0x1b,
0xe4, 0xd0, 0x53, 0x2b, 0x4b, 0xf7, 0x60, 0x26, 0x0a, 0x10, 0x76, 0x9a, 0x90, 0x3a, 0xfb, 0x53,
0xa7, 0xd0, 0x1c, 0xcc, 0xa6, 0x06, 0x16, 0xaa, 0x82, 0x10, 0xb4, 0x9c, 0xd4, 0x94, 0x48, 0x2d,
0xad, 0xfe, 0xb5, 0x01, 0x10, 0x36, 0x20, 0x84, 0xf8, 0x16, 0x1a, 0x02, 0xda, 0xc4, 0x01, 0x4b,
0xae, 0xc4, 0x8b, 0x12, 0x23, 0x45, 0x77, 0x0a, 0xea, 0x74, 0x1e, 0x55, 0x48, 0xda, 0xbd, 0x55,
0xb0, 0x23, 0x83, 0xae, 0x4d, 0x21, 0x97, 0x73, 0x64, 0x17, 0xda, 0x3d, 0xbb, 0xff, 0x3c, 0xee,
0x5c, 0x8a, 0x39, 0x66, 0x50, 0x23, 0x8e, 0x99, 0xa4, 0x26, 0x7e, 0x76, 0x03, 0xdf, 0xf6, 0x06,
0xd1, 0x7b, 0xa8, 0x36, 0x85, 0x5e, 0xc0, 0xd5, 0x4d, 0xcc, 0xb9, 0xdb, 0x34, 0xb0, 0xfb, 0x34,
0x62, 0xb8, 0x5a, 0xcc, 0x30, 0x87, 0x7c, 0x46, 0x96, 0x0e, 0xb4, 0x33, 0x53, 0x59, 0xb4, 0x24,
0x75, 0x64, 0xe9, 0x04, 0xb9, 0xfb, 0xf1, 0x44, 0xb8, 0x31, 0x37, 0x1b, 0x5a, 0xe9, 0x89, 0x25,
0xfa, 0xff, 0x22, 0x02, 0xb9, 0x11, 0x4f, 0x77, 0x69, 0x12, 0xd4, 0x98, 0xd5, 0x53, 0x68, 0xa5,
0x67, 0x62, 0x72, 0x56, 0xd2, 0xb9, 0x59, 0xf7, 0xa4, 0xa7, 0x68, 0x6d, 0x0a, 0xfd, 0x1c, 0xe6,
0x72, 0x83, 0x28, 0xf4, 0x2d, 0x19, 0xf9, 0xa2, 0x79, 0xd5, 0x69, 0x1c, 0x84, 0xf4, 0x63, 0x2d,
0x16, 0x4b, 0x9f, 0x9b, 0x48, 0x4e, 0x2e, 0x7d, 0x82, 0xfc, 0x49, 0xd2, 0x9f, 0x99, 0xc3, 0x08,
0x50, 0x7e, 0x14, 0x85, 0x3e, 0x91, 0xb1, 0x28, 0x1c, 0x87, 0x75, 0x97, 0x27, 0x45, 0x8f, 0x4d,
0x3e, 0xe2, 0xd1, 0x9a, 0xed, 0xc0, 0xa5, 0x6c, 0x0b, 0xc7, 0x4f, 0x72, 0xb6, 0xc5, 0x13, 0xa0,
0xd0, 0xa9, 0xd3, 0x13, 0x0e, 0xb9, 0xad, 0xa4, 0x53, 0x19, 0xb9, 0x53, 0xcb, 0x07, 0x26, 0xda,
0x14, 0xda, 0x4b, 0xe5, 0x60, 0x74, 0xab, 0xc8, 0x27, 0xd2, 0x57, 0xeb, 0xd3, 0xcc, 0x65, 0x00,
0x6c, 0xe2, 0xe0, 0x11, 0x0e, 0x7c, 0xbb, 0x4f, 0xb3, 0x44, 0xc5, 0xcf, 0x18, 0x21, 0x22, 0xfa,
0xd1, 0xa9, 0x78, 0x91, 0xd8, 0xab, 0xaf, 0x00, 0xea, 0xdc, 0x66, 0xac, 0x3c, 0xfc, 0x2f, 0x8d,
0x5f, 0x42, 0x1a, 0x7f, 0x06, 0xed, 0xcc, 0x78, 0x4b, 0x9e, 0xc6, 0xe5, 0x33, 0xb0, 0xd3, 0x1c,
0xa4, 0x07, 0x28, 0x3f, 0x84, 0x91, 0x07, 0x56, 0xe1, 0xb0, 0xe6, 0x34, 0x1e, 0xcf, 0xa0, 0x9d,
0x99, 0x82, 0xc8, 0x4f, 0x20, 0x1f, 0x95, 0x4c, 0x70, 0x82, 0xfc, 0xdb, 0xbf, 0xfc, 0x04, 0x85,
0x33, 0x82, 0xd3, 0x78, 0x7c, 0x01, 0xcd, 0xe4, 0xab, 0x2b, 0xfa, 0xa8, 0x28, 0x3a, 0x33, 0xef,
0x70, 0x6f, 0x3e, 0x5f, 0x5f, 0x7e, 0x3d, 0x7b, 0x06, 0xed, 0xcc, 0x2b, 0xab, 0xdc, 0xba, 0xf2,
0xa7, 0xd8, 0xd3, 0xa8, 0x7f, 0x83, 0x19, 0xf8, 0xb2, 0x73, 0xe5, 0xda, 0x77, 0x9e, 0xae, 0x0e,
0xec, 0xe0, 0x60, 0xd4, 0x63, 0xa7, 0x5c, 0x09, 0x31, 0x3f, 0xb1, 0x89, 0xf8, 0x5a, 0x89, 0x92,
0xc6, 0x0a, 0xa7, 0xb4, 0xc2, 0xa5, 0x1d, 0xf6, 0x7a, 0x35, 0xfe, 0x7b, 0xf7, 0x3f, 0x01, 0x00,
0x00, 0xff, 0xff, 0x04, 0xe5, 0x43, 0x04, 0x73, 0x28, 0x00, 0x00,
// 2241 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0x4d, 0x73, 0xdc, 0x48,
0xd5, 0x9a, 0x2f, 0x7b, 0xde, 0x8c, 0x67, 0xe4, 0x4e, 0xec, 0x9d, 0x0c, 0xbb, 0xd9, 0xac, 0x76,
0x93, 0x0d, 0x59, 0xd6, 0x09, 0x0e, 0x50, 0x6c, 0x01, 0x87, 0xd8, 0x26, 0x5e, 0x93, 0x8d, 0x63,
0x64, 0x67, 0x29, 0x52, 0xa9, 0x12, 0x9a, 0x51, 0x7b, 0xac, 0x8a, 0xa4, 0x9e, 0xa8, 0x35, 0x6b,
0x3b, 0x67, 0x0e, 0x70, 0xa0, 0xf8, 0x01, 0x50, 0x5c, 0x80, 0x82, 0x54, 0xb1, 0x47, 0xee, 0xb9,
0xf0, 0x13, 0xb8, 0x52, 0x1c, 0xe0, 0x27, 0x70, 0xa7, 0xba, 0xd5, 0xd2, 0xe8, 0xa3, 0x65, 0xcb,
0x76, 0x79, 0x93, 0xa2, 0xb8, 0x49, 0xaf, 0x5f, 0xbf, 0xf7, 0xfa, 0x7d, 0x77, 0x3f, 0x58, 0x78,
0x3e, 0xc1, 0xfe, 0x91, 0x31, 0x24, 0xc4, 0xb7, 0x96, 0xc7, 0x3e, 0x09, 0x08, 0x42, 0xae, 0xed,
0x7c, 0x31, 0xa1, 0xe1, 0xdf, 0x32, 0x5f, 0xef, 0xb7, 0x87, 0xc4, 0x75, 0x89, 0x17, 0xc2, 0xfa,
0xed, 0x24, 0x46, 0xbf, 0x63, 0x7b, 0x01, 0xf6, 0x3d, 0xd3, 0x89, 0x56, 0xe9, 0x70, 0x1f, 0xbb,
0xa6, 0xf8, 0x53, 0x2d, 0x33, 0x30, 0x93, 0xf4, 0xfb, 0x0b, 0xb6, 0x67, 0xe1, 0xc3, 0x24, 0x48,
0xfb, 0xb9, 0x02, 0x4b, 0x3b, 0xfb, 0xe4, 0x60, 0x8d, 0x38, 0x0e, 0x1e, 0x06, 0x36, 0xf1, 0xa8,
0x8e, 0x9f, 0x4f, 0x30, 0x0d, 0xd0, 0x1d, 0xa8, 0x0d, 0x4c, 0x8a, 0x7b, 0xca, 0x35, 0xe5, 0x66,
0x6b, 0xe5, 0xed, 0xe5, 0x94, 0x70, 0x42, 0xaa, 0x87, 0x74, 0xb4, 0x6a, 0x52, 0xac, 0x73, 0x4c,
0x84, 0xa0, 0x66, 0x0d, 0x36, 0xd7, 0x7b, 0x95, 0x6b, 0xca, 0xcd, 0xaa, 0xce, 0xbf, 0xd1, 0x07,
0x30, 0x3f, 0x8c, 0x69, 0x6f, 0xae, 0xd3, 0x5e, 0xf5, 0x5a, 0xf5, 0x66, 0x55, 0x4f, 0x03, 0xb5,
0x3f, 0x29, 0xf0, 0x56, 0x4e, 0x0c, 0x3a, 0x26, 0x1e, 0xc5, 0xe8, 0x2e, 0x34, 0x68, 0x60, 0x06,
0x13, 0x2a, 0x24, 0xf9, 0x9a, 0x54, 0x92, 0x1d, 0x8e, 0xa2, 0x0b, 0xd4, 0x3c, 0xdb, 0x8a, 0x84,
0x2d, 0xfa, 0x26, 0x5c, 0xb6, 0xbd, 0x87, 0xd8, 0x25, 0xfe, 0x91, 0x31, 0xc6, 0xfe, 0x10, 0x7b,
0x81, 0x39, 0xc2, 0x91, 0x8c, 0x97, 0xa2, 0xb5, 0xed, 0xe9, 0x92, 0xf6, 0x47, 0x05, 0x16, 0x99,
0xa4, 0xdb, 0xa6, 0x1f, 0xd8, 0x17, 0xa0, 0x2f, 0x0d, 0xda, 0x49, 0x19, 0x7b, 0x55, 0xbe, 0x96,
0x82, 0x31, 0x9c, 0x71, 0xc4, 0x9e, 0x9d, 0xad, 0xc6, 0xc5, 0x4d, 0xc1, 0xb4, 0x3f, 0x08, 0xc3,
0x26, 0xe5, 0x3c, 0x8f, 0x42, 0xb3, 0x3c, 0x2b, 0x79, 0x9e, 0x67, 0x51, 0xe7, 0x2b, 0x05, 0x16,
0x3f, 0x23, 0xa6, 0x35, 0x35, 0xfc, 0x57, 0xaf, 0xce, 0x1f, 0x40, 0x23, 0x0c, 0x9c, 0x5e, 0x8d,
0xf3, 0xba, 0x9e, 0xe6, 0x25, 0x82, 0x6a, 0x2a, 0xe1, 0x0e, 0x07, 0xe8, 0x62, 0x93, 0xf6, 0x5b,
0x05, 0x7a, 0x3a, 0x76, 0xb0, 0x49, 0xf1, 0xeb, 0x3c, 0xc5, 0x12, 0x34, 0x3c, 0x62, 0xe1, 0xcd,
0x75, 0x7e, 0x8a, 0xaa, 0x2e, 0xfe, 0xb4, 0x7f, 0x09, 0x0d, 0xbf, 0xe1, 0x0e, 0x9b, 0xb0, 0x42,
0xfd, 0x2c, 0x56, 0x78, 0x35, 0xb5, 0xc2, 0x9b, 0x7e, 0xd2, 0xa9, 0xa5, 0xea, 0x29, 0x4b, 0xfd,
0x14, 0xae, 0xac, 0xf9, 0xd8, 0x0c, 0xf0, 0x8f, 0x59, 0xe6, 0x5f, 0xdb, 0x37, 0x3d, 0x0f, 0x3b,
0xd1, 0x11, 0xb2, 0xcc, 0x15, 0x09, 0xf3, 0x1e, 0xcc, 0x8e, 0x7d, 0x72, 0x78, 0x14, 0xcb, 0x1d,
0xfd, 0x6a, 0x7f, 0x56, 0xa0, 0x2f, 0xa3, 0x7d, 0x9e, 0x8c, 0xf0, 0x3e, 0xcc, 0x8b, 0x12, 0x16,
0x52, 0xe3, 0x3c, 0x9b, 0x7a, 0xfb, 0x79, 0x82, 0x03, 0xba, 0x03, 0x97, 0x43, 0x24, 0x1f, 0xd3,
0x89, 0x13, 0xc4, 0xb8, 0x55, 0x8e, 0x8b, 0xf8, 0x9a, 0xce, 0x97, 0xc4, 0x0e, 0xed, 0xa5, 0x02,
0x57, 0x36, 0x70, 0x10, 0x1b, 0x91, 0x71, 0xc5, 0x6f, 0x68, 0x92, 0xfd, 0x52, 0x81, 0xbe, 0x4c,
0xd6, 0xf3, 0xa8, 0xf5, 0x09, 0x2c, 0xc5, 0x3c, 0x0c, 0x0b, 0xd3, 0xa1, 0x6f, 0x8f, 0xb9, 0x33,
0xf3, 0x94, 0xdb, 0x5a, 0x79, 0x7f, 0x39, 0xdf, 0x25, 0x2c, 0x67, 0x25, 0x58, 0x8c, 0x49, 0xac,
0x27, 0x28, 0x68, 0xbf, 0x52, 0x60, 0x71, 0x03, 0x07, 0x3b, 0x78, 0xe4, 0x62, 0x2f, 0xd8, 0xf4,
0xf6, 0xc8, 0xd9, 0xf5, 0x7a, 0x15, 0x80, 0x0a, 0x3a, 0x71, 0x39, 0x48, 0x40, 0xca, 0xe8, 0x98,
0x77, 0x1f, 0x59, 0x79, 0xce, 0xa3, 0xbb, 0x6f, 0x43, 0xdd, 0xf6, 0xf6, 0x48, 0xa4, 0xaa, 0x77,
0x65, 0xaa, 0x4a, 0x32, 0x0b, 0xb1, 0xb5, 0xbf, 0x56, 0x61, 0xe9, 0x9e, 0x65, 0xc9, 0xc2, 0xee,
0xf4, 0x7a, 0x99, 0x46, 0x77, 0x25, 0x19, 0xdd, 0xa5, 0x7c, 0x2e, 0x17, 0x52, 0xb5, 0x53, 0x84,
0x54, 0xbd, 0x28, 0xa4, 0xd0, 0x77, 0xe0, 0xad, 0x91, 0x43, 0x06, 0xa6, 0x63, 0x50, 0x6c, 0x3a,
0xd8, 0x32, 0x62, 0x33, 0xf5, 0x1a, 0xdc, 0x6e, 0x8b, 0xe1, 0xf2, 0x0e, 0x5f, 0x8d, 0x14, 0xb4,
0x8e, 0x36, 0x60, 0x9e, 0x62, 0xfc, 0xcc, 0x18, 0x13, 0xca, 0x7d, 0xa9, 0x37, 0xcb, 0xb5, 0xa0,
0xa5, 0xb5, 0x10, 0x37, 0xa1, 0x0f, 0xe9, 0x68, 0x5b, 0x60, 0xea, 0x6d, 0xb6, 0x31, 0xfa, 0x43,
0x8f, 0x61, 0x49, 0x2a, 0x00, 0xed, 0xcd, 0x95, 0x33, 0xd4, 0x65, 0x89, 0x80, 0x54, 0xfb, 0xa7,
0x02, 0x57, 0x74, 0xec, 0x92, 0x2f, 0xf0, 0xff, 0xaa, 0xe9, 0xb4, 0x7f, 0x57, 0x60, 0xe9, 0x27,
0x66, 0x30, 0xdc, 0x5f, 0x77, 0x05, 0x88, 0xbe, 0x9e, 0xf3, 0x95, 0x29, 0x6c, 0x71, 0xf8, 0xd5,
0x65, 0x56, 0x65, 0xd7, 0x91, 0xe5, 0xcf, 0xc5, 0x91, 0x13, 0xe1, 0x97, 0xa8, 0xfc, 0x8d, 0x33,
0x54, 0x7e, 0xb4, 0x06, 0xf3, 0xf8, 0x70, 0xe8, 0x4c, 0x2c, 0x6c, 0x84, 0xdc, 0x67, 0x39, 0xf7,
0xab, 0x12, 0xee, 0x49, 0x97, 0x6a, 0x8b, 0x4d, 0x9b, 0x3c, 0x05, 0xbc, 0x52, 0xe0, 0x4a, 0xa8,
0x67, 0xec, 0x04, 0xe6, 0xeb, 0x55, 0x75, 0xac, 0xc6, 0xda, 0x69, 0xd4, 0xa8, 0xfd, 0xbe, 0x06,
0x5d, 0x71, 0x40, 0xd6, 0xef, 0xb1, 0x25, 0xf4, 0x36, 0x34, 0xa7, 0xb1, 0x1e, 0xb6, 0x0c, 0x53,
0x00, 0xba, 0x06, 0xad, 0x84, 0xfd, 0x84, 0xa4, 0x49, 0x50, 0x29, 0x71, 0xa3, 0x02, 0x5b, 0x4b,
0x14, 0xd8, 0x77, 0x00, 0xf6, 0x9c, 0x09, 0xdd, 0x37, 0x02, 0xdb, 0xc5, 0xa2, 0xcd, 0x69, 0x72,
0xc8, 0xae, 0xed, 0x62, 0x74, 0x0f, 0xda, 0x03, 0xdb, 0x73, 0xc8, 0xc8, 0x18, 0x9b, 0xc1, 0x3e,
0xe5, 0x59, 0x48, 0x6e, 0xb1, 0xfb, 0x36, 0x76, 0xac, 0x55, 0x8e, 0xab, 0xb7, 0xc2, 0x3d, 0xdb,
0x6c, 0x0b, 0xba, 0x0a, 0x2d, 0x6f, 0xe2, 0x1a, 0x64, 0xcf, 0xf0, 0xc9, 0x01, 0xe5, 0x99, 0xa9,
0xaa, 0x37, 0xbd, 0x89, 0xfb, 0x68, 0x4f, 0x27, 0x07, 0x14, 0x7d, 0x1f, 0x9a, 0xac, 0x28, 0x50,
0x87, 0x8c, 0xa2, 0x2c, 0x73, 0x12, 0xfd, 0xe9, 0x06, 0xb6, 0xdb, 0x62, 0x8e, 0xc0, 0x77, 0x37,
0xcb, 0xed, 0x8e, 0x37, 0xa0, 0x1b, 0xd0, 0x19, 0x12, 0x77, 0x6c, 0x72, 0x0d, 0xdd, 0xf7, 0x89,
0xdb, 0x03, 0x1e, 0x2d, 0x19, 0x28, 0x7a, 0x0f, 0xda, 0xd8, 0x33, 0x07, 0x0e, 0x73, 0x5c, 0x0b,
0x1f, 0xf6, 0x5a, 0xd7, 0x94, 0x9b, 0x73, 0x7a, 0x2b, 0x84, 0x6d, 0x32, 0x10, 0x7a, 0x04, 0x6a,
0x78, 0x69, 0x67, 0x8a, 0x12, 0xfe, 0xdd, 0xe6, 0xf2, 0x5c, 0xcf, 0x66, 0x61, 0x0b, 0x1f, 0x2e,
0xf3, 0x4d, 0xf7, 0x6d, 0x07, 0x33, 0x25, 0x71, 0xe7, 0xe8, 0xf0, 0x85, 0xe8, 0x97, 0x6a, 0x2f,
0x2b, 0x70, 0x89, 0xb9, 0x47, 0x94, 0x44, 0xcf, 0xee, 0xe2, 0xef, 0x00, 0x58, 0x34, 0x30, 0x52,
0x6e, 0xde, 0xb4, 0x68, 0xb0, 0x15, 0x7a, 0xfa, 0x27, 0x91, 0x17, 0x57, 0x8b, 0xdb, 0x96, 0x8c,
0xbb, 0xe6, 0x13, 0xc2, 0x59, 0x2e, 0x64, 0x2c, 0x15, 0x53, 0x32, 0xf1, 0x87, 0xd8, 0x48, 0xb5,
0xd9, 0xed, 0x10, 0xb8, 0x25, 0x0f, 0xc4, 0x86, 0xa4, 0x3d, 0xf9, 0x87, 0x02, 0x4b, 0xe2, 0x4e,
0x71, 0x7e, 0x75, 0x15, 0x65, 0x84, 0x28, 0x7c, 0xaa, 0xc7, 0xf4, 0xa7, 0xb5, 0x12, 0x09, 0xb9,
0x2e, 0x49, 0xc8, 0xe9, 0x1e, 0xad, 0x91, 0xed, 0xd1, 0xb4, 0x5f, 0x2b, 0xb0, 0xf4, 0xa9, 0xe9,
0x59, 0x64, 0x6f, 0xef, 0xfc, 0x07, 0x5c, 0x83, 0x36, 0x9d, 0xe6, 0xd7, 0xd2, 0x3d, 0x58, 0x6a,
0x93, 0xf6, 0x8b, 0x0a, 0x20, 0xe6, 0x0e, 0xab, 0xa6, 0x63, 0x7a, 0x43, 0x7c, 0x76, 0x69, 0xae,
0x43, 0x27, 0xe5, 0x04, 0xf1, 0x0b, 0x50, 0xd2, 0x0b, 0x28, 0x7a, 0x00, 0x9d, 0x41, 0xc8, 0xca,
0xf0, 0xb1, 0x49, 0x89, 0xc7, 0xed, 0xd0, 0x59, 0xf9, 0x40, 0x26, 0xf6, 0xae, 0x6f, 0x8f, 0x46,
0xd8, 0x5f, 0x23, 0x9e, 0x15, 0x76, 0x39, 0xf3, 0x83, 0x48, 0x4c, 0xb6, 0x15, 0xbd, 0x0b, 0xad,
0x69, 0x44, 0x44, 0x25, 0x12, 0xe2, 0x90, 0xa0, 0xe8, 0x23, 0x58, 0xc8, 0x76, 0x60, 0x91, 0xe1,
0x54, 0x9a, 0x6e, 0xbe, 0xa8, 0xf6, 0x1b, 0x05, 0x50, 0x5c, 0xf5, 0x79, 0x6d, 0xe2, 0x29, 0xbd,
0xcc, 0x45, 0xf0, 0x2a, 0x40, 0x54, 0x20, 0xc4, 0xc1, 0x9b, 0x7a, 0x02, 0xc2, 0xca, 0x82, 0x15,
0x51, 0x16, 0x57, 0xb1, 0x29, 0x80, 0xc5, 0x4f, 0x78, 0x04, 0xc3, 0x21, 0xa6, 0x85, 0xad, 0xc8,
0xfd, 0x42, 0xe0, 0x67, 0x1c, 0xa6, 0x7d, 0x59, 0x01, 0x35, 0xd9, 0x75, 0x95, 0x96, 0xed, 0x62,
0xae, 0x8d, 0xc7, 0xb4, 0x98, 0xb5, 0x73, 0xb4, 0x98, 0xf9, 0x16, 0xb8, 0x7e, 0xb6, 0x16, 0x58,
0xfb, 0x9d, 0x02, 0xdd, 0xcc, 0x2d, 0x2d, 0x5b, 0x7f, 0x95, 0x7c, 0xfd, 0xfd, 0x2e, 0xd4, 0x59,
0x51, 0xc2, 0x5c, 0x49, 0x9d, 0x2c, 0x5b, 0xd9, 0xdd, 0x4f, 0x0f, 0x37, 0xa0, 0xdb, 0x70, 0x49,
0xf2, 0x16, 0x27, 0xb2, 0x0c, 0xca, 0x3f, 0xc5, 0x69, 0x7f, 0xa9, 0x41, 0x2b, 0xa1, 0x8f, 0x13,
0x5a, 0x87, 0xac, 0xa5, 0x2b, 0x12, 0x4b, 0x67, 0x8e, 0x57, 0xcd, 0x1f, 0xaf, 0xe0, 0xcd, 0x0a,
0x5d, 0x81, 0x39, 0x17, 0xbb, 0x06, 0xb5, 0x5f, 0x44, 0xcd, 0xc3, 0xac, 0x8b, 0xdd, 0x1d, 0xfb,
0x05, 0x66, 0x4b, 0xac, 0xee, 0xf3, 0xa2, 0x1f, 0xe6, 0xec, 0x59, 0x6f, 0xe2, 0xf2, 0x92, 0xff,
0x0e, 0x40, 0x58, 0x2b, 0x3d, 0xd3, 0xc5, 0xbc, 0x23, 0x68, 0xea, 0x4d, 0x0e, 0xd9, 0x32, 0x5d,
0x8c, 0x7a, 0x30, 0xcb, 0x7f, 0x36, 0xd7, 0x7b, 0x73, 0xe1, 0x46, 0xf1, 0x9b, 0x0e, 0x87, 0x66,
0x36, 0x1c, 0xca, 0x56, 0xf3, 0x3b, 0x70, 0x69, 0xc8, 0x9f, 0x58, 0xac, 0xd5, 0xa3, 0xb5, 0x78,
0x49, 0x14, 0x75, 0xd9, 0x12, 0xba, 0xcf, 0x9c, 0x8b, 0x6b, 0xd4, 0x08, 0xad, 0xdc, 0xe6, 0x56,
0x7e, 0x4f, 0x7e, 0xd5, 0x0d, 0x31, 0x43, 0x23, 0x47, 0x49, 0x93, 0xff, 0xe5, 0xfa, 0x88, 0xf9,
0x72, 0x7d, 0x44, 0xe7, 0x3c, 0x7d, 0xc4, 0xdf, 0xab, 0xd0, 0x99, 0x56, 0xe0, 0xd2, 0xd1, 0x5f,
0xe6, 0x19, 0x79, 0x0b, 0xd4, 0xe9, 0x0b, 0x08, 0x57, 0xcc, 0xb1, 0x4d, 0x44, 0xf6, 0xed, 0xa3,
0x3b, 0xce, 0x84, 0xd9, 0x03, 0x98, 0x17, 0xf9, 0xc3, 0x48, 0xf6, 0xd5, 0x37, 0x64, 0xc4, 0xf2,
0x09, 0x57, 0x6f, 0x27, 0x7a, 0x6d, 0x8a, 0x3e, 0x81, 0x26, 0xcb, 0x8a, 0x46, 0x70, 0x34, 0x0e,
0x7d, 0xb3, 0x93, 0x2d, 0x47, 0x21, 0x21, 0x96, 0x26, 0x77, 0x8f, 0xc6, 0x58, 0x9f, 0x73, 0xc4,
0xd7, 0x79, 0xef, 0x39, 0x77, 0x61, 0xd1, 0x0f, 0x9b, 0x11, 0xcb, 0x48, 0xe9, 0x70, 0x96, 0xeb,
0xf0, 0x72, 0xb4, 0xb8, 0x9d, 0xd4, 0x65, 0x41, 0x1a, 0x98, 0x2b, 0x4c, 0x03, 0xff, 0x51, 0x60,
0x41, 0xb8, 0x1a, 0xd3, 0xc4, 0x88, 0xdf, 0x8f, 0x58, 0xd2, 0x26, 0x9e, 0x63, 0x7b, 0x71, 0x4b,
0x25, 0x6c, 0x1b, 0x02, 0x45, 0x4b, 0xf5, 0x29, 0x74, 0x05, 0x52, 0x9c, 0x7b, 0x4b, 0xf6, 0x00,
0x9d, 0x70, 0x5f, 0x9c, 0x75, 0xaf, 0x43, 0x87, 0xec, 0xed, 0x25, 0xf9, 0x85, 0xc9, 0x63, 0x5e,
0x40, 0x05, 0xc3, 0x1f, 0x81, 0x1a, 0xa1, 0x9d, 0x36, 0xdb, 0x77, 0xc5, 0xc6, 0xf8, 0x2d, 0xe1,
0x97, 0x0a, 0xf4, 0xd2, 0xb9, 0x3f, 0x71, 0xfc, 0xd3, 0xb7, 0x1f, 0xdf, 0x4b, 0xbf, 0x44, 0x5d,
0x3f, 0x46, 0x9e, 0x29, 0x1f, 0xd1, 0xff, 0xde, 0x7a, 0x01, 0x9d, 0xb4, 0x53, 0xa3, 0x36, 0xcc,
0x6d, 0x91, 0xe0, 0x87, 0x87, 0x36, 0x0d, 0xd4, 0x19, 0xd4, 0x01, 0xd8, 0x22, 0xc1, 0xb6, 0x8f,
0x29, 0xf6, 0x02, 0x55, 0x41, 0x00, 0x8d, 0x47, 0xde, 0xba, 0x4d, 0x9f, 0xa9, 0x15, 0x74, 0x49,
0x94, 0x19, 0xd3, 0xd9, 0x14, 0xc6, 0x55, 0xab, 0x6c, 0x7b, 0xfc, 0x57, 0x43, 0x2a, 0xb4, 0x63,
0x94, 0x8d, 0xed, 0xc7, 0x6a, 0x1d, 0x35, 0xa1, 0x1e, 0x7e, 0x36, 0x6e, 0x59, 0xa0, 0x66, 0xdb,
0x1c, 0x46, 0xf3, 0xb1, 0xf7, 0xc0, 0x23, 0x07, 0x31, 0x48, 0x9d, 0x41, 0x2d, 0x98, 0x15, 0xad,
0xa3, 0xaa, 0xa0, 0x2e, 0xb4, 0x12, 0x5d, 0x9b, 0x5a, 0x61, 0x80, 0x0d, 0x7f, 0x3c, 0x14, 0xfd,
0x5b, 0x28, 0x02, 0xb3, 0xda, 0x3a, 0x39, 0xf0, 0xd4, 0xda, 0xad, 0x7b, 0x30, 0x17, 0x05, 0x08,
0x3b, 0x4d, 0x48, 0x9d, 0xfd, 0xa9, 0x33, 0x68, 0x01, 0xe6, 0x53, 0xf3, 0x0a, 0x55, 0x41, 0x08,
0x3a, 0x4e, 0x6a, 0x48, 0xa4, 0x56, 0x56, 0xfe, 0xd6, 0x02, 0x08, 0x1b, 0x10, 0x42, 0x7c, 0x0b,
0x8d, 0x01, 0x6d, 0xe0, 0x80, 0x25, 0x57, 0xe2, 0x45, 0x89, 0x91, 0xa2, 0x3b, 0x05, 0x75, 0x3a,
0x8f, 0x2a, 0x24, 0xed, 0xdf, 0x28, 0xd8, 0x91, 0x41, 0xd7, 0x66, 0x90, 0xcb, 0x39, 0xb2, 0xfb,
0xec, 0xae, 0x3d, 0x7c, 0x16, 0x77, 0x2e, 0xc5, 0x1c, 0x33, 0xa8, 0x11, 0xc7, 0x4c, 0x52, 0x13,
0x3f, 0x3b, 0x81, 0x6f, 0x7b, 0xa3, 0xe8, 0x39, 0x54, 0x9b, 0x41, 0xcf, 0xe1, 0xf2, 0x06, 0xe6,
0xdc, 0x6d, 0x1a, 0xd8, 0x43, 0x1a, 0x31, 0x5c, 0x29, 0x66, 0x98, 0x43, 0x3e, 0x25, 0x4b, 0x07,
0xba, 0x99, 0xa1, 0x2c, 0xba, 0x25, 0x75, 0x64, 0xe9, 0x00, 0xb9, 0xff, 0x51, 0x29, 0xdc, 0x98,
0x9b, 0x0d, 0x9d, 0xf4, 0xc0, 0x12, 0x7d, 0xbd, 0x88, 0x40, 0x6e, 0xc2, 0xd3, 0xbf, 0x55, 0x06,
0x35, 0x66, 0xf5, 0x04, 0x3a, 0xe9, 0x91, 0x98, 0x9c, 0x95, 0x74, 0x6c, 0xd6, 0x3f, 0xee, 0x25,
0x5a, 0x9b, 0x41, 0x3f, 0x83, 0x85, 0xdc, 0x1c, 0x0a, 0x7d, 0x43, 0x46, 0xbe, 0x68, 0x5c, 0x75,
0x12, 0x07, 0x21, 0xfd, 0x54, 0x8b, 0xc5, 0xd2, 0xe7, 0x06, 0x92, 0xe5, 0xa5, 0x4f, 0x90, 0x3f,
0x4e, 0xfa, 0x53, 0x73, 0x98, 0x00, 0xca, 0x4f, 0xa2, 0xd0, 0xc7, 0x32, 0x16, 0x85, 0xd3, 0xb0,
0xfe, 0x72, 0x59, 0xf4, 0xd8, 0xe4, 0x13, 0x1e, 0xad, 0xd9, 0x0e, 0x5c, 0xca, 0xb6, 0x70, 0xfa,
0x24, 0x67, 0x5b, 0x3c, 0x00, 0x0a, 0x9d, 0x3a, 0x3d, 0xe0, 0x90, 0xdb, 0x4a, 0x3a, 0x94, 0x91,
0x3b, 0xb5, 0x7c, 0x5e, 0xa2, 0xcd, 0xa0, 0xdd, 0x54, 0x0e, 0x46, 0x37, 0x8a, 0x7c, 0x22, 0x7d,
0xb5, 0x3e, 0xc9, 0x5c, 0x06, 0xc0, 0x06, 0x0e, 0x1e, 0xe2, 0xc0, 0xb7, 0x87, 0x34, 0x4b, 0x54,
0xfc, 0x4c, 0x11, 0x22, 0xa2, 0x1f, 0x9e, 0x88, 0x17, 0x89, 0xbd, 0xf2, 0x12, 0xa0, 0xc9, 0x6d,
0xc6, 0xca, 0xc3, 0xff, 0xd3, 0xf8, 0x05, 0xa4, 0xf1, 0xa7, 0xd0, 0xcd, 0x4c, 0xb7, 0xe4, 0x69,
0x5c, 0x3e, 0x02, 0x3b, 0xc9, 0x41, 0x06, 0x80, 0xf2, 0x33, 0x18, 0x79, 0x60, 0x15, 0xce, 0x6a,
0x4e, 0xe2, 0xf1, 0x14, 0xba, 0x99, 0x21, 0x88, 0xfc, 0x04, 0xf2, 0x49, 0x49, 0x89, 0x13, 0xe4,
0x9f, 0xfe, 0xe5, 0x27, 0x28, 0x1c, 0x11, 0x9c, 0xc4, 0xe3, 0x73, 0x68, 0x27, 0x5f, 0x5d, 0xd1,
0x87, 0x45, 0xd1, 0x99, 0x79, 0x87, 0x7b, 0xfd, 0xf9, 0xfa, 0xe2, 0xeb, 0xd9, 0x53, 0xe8, 0x66,
0x5e, 0x59, 0xe5, 0xd6, 0x95, 0x3f, 0xc5, 0x9e, 0x44, 0xfd, 0x2b, 0xcc, 0xc0, 0x17, 0x9d, 0x2b,
0x57, 0xbf, 0xf5, 0x64, 0x65, 0x64, 0x07, 0xfb, 0x93, 0x01, 0x3b, 0xe5, 0xed, 0x10, 0xf3, 0x63,
0x9b, 0x88, 0xaf, 0xdb, 0x51, 0xd2, 0xb8, 0xcd, 0x29, 0xdd, 0xe6, 0xd2, 0x8e, 0x07, 0x83, 0x06,
0xff, 0xbd, 0xfb, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x8c, 0x66, 0xd7, 0x72, 0x28, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

4
internal/querycoord/cluster.go
View File

@ -843,9 +843,9 @@ func estimateSegmentsSize(segments *querypb.LoadSegmentsRequest, kvClient kv.Dat
// get binlog size
for _, binlogPath := range loadInfo.BinlogPaths {
for _, path := range binlogPath.Binlogs {
binlogSize, err := storage.EstimateMemorySize(kvClient, path)
binlogSize, err := storage.EstimateMemorySize(kvClient, path.GetLogPath())
if err != nil {
binlogSize, err = storage.GetBinlogSize(kvClient, path)
binlogSize, err = storage.GetBinlogSize(kvClient, path.GetLogPath())
if err != nil {
return 0, err
}

4
internal/querycoord/cluster_test.go
View File

@ -269,7 +269,7 @@ func saveBinLog(ctx context.Context,
kvs[key] = string(blob.Value[:])
fieldBinlog = append(fieldBinlog, &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: []string{key},
Binlogs: []*datapb.Binlog{{LogPath: key}},
})
}
log.Debug("[query coord unittest] save binlog file to MinIO/S3")
@ -665,7 +665,7 @@ func TestEstimateSegmentSize(t *testing.T) {
binlog := []*datapb.FieldBinlog{
{
FieldID: simpleConstField.id,
Binlogs: []string{"^&^%*&%&&(*^*&"},
Binlogs: []*datapb.Binlog{{LogPath: "^&^%*&%&&(*^*&"}},
},
}

2
internal/querycoord/mock_3rd_component_test.go
View File

@ -351,7 +351,7 @@ func (data *dataCoordMock) GetRecoveryInfo(ctx context.Context, req *datapb.GetR
for fieldID, path := range fieldID2Paths {
fieldBinlog := &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: []string{path},
Binlogs: []*datapb.Binlog{{LogPath: path}},
}
fieldBinlogs = append(fieldBinlogs, fieldBinlog)
}

2
internal/querycoord/task_scheduler_test.go
View File

@ -70,7 +70,7 @@ func (tt *testTask) execute(ctx context.Context) error {
binlogs := make([]*datapb.FieldBinlog, 0)
binlogs = append(binlogs, &datapb.FieldBinlog{
FieldID: 0,
Binlogs: []string{funcutil.RandomString(tt.binlogSize)},
Binlogs: []*datapb.Binlog{{LogPath: funcutil.RandomString(tt.binlogSize)}},
})
for id := 0; id < 10; id++ {
segmentInfo := &querypb.SegmentLoadInfo{

2
internal/querycoord/task_test.go
View File

@ -688,7 +688,7 @@ func Test_AssignInternalTask(t *testing.T) {
binlogs := make([]*datapb.FieldBinlog, 0)
binlogs = append(binlogs, &datapb.FieldBinlog{
FieldID: 0,
Binlogs: []string{funcutil.RandomString(1000)},
Binlogs: []*datapb.Binlog{{LogPath: funcutil.RandomString(1000)}},
})
for id := 0; id < 3000; id++ {
segmentInfo := &querypb.SegmentLoadInfo{

2
internal/querynode/mock_test.go
View File

@ -673,7 +673,7 @@ func saveBinLog(ctx context.Context,
kvs[key] = string(blob.Value[:])
fieldBinlog = append(fieldBinlog, &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: []string{key},
Binlogs: []*datapb.Binlog{{LogPath: key}},
})
}
log.Debug("[query node unittest] save binlog file to MinIO/S3")

2
internal/querynode/segment.go
View File

@ -374,7 +374,7 @@ func (s *Segment) fillVectorFieldsData(collectionID UniqueID,
var vecPath string
for index, idBinlogRowSize := range s.idBinlogRowSizes {
if offset < idBinlogRowSize {
vecPath = vecFieldInfo.fieldBinlog.Binlogs[index]
vecPath = vecFieldInfo.fieldBinlog.Binlogs[index].GetLogPath()
break
} else {
offset -= idBinlogRowSize

45
internal/querynode/segment_loader.go
View File

@ -216,7 +216,9 @@ func (loader *segmentLoader) filterPKStatsBinlogs(fieldBinlogs []*datapb.FieldBi
result := make([]string, 0)
for _, fieldBinlog := range fieldBinlogs {
if fieldBinlog.FieldID == pkFieldID {
result = append(result, fieldBinlog.Binlogs...)
for _, binlog := range fieldBinlog.GetBinlogs() {
result = append(result, binlog.GetLogPath())
}
}
}
return result
@ -242,14 +244,13 @@ func (loader *segmentLoader) loadSegmentFieldsData(segment *Segment, fieldBinlog
zap.String("paths", fmt.Sprintln(fb.Binlogs)),
)
for _, path := range fb.Binlogs {
p := path
binLog, err := loader.minioKV.Load(path)
binLog, err := loader.minioKV.Load(path.GetLogPath())
if err != nil {
// TODO: return or continue?
return err
}
blob := &storage.Blob{
Key: p,
Key: path.GetLogPath(),
Value: []byte(binLog),
}
blobs = append(blobs, blob)
@ -423,24 +424,26 @@ func (loader *segmentLoader) loadSegmentBloomFilter(segment *Segment, binlogPath
return nil
}
func (loader *segmentLoader) loadDeltaLogs(segment *Segment, deltaLogs []*datapb.DeltaLogInfo) error {
if len(deltaLogs) == 0 {
func (loader *segmentLoader) loadDeltaLogs(segment *Segment, deltaLogs []*datapb.FieldBinlog) error {
dCodec := storage.DeleteCodec{}
var blobs []*storage.Blob
for _, deltaLog := range deltaLogs {
for _, log := range deltaLog.GetBinlogs() {
value, err := loader.minioKV.Load(log.GetLogPath())
if err != nil {
return err
}
blob := &storage.Blob{
Key: log.GetLogPath(),
Value: []byte(value),
}
blobs = append(blobs, blob)
}
}
if len(blobs) == 0 {
log.Info("there are no delta logs saved with segment", zap.Any("segmentID", segment.segmentID))
return nil
}
dCodec := storage.DeleteCodec{}
blobs := make([]*storage.Blob, 0)
for _, deltaLog := range deltaLogs {
value, err := loader.minioKV.Load(deltaLog.DeltaLogPath)
if err != nil {
return err
}
blob := &storage.Blob{
Key: deltaLog.DeltaLogPath,
Value: []byte(value),
}
blobs = append(blobs, blob)
}
_, _, deltaData, err := dCodec.Deserialize(blobs)
if err != nil {
return err
@ -594,9 +597,9 @@ func (loader *segmentLoader) estimateSegmentSize(segment *Segment,
zap.Any("paths", fb.Binlogs),
)
for _, binlogPath := range fb.Binlogs {
logSize, err := storage.EstimateMemorySize(loader.minioKV, binlogPath)
logSize, err := storage.EstimateMemorySize(loader.minioKV, binlogPath.GetLogPath())
if err != nil {
logSize, err = storage.GetBinlogSize(loader.minioKV, binlogPath)
logSize, err = storage.GetBinlogSize(loader.minioKV, binlogPath.GetLogPath())
if err != nil {
return 0, err
}

2
internal/querynode/segment_loader_test.go
View File

@ -326,7 +326,7 @@ func TestSegmentLoader_estimateSegmentSize(t *testing.T) {
binlog := []*datapb.FieldBinlog{
{
FieldID: simpleConstField.id,
Binlogs: []string{"^&^%*&%&&(*^*&"},
Binlogs: []*datapb.Binlog{{LogPath: "^&^%*&%&&(*^*&"}},
},
}

4
internal/querynode/segment_test.go
View File

@ -1041,7 +1041,7 @@ func TestSegment_BasicMetrics(t *testing.T) {
info := &VectorFieldInfo{
fieldBinlog: &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: []string{},
Binlogs: []*datapb.Binlog{},
},
}
segment.setVectorFieldInfo(fieldID, info)
@ -1078,7 +1078,7 @@ func TestSegment_fillVectorFieldsData(t *testing.T) {
info := &VectorFieldInfo{
fieldBinlog: &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: []string{},
Binlogs: []*datapb.Binlog{},
},
}
segment.setVectorFieldInfo(fieldID, info)