From 1217deee1c275fbebca655641c72249d948b3558 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kuba=20Podg=C3=B3rski?= Date: Wed, 8 Apr 2020 01:01:15 +0200 Subject: [PATCH] Rebase --- cache.go | 7 + encoding/proto/proto.go | 6 + executor.go | 94 ++++-- executor_test.go | 214 ++++++++++++- fragment.go | 175 +++++++++- fragment_internal_test.go | 12 +- go.sum | 2 - internal/public.pb.go | 601 ++++++++++++++++++++++++----------- internal/public.proto | 7 +- server/grpc.go | 6 +- server/grpc_internal_test.go | 9 + 11 files changed, 889 insertions(+), 244 deletions(-) diff --git a/cache.go b/cache.go index 9c0a7dc79..e48c9cf17 100644 --- a/cache.go +++ b/cache.go @@ -422,6 +422,13 @@ func (p PairsField) MarshalJSON() ([]byte, error) { return json.Marshal(p.Pairs) } +// int64Slice represents a sortable slice of int64 numbers. +type int64Slice []int64 + +func (p int64Slice) Len() int { return len(p) } +func (p int64Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p int64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + // uint64Slice represents a sortable slice of uint64 numbers. type uint64Slice []uint64 diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go index fddc84aad..3c72e1d16 100644 --- a/encoding/proto/proto.go +++ b/encoding/proto/proto.go @@ -1339,6 +1339,9 @@ func decodeFieldRows(a []*internal.FieldRow) []pilosa.FieldRow { } else { other[i].RowKey = fr.RowKey } + if fr.Value != nil { + other[i].Value = &fr.Value.Value + } } return other } @@ -1470,6 +1473,9 @@ func encodeFieldRows(a []pilosa.FieldRow) []*internal.FieldRow { Field: fr.Field, RowID: fr.RowID, } + if fr.Value != nil { + other[i].Value = &internal.Int64{Value: *fr.Value} + } } else { other[i] = &internal.FieldRow{ Field: fr.Field, diff --git a/executor.go b/executor.go index 7e74421e7..5733c4b87 100644 --- a/executor.go +++ b/executor.go @@ -20,6 +20,7 @@ import ( "fmt" "math" "sort" + "strings" "sync" "time" @@ -1685,6 +1686,7 @@ type FieldRow struct { Field string `json:"field"` RowID uint64 `json:"rowID"` RowKey string `json:"rowKey,omitempty"` + Value *int64 `json:"value,omitempty"` } // MarshalJSON marshals FieldRow to JSON such that @@ -1699,6 +1701,17 @@ func (fr FieldRow) MarshalJSON() ([]byte, error) { RowKey: fr.RowKey, }) } + + if fr.Value != nil { + return json.Marshal(struct { + Field string `json:"field"` + Value int64 `json:"value"` + }{ + Field: fr.Field, + Value: *fr.Value, + }) + } + return json.Marshal(struct { Field string `json:"field"` RowID uint64 `json:"rowID"` @@ -1710,6 +1723,9 @@ func (fr FieldRow) MarshalJSON() ([]byte, error) { // String is the FieldRow stringer. func (fr FieldRow) String() string { + if fr.Value != nil { + return fmt.Sprintf("%s.%d.%d.%s", fr.Field, fr.RowID, *fr.Value, fr.RowKey) + } return fmt.Sprintf("%s.%d.%s", fr.Field, fr.RowID, fr.RowKey) } @@ -1756,12 +1772,23 @@ func mergeGroupCounts(a, b []GroupCount, limit int) []GroupCount { // Compare is used in ordering two GroupCount objects. func (g GroupCount) Compare(o GroupCount) int { - for i := range g.Group { - if g.Group[i].RowID < o.Group[i].RowID { - return -1 - } - if g.Group[i].RowID > o.Group[i].RowID { - return 1 + for i, g1 := range g.Group { + g2 := o.Group[i] + + if g1.Value != nil && g2.Value != nil { + if *g1.Value < *g2.Value { + return -1 + } + if *g1.Value > *g2.Value { + return 1 + } + } else { + if g1.RowID < g2.RowID { + return -1 + } + if g1.RowID > g2.RowID { + return 1 + } } } return 0 @@ -1939,6 +1966,7 @@ func (e *executor) executeGroupByShard(ctx context.Context, index string, c *pql if err != nil { return nil, err } + if gc.Count > 0 { num++ results = append(results, gc) @@ -4253,7 +4281,7 @@ type groupByIterator struct { shard uint64 // rowIters contains a rowIterator for each of the fields in the Group By. - rowIters []*rowIterator + rowIters []rowIterator // rows contains the current row data for each of the fields in the Group // By. Each row is the intersection of itself and the rows of the fields // with an index lower than its own. This is a performance optimization so @@ -4261,8 +4289,9 @@ type groupByIterator struct { // field to the right require only a single intersect with the row of the // previous field to determine the count of the new group. rows []struct { - row *Row - id uint64 + row *Row + id uint64 + value *int64 } // fields helps with the construction of GroupCount results by holding all @@ -4284,29 +4313,47 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal executor: executor, index: index, shard: shard, - rowIters: make([]*rowIterator, len(children)), + rowIters: make([]rowIterator, len(children)), rows: make([]struct { - row *Row - id uint64 + row *Row + id uint64 + value *int64 }, len(children)), filter: filter, aggregate: aggregate, fields: make([]FieldRow, len(children)), } - var fieldName string - var ok bool + var ( + fieldName string + viewName string + ok bool + ) ignorePrev := false for i, call := range children { if fieldName, ok = call.Args["_field"].(string); !ok { return nil, errors.Errorf("%s call must have field with valid (string) field name. Got %v of type %[2]T", call.Name, call.Args["_field"]) } - if holder.Field(index, fieldName) == nil { + field := holder.Field(index, fieldName) + if field == nil { return nil, ErrFieldNotFound } gbi.fields[i].Field = fieldName + + switch field.Type() { + case FieldTypeSet, FieldTypeTime, FieldTypeMutex, FieldTypeBool: + viewName = viewStandard + + case FieldTypeInt: + viewName = viewBSIGroupPrefix + fieldName + + default: // FieldTypeDecimal + return nil, errors.Errorf("%s call must have field of one of types: %s", + call.Name, strings.Join([]string{FieldTypeSet, FieldTypeTime, FieldTypeMutex, FieldTypeBool, FieldTypeInt}, ",")) + } + // Fetch fragment. - frag := holder.fragment(index, fieldName, viewStandard, shard) + frag := holder.fragment(index, fieldName, viewName, shard) if frag == nil { // this means this whole shard doesn't have all it needs to continue return nil, nil } @@ -4325,13 +4372,14 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal } gbi.rowIters[i].Seek(prev) } - nextRow, rowID, wrapped := gbi.rowIters[i].Next() + nextRow, rowID, value, wrapped := gbi.rowIters[i].Next() if nextRow == nil { gbi.done = true return gbi, nil } gbi.rows[i].row = nextRow gbi.rows[i].id = rowID + gbi.rows[i].value = value if hasPrev && rowID != prev { // ignorePrev signals that we didn't find a previous row, so all // Rows queries "deeper" than it need to ignore the previous @@ -4343,13 +4391,14 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal // previous field, and if that one wraps we need to keep going // backward. for j := i - 1; j >= 0; j-- { - nextRow, rowID, wrapped := gbi.rowIters[j].Next() + nextRow, rowID, value, wrapped := gbi.rowIters[j].Next() if nextRow == nil { gbi.done = true return gbi, nil } gbi.rows[j].row = nextRow gbi.rows[j].id = rowID + gbi.rows[j].value = value if !wrapped { break } @@ -4374,7 +4423,7 @@ func newGroupByIterator(executor *executor, rowIDs []RowIDs, children []*pql.Cal func (gbi *groupByIterator) nextAtIdx(i int) { // loop until we find a non-empty row. This is an optimization - the loop and if/break can be removed. for { - nr, rowID, wrapped := gbi.rowIters[i].Next() + nr, rowID, value, wrapped := gbi.rowIters[i].Next() if nr == nil { gbi.done = true return @@ -4390,6 +4439,7 @@ func (gbi *groupByIterator) nextAtIdx(i int) { gbi.rows[i].row = nr.Intersect(gbi.rows[i-1].row) } gbi.rows[i].id = rowID + gbi.rows[i].value = value if !gbi.rows[i].row.IsEmpty() { break @@ -4412,7 +4462,8 @@ func (gbi *groupByIterator) Next(ctx context.Context) (ret GroupCount, done bool ret.Count = gbi.rows[len(gbi.rows)-1].row.intersectionCount(gbi.rows[len(gbi.rows)-2].row) } } else { - filter := gbi.rows[len(gbi.rows)-1].row + gr := gbi.rows[len(gbi.rows)-1] + filter := gr.row if len(gbi.rows) != 1 { filter = filter.Intersect(gbi.rows[len(gbi.rows)-2].row) } @@ -4437,11 +4488,12 @@ func (gbi *groupByIterator) Next(ctx context.Context) (ret GroupCount, done bool ret.Group = make([]FieldRow, len(gbi.rows)) copy(ret.Group, gbi.fields) for i, r := range gbi.rows { + ret.Group[i].RowID = r.id + ret.Group[i].Value = r.value } // set up for next call - gbi.nextAtIdx(len(gbi.rows) - 1) return ret, false, nil diff --git a/executor_test.go b/executor_test.go index 236b94662..dd0f7b811 100644 --- a/executor_test.go +++ b/executor_test.go @@ -2762,16 +2762,16 @@ func TestExecutor_Execute_Remote_Row(t *testing.T) { t.Fatalf("creating field: %v", err) } if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: ` -Set(500001, fn=5) -Set(1500001, fn=5) -Set(2500001, fn=5) -Set(3500001, fn=5) -Set(1500001, fn=3) -Set(1500002, fn=3) -Set(3500003, fn=3) -Set(500001, fn=4) -Set(4500001, fn=4) -`}); err != nil { + Set(500001, fn=5) + Set(1500001, fn=5) + Set(2500001, fn=5) + Set(3500001, fn=5) + Set(1500001, fn=3) + Set(1500002, fn=3) + Set(3500003, fn=3) + Set(500001, fn=4) + Set(4500001, fn=4) + `}); err != nil { t.Fatalf("querying remote: %v", err) } err := c[0].API.RecalculateCaches(context.Background()) @@ -2822,6 +2822,48 @@ Set(4500001, fn=4) test.CheckGroupBy(t, expected, results) } }) + + t.Run("remote groupBy on ints", func(t *testing.T) { + _, err = c[0].API.CreateField(context.Background(), "i", "fint", pilosa.OptFieldTypeInt(-1000, 1000)) + if err != nil { + t.Fatalf("creating field: %v", err) + } + if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: ` + Set(0, fint=1) + Set(1, fint=2) + + Set(2,fint=-2) + Set(3,fint=-1) + + Set(4,fint=4) + + Set(10, fint=0) + Set(100, fint=0) + Set(1000, fint=0) + Set(10000,fint=0) + Set(100000,fint=0) + `}); err != nil { + t.Fatalf("querying remote: %v", err) + } + + if res, err := c[1].API.Query(context.Background(), &pilosa.QueryRequest{ + Index: "i", + Query: `GroupBy(Rows(fint), limit=4, filter=Union(Row(fint < 1), Row(fint > 2)))`, + }); err != nil { + t.Fatalf("GroupBy querying: %v", err) + } else { + var a, b, c, d int64 = -2, -1, 0, 4 + expected := []pilosa.GroupCount{ + {Group: []pilosa.FieldRow{{Field: "fint", RowID: 0, Value: &a}}, Count: 1}, + {Group: []pilosa.FieldRow{{Field: "fint", RowID: 1, Value: &b}}, Count: 1}, + {Group: []pilosa.FieldRow{{Field: "fint", RowID: 2, Value: &c}}, Count: 5}, + {Group: []pilosa.FieldRow{{Field: "fint", RowID: 5, Value: &d}}, Count: 1}, + } + + results := res.Results[0].([]pilosa.GroupCount) + test.CheckGroupBy(t, expected, results) + } + }) } // Ensure executor returns an error if too many writes are in a single request. @@ -3890,6 +3932,7 @@ func TestExecutor_Execute_Query_Error(t *testing.T) { c := test.MustRunCluster(t, 1) defer c.Close() c.CreateField(t, "i", pilosa.IndexOptions{}, "general") + c.CreateField(t, "i", pilosa.IndexOptions{}, "integer", pilosa.OptFieldTypeInt(-1000, 1000)) tests := []struct { query string @@ -3919,6 +3962,10 @@ func TestExecutor_Execute_Query_Error(t *testing.T) { query: "GroupBy(Rows(general), filter=Rows(general))", error: "parsing: parsing:", }, + { + query: "GroupBy(Rows(integer), prev=-1)", + error: "unknown arg 'prev'", + }, } for i, test := range tests { @@ -3942,6 +3989,8 @@ func TestExecutor_GroupByStrings(t *testing.T) { defer c.Close() c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "generals", pilosa.OptFieldKeys()) c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "v", pilosa.OptFieldTypeInt(0, 1000)) + c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "vv", pilosa.OptFieldTypeInt(0, 1000)) + c.CreateField(t, "istring", pilosa.IndexOptions{Keys: true}, "nv", pilosa.OptFieldTypeInt(-1000, 1000)) if err := c[0].API.Import(context.Background(), &pilosa.ImportRequest{ Index: "istring", @@ -3953,12 +4002,34 @@ func TestExecutor_GroupByStrings(t *testing.T) { t.Fatalf("importing: %v", err) } + var v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 int64 = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 + var nv1, nv2, nv3, nv4 int64 = -1, -2, -3, -4 if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{ Index: "istring", Field: "v", Shard: 0, ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"}, - Values: []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, + Values: []int64{v1, v2, v3, v4, v5, v6, v7, v8, v9, v10}, + }); err != nil { + t.Fatalf("importing: %v", err) + } + + if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{ + Index: "istring", + Field: "vv", + Shard: 0, + ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"}, + Values: []int64{v1, v2, v2, v3, v3, v3, v4, v4, v4, v4}, + }); err != nil { + t.Fatalf("importing: %v", err) + } + + if err := c[0].API.ImportValue(context.Background(), &pilosa.ImportValueRequest{ + Index: "istring", + Field: "nv", + Shard: 0, + ColumnKeys: []string{"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10"}, + Values: []int64{nv1, nv2, nv2, nv3, nv3, nv3, nv4, nv4, nv4, nv4}, }); err != nil { t.Fatalf("importing: %v", err) } @@ -4003,6 +4074,127 @@ func TestExecutor_GroupByStrings(t *testing.T) { query: "GroupBy(Rows(generals), aggregate=Sum(field=v), having=Condition(count>5))", expected: []pilosa.GroupCount{}, }, + { + query: "GroupBy(Rows(v))", + expected: []pilosa.GroupCount{ + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v1}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v2}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v3}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v4}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v5}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v6}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v7}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v8}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v9}}, + Count: 1, + Sum: 0, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "v", Value: &v10}}, + Count: 1, + Sum: 0, + }, + }, + }, + { + query: "GroupBy(Rows(vv), aggregate=Sum(field=vv), having=Condition(count > 2))", + expected: []pilosa.GroupCount{ + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "vv", Value: &v3}}, + Count: 3, + Sum: 9, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "vv", Value: &v4}}, + Count: 4, + Sum: 16, + }, + }, + }, + { + query: "GroupBy(Rows(nv), aggregate=Sum(field=nv), limit=2)", + expected: []pilosa.GroupCount{ + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv4}}, + Count: 4, + Sum: -16, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv3}}, + Count: 3, + Sum: -9, + }, + }, + }, + { + query: "GroupBy(Rows(nv), aggregate=Sum(field=nv), having=Condition(count > 2), limit=2)", + expected: []pilosa.GroupCount{ + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv4}}, + Count: 4, + Sum: -16, + }, + { + Group: []pilosa.FieldRow{pilosa.FieldRow{Field: "nv", Value: &nv3}}, + Count: 3, + Sum: -9, + }, + }, + }, + { + query: "GroupBy(Rows(vv), Rows(nv), aggregate=Sum(field=vv), having=Condition(count > 2))", + expected: []pilosa.GroupCount{ + { + Group: []pilosa.FieldRow{ + pilosa.FieldRow{Field: "vv", Value: &v3}, + pilosa.FieldRow{Field: "nv", Value: &nv3}, + }, + Count: 3, + Sum: 9, + }, + { + Group: []pilosa.FieldRow{ + pilosa.FieldRow{Field: "vv", Value: &v4}, + pilosa.FieldRow{Field: "nv", Value: &nv4}, + }, + Count: 4, + Sum: 16, + }, + }, + }, } for i, tst := range tests { diff --git a/fragment.go b/fragment.go index c89d25c6d..c352959ad 100644 --- a/fragment.go +++ b/fragment.go @@ -2717,40 +2717,183 @@ func upgradeRoaringBSIv2(f *fragment, bitDepth uint) (string, error) { return newPath, nil } -type rowIterator struct { +type rowIterator interface { + // TODO(kuba) linter suggests to use io.Seeker + // Seek(offset int64, whence int) (int64, error) + Seek(uint64) + + Next() (*Row, uint64, *int64, bool) +} + +func (f *fragment) rowIterator(wrap bool, filters ...rowFilter) rowIterator { + if strings.HasPrefix(f.view, viewBSIGroupPrefix) { + return f.intRowIterator(wrap, filters...) + } + // viewStandard + // TODO(kuba) - IMHO we should check if f.view is viewStandard, + // but because of testing the function returns set iterator as default one. + return f.setRowIterator(wrap, filters...) +} + +type intRowIterator struct { + f *fragment + values int64Slice // sorted slice of int values + colIDs map[int64][]uint64 // [int value] -> [column IDs] + cur int // current value index (rowID) + wrap bool +} + +func (f *fragment) intRowIterator(wrap bool, filters ...rowFilter) rowIterator { + it := intRowIterator{ + f: f, + colIDs: make(map[int64][]uint64), + cur: 0, + wrap: wrap, + } + + // accumulator [column ID] -> [int value] + acc := make(map[uint64]int64) + + f.mu.RLock() + defer f.mu.RUnlock() + f.foreachRow(filters, func(rid uint64) { + // skip exist(0) and sign(1) rows + if rid == bsiExistsBit || rid == bsiSignBit { + return + } + + val := int64(1 << (rid - bsiOffsetBit)) + for _, cid := range f.unprotectedRow(rid).Columns() { + acc[cid] |= val + } + }) + + // apply exist and sign bits + allCols := f.unprotectedRow(0).Columns() + signCols := f.unprotectedRow(1).Columns() + signIdx, signLen := 0, len(signCols) + + // all distinct values + values := make(map[int64]struct{}) + for _, cid := range allCols { + // apply sign bit + if signIdx < signLen && cid == signCols[signIdx] { + if tmp, ok := acc[cid]; ok { + acc[cid] = -tmp + } + + signIdx++ + } + + val := acc[cid] + it.colIDs[val] = append(it.colIDs[val], cid) + + if _, ok := values[val]; !ok { + it.values = append(it.values, val) + values[val] = struct{}{} + } + } + sort.Sort(it.values) + + return &it +} + +func (f *fragment) foreachRow(filters []rowFilter, fn func(rid uint64)) { + var lastRow uint64 = math.MaxUint64 + i, _ := f.storage.Containers.Iterator(rowToKey(0)) + // Loop over the existing containers. + for i.Next() { + key, c := i.Value() + // virtual row for the current container + vRow := key >> shardVsContainerExponent + // skip dups + if vRow == lastRow { + continue + } + + // apply filters + addRow, done := true, false + for _, filter := range filters { + var d bool + addRow, d = filter(vRow, key, c) + done = done || d + if !addRow { + break + } + } + if addRow { + lastRow = vRow + if fn != nil { + fn(vRow) + } + } + if done { + break + } + } +} + +func (it *intRowIterator) Seek(rowID uint64) { + idx := sort.Search(len(it.values), func(i int) bool { + return it.values[i] >= it.values[rowID] + }) + it.cur = idx +} + +func (it *intRowIterator) Next() (r *Row, rowID uint64, value *int64, wrapped bool) { + if it.cur >= len(it.values) { + if !it.wrap || len(it.values) == 0 { + return nil, 0, nil, true + } + wrapped = true + it.cur = 0 + } + if it.cur >= 0 { + rowID = uint64(it.cur) + value = &it.values[rowID] + r = NewRow(it.colIDs[*value]...) + } + it.cur++ + return r, rowID, value, wrapped +} + +type setRowIterator struct { f *fragment rowIDs []uint64 cur int wrap bool } -func (f *fragment) rowIterator(wrap bool, filters ...rowFilter) *rowIterator { - return &rowIterator{ +func (f *fragment) setRowIterator(wrap bool, filters ...rowFilter) rowIterator { + return &setRowIterator{ f: f, rowIDs: f.rows(0, filters...), // TODO: this may be memory intensive in high cardinality cases wrap: wrap, } } -func (ri *rowIterator) Seek(rowID uint64) { - idx := sort.Search(len(ri.rowIDs), func(i int) bool { - return ri.rowIDs[i] >= rowID +func (it *setRowIterator) Seek(rowID uint64) { + idx := sort.Search(len(it.rowIDs), func(i int) bool { + return it.rowIDs[i] >= rowID }) - ri.cur = idx + it.cur = idx } -func (ri *rowIterator) Next() (r *Row, rowID uint64, wrapped bool) { - if ri.cur >= len(ri.rowIDs) { - if !ri.wrap || len(ri.rowIDs) == 0 { - return nil, 0, true +func (it *setRowIterator) Next() (r *Row, rowID uint64, _ *int64, wrapped bool) { + if it.cur >= len(it.rowIDs) { + if !it.wrap || len(it.rowIDs) == 0 { + return nil, 0, nil, true } - ri.Seek(0) + it.Seek(0) wrapped = true } - rowID = ri.rowIDs[ri.cur] - r = ri.f.row(rowID) - ri.cur++ - return r, rowID, wrapped + id := it.rowIDs[it.cur] + r = it.f.row(id) + + rowID = id + + it.cur++ + return r, rowID, nil, wrapped } // FragmentBlock represents info about a subsection of the rows in a block. diff --git a/fragment_internal_test.go b/fragment_internal_test.go index 9eee27f8f..3394825f9 100644 --- a/fragment_internal_test.go +++ b/fragment_internal_test.go @@ -2989,7 +2989,7 @@ func TestFragmentRowIterator(t *testing.T) { iter := f.rowIterator(false) for i := uint64(0); i < 4; i++ { - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if id != i { t.Fatalf("expected row %d but got %d", i, id) } @@ -3000,7 +3000,7 @@ func TestFragmentRowIterator(t *testing.T) { t.Fatalf("got wrong columns back on iteration %d - should just be 0 but %v", i, row.Columns()) } } - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if row != nil { t.Fatalf("row should be nil after iterator is exhausted, got %v", row.Columns()) } @@ -3022,7 +3022,7 @@ func TestFragmentRowIterator(t *testing.T) { iter := f.rowIterator(false) for i := uint64(1); i < 8; i += 2 { - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if id != i { t.Fatalf("expected row %d but got %d", i, id) } @@ -3033,7 +3033,7 @@ func TestFragmentRowIterator(t *testing.T) { t.Fatalf("got wrong columns back on iteration %d - should just be 0 but %v", i, row.Columns()) } } - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if row != nil { t.Fatalf("row should be nil after iterator is exhausted, got %v", row.Columns()) } @@ -3055,7 +3055,7 @@ func TestFragmentRowIterator(t *testing.T) { iter := f.rowIterator(true) for i := uint64(0); i < 5; i++ { - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if id != i%4 { t.Fatalf("expected row %d but got %d", i%4, id) } @@ -3080,7 +3080,7 @@ func TestFragmentRowIterator(t *testing.T) { iter := f.rowIterator(true) for i := uint64(1); i < 10; i += 2 { - row, id, wrapped := iter.Next() + row, id, _, wrapped := iter.Next() if id != i%8 { t.Errorf("expected row %d but got %d", i%8, id) } diff --git a/go.sum b/go.sum index 3fb61bcc5..9da5feace 100644 --- a/go.sum +++ b/go.sum @@ -227,8 +227,6 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2El google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.24.0 h1:vb/1TCsVn3DcJlQ0Gs1yB1pKI6Do2/QNwxdKqmc/b0s= -google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.28.0 h1:bO/TA4OxCOummhSf10siHuG7vJOiwh7SpRpFZDkOgl4= google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= diff --git a/internal/public.pb.go b/internal/public.pb.go index 57a26c826..ff033abf7 100644 --- a/internal/public.pb.go +++ b/internal/public.pb.go @@ -377,10 +377,58 @@ func (m *PairsField) GetField() string { return "" } +type Int64 struct { + Value int64 `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Int64) Reset() { *m = Int64{} } +func (m *Int64) String() string { return proto.CompactTextString(m) } +func (*Int64) ProtoMessage() {} +func (*Int64) Descriptor() ([]byte, []int) { + return fileDescriptor_413a91106d7bcce8, []int{6} +} +func (m *Int64) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Int64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Int64.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Int64) XXX_Merge(src proto.Message) { + xxx_messageInfo_Int64.Merge(m, src) +} +func (m *Int64) XXX_Size() int { + return m.Size() +} +func (m *Int64) XXX_DiscardUnknown() { + xxx_messageInfo_Int64.DiscardUnknown(m) +} + +var xxx_messageInfo_Int64 proto.InternalMessageInfo + +func (m *Int64) GetValue() int64 { + if m != nil { + return m.Value + } + return 0 +} + type FieldRow struct { Field string `protobuf:"bytes,1,opt,name=Field,proto3" json:"Field,omitempty"` RowID uint64 `protobuf:"varint,2,opt,name=RowID,proto3" json:"RowID,omitempty"` RowKey string `protobuf:"bytes,3,opt,name=RowKey,proto3" json:"RowKey,omitempty"` + Value *Int64 `protobuf:"bytes,4,opt,name=Value,proto3" json:"Value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -390,7 +438,7 @@ func (m *FieldRow) Reset() { *m = FieldRow{} } func (m *FieldRow) String() string { return proto.CompactTextString(m) } func (*FieldRow) ProtoMessage() {} func (*FieldRow) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{6} + return fileDescriptor_413a91106d7bcce8, []int{7} } func (m *FieldRow) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -440,6 +488,13 @@ func (m *FieldRow) GetRowKey() string { return "" } +func (m *FieldRow) GetValue() *Int64 { + if m != nil { + return m.Value + } + return nil +} + type GroupCount struct { Group []*FieldRow `protobuf:"bytes,1,rep,name=Group,proto3" json:"Group,omitempty"` Count uint64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"` @@ -453,7 +508,7 @@ func (m *GroupCount) Reset() { *m = GroupCount{} } func (m *GroupCount) String() string { return proto.CompactTextString(m) } func (*GroupCount) ProtoMessage() {} func (*GroupCount) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{7} + return fileDescriptor_413a91106d7bcce8, []int{8} } func (m *GroupCount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -517,7 +572,7 @@ func (m *ValCount) Reset() { *m = ValCount{} } func (m *ValCount) String() string { return proto.CompactTextString(m) } func (*ValCount) ProtoMessage() {} func (*ValCount) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{8} + return fileDescriptor_413a91106d7bcce8, []int{9} } func (m *ValCount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -586,7 +641,7 @@ func (m *Decimal) Reset() { *m = Decimal{} } func (m *Decimal) String() string { return proto.CompactTextString(m) } func (*Decimal) ProtoMessage() {} func (*Decimal) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{9} + return fileDescriptor_413a91106d7bcce8, []int{10} } func (m *Decimal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -642,7 +697,7 @@ func (m *ColumnAttrSet) Reset() { *m = ColumnAttrSet{} } func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) } func (*ColumnAttrSet) ProtoMessage() {} func (*ColumnAttrSet) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{10} + return fileDescriptor_413a91106d7bcce8, []int{11} } func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -708,7 +763,7 @@ func (m *Attr) Reset() { *m = Attr{} } func (m *Attr) String() string { return proto.CompactTextString(m) } func (*Attr) ProtoMessage() {} func (*Attr) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{11} + return fileDescriptor_413a91106d7bcce8, []int{12} } func (m *Attr) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -790,7 +845,7 @@ func (m *AttrMap) Reset() { *m = AttrMap{} } func (m *AttrMap) String() string { return proto.CompactTextString(m) } func (*AttrMap) ProtoMessage() {} func (*AttrMap) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{12} + return fileDescriptor_413a91106d7bcce8, []int{13} } func (m *AttrMap) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -843,7 +898,7 @@ func (m *QueryRequest) Reset() { *m = QueryRequest{} } func (m *QueryRequest) String() string { return proto.CompactTextString(m) } func (*QueryRequest) ProtoMessage() {} func (*QueryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{13} + return fileDescriptor_413a91106d7bcce8, []int{14} } func (m *QueryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -934,7 +989,7 @@ func (m *QueryResponse) Reset() { *m = QueryResponse{} } func (m *QueryResponse) String() string { return proto.CompactTextString(m) } func (*QueryResponse) ProtoMessage() {} func (*QueryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{14} + return fileDescriptor_413a91106d7bcce8, []int{15} } func (m *QueryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1005,7 +1060,7 @@ func (m *QueryResult) Reset() { *m = QueryResult{} } func (m *QueryResult) String() string { return proto.CompactTextString(m) } func (*QueryResult) ProtoMessage() {} func (*QueryResult) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{15} + return fileDescriptor_413a91106d7bcce8, []int{16} } func (m *QueryResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1129,7 +1184,7 @@ func (m *ImportRequest) Reset() { *m = ImportRequest{} } func (m *ImportRequest) String() string { return proto.CompactTextString(m) } func (*ImportRequest) ProtoMessage() {} func (*ImportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{16} + return fileDescriptor_413a91106d7bcce8, []int{17} } func (m *ImportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1232,7 +1287,7 @@ func (m *ImportValueRequest) Reset() { *m = ImportValueRequest{} } func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) } func (*ImportValueRequest) ProtoMessage() {} func (*ImportValueRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{17} + return fileDescriptor_413a91106d7bcce8, []int{18} } func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1330,7 +1385,7 @@ func (m *TranslateKeysRequest) Reset() { *m = TranslateKeysRequest{} } func (m *TranslateKeysRequest) String() string { return proto.CompactTextString(m) } func (*TranslateKeysRequest) ProtoMessage() {} func (*TranslateKeysRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{18} + return fileDescriptor_413a91106d7bcce8, []int{19} } func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1391,7 +1446,7 @@ func (m *TranslateKeysResponse) Reset() { *m = TranslateKeysResponse{} } func (m *TranslateKeysResponse) String() string { return proto.CompactTextString(m) } func (*TranslateKeysResponse) ProtoMessage() {} func (*TranslateKeysResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{19} + return fileDescriptor_413a91106d7bcce8, []int{20} } func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1440,7 +1495,7 @@ func (m *TranslateIDsRequest) Reset() { *m = TranslateIDsRequest{} } func (m *TranslateIDsRequest) String() string { return proto.CompactTextString(m) } func (*TranslateIDsRequest) ProtoMessage() {} func (*TranslateIDsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{20} + return fileDescriptor_413a91106d7bcce8, []int{21} } func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1501,7 +1556,7 @@ func (m *TranslateIDsResponse) Reset() { *m = TranslateIDsResponse{} } func (m *TranslateIDsResponse) String() string { return proto.CompactTextString(m) } func (*TranslateIDsResponse) ProtoMessage() {} func (*TranslateIDsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{21} + return fileDescriptor_413a91106d7bcce8, []int{22} } func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1549,7 +1604,7 @@ func (m *ImportRoaringRequestView) Reset() { *m = ImportRoaringRequestVi func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) } func (*ImportRoaringRequestView) ProtoMessage() {} func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{22} + return fileDescriptor_413a91106d7bcce8, []int{23} } func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1606,7 +1661,7 @@ func (m *ImportRoaringRequest) Reset() { *m = ImportRoaringRequest{} } func (m *ImportRoaringRequest) String() string { return proto.CompactTextString(m) } func (*ImportRoaringRequest) ProtoMessage() {} func (*ImportRoaringRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{23} + return fileDescriptor_413a91106d7bcce8, []int{24} } func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1678,7 +1733,7 @@ func (m *ImportColumnAttrsRequest) Reset() { *m = ImportColumnAttrsReque func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) } func (*ImportColumnAttrsRequest) ProtoMessage() {} func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{24} + return fileDescriptor_413a91106d7bcce8, []int{25} } func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1749,6 +1804,7 @@ func init() { proto.RegisterType((*Pair)(nil), "internal.Pair") proto.RegisterType((*PairField)(nil), "internal.PairField") proto.RegisterType((*PairsField)(nil), "internal.PairsField") + proto.RegisterType((*Int64)(nil), "internal.Int64") proto.RegisterType((*FieldRow)(nil), "internal.FieldRow") proto.RegisterType((*GroupCount)(nil), "internal.GroupCount") proto.RegisterType((*ValCount)(nil), "internal.ValCount") @@ -1773,81 +1829,82 @@ func init() { func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) } var fileDescriptor_413a91106d7bcce8 = []byte{ - // 1175 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcd, 0x8e, 0x1b, 0xc5, - 0x13, 0xff, 0xb7, 0x67, 0xbc, 0xb6, 0xcb, 0xde, 0xfd, 0x87, 0x8e, 0x13, 0x46, 0x28, 0xda, 0x58, - 0xad, 0x08, 0x19, 0x0e, 0x1b, 0x65, 0xf9, 0x50, 0x4e, 0x40, 0x36, 0xde, 0x80, 0x15, 0xc5, 0x0a, - 0xed, 0x95, 0xb9, 0x21, 0xcd, 0xda, 0xcd, 0x66, 0xc4, 0x78, 0xc6, 0xcc, 0x07, 0xce, 0x1e, 0x79, - 0x06, 0x38, 0x20, 0x9e, 0x80, 0x77, 0xe0, 0x05, 0x38, 0xf2, 0x08, 0xb0, 0xbc, 0x01, 0x57, 0x2e, - 0xa8, 0xaa, 0xa7, 0xdd, 0x6d, 0xaf, 0x77, 0x89, 0x22, 0x6e, 0xfd, 0xab, 0xaa, 0xae, 0xae, 0xaa, - 0xa9, 0xfe, 0x55, 0x0f, 0x74, 0x16, 0xe5, 0x69, 0x1c, 0x4d, 0x0f, 0x16, 0x59, 0x5a, 0xa4, 0xbc, - 0x19, 0x25, 0x85, 0xca, 0x92, 0x30, 0x16, 0x39, 0x78, 0x32, 0x5d, 0xf2, 0x00, 0x1a, 0x8f, 0xd3, - 0xb8, 0x9c, 0x27, 0x79, 0xc0, 0x7a, 0x5e, 0xdf, 0x97, 0x06, 0x72, 0x0e, 0xfe, 0x53, 0x75, 0x9e, - 0x07, 0x5e, 0xcf, 0xeb, 0xb7, 0x24, 0xad, 0xf9, 0x3d, 0xa8, 0x3f, 0x2a, 0x8a, 0x2c, 0x0f, 0x6a, - 0x3d, 0xaf, 0xdf, 0x3e, 0xdc, 0x3b, 0x30, 0xee, 0x0e, 0x50, 0x2c, 0xb5, 0x12, 0x7d, 0xca, 0x34, - 0xcc, 0xa2, 0xe4, 0x2c, 0xf0, 0x7b, 0xac, 0xdf, 0x91, 0x06, 0x8a, 0x67, 0xd0, 0x1a, 0x47, 0x67, - 0x89, 0x9a, 0xe1, 0xd1, 0x77, 0xc1, 0x7b, 0x9e, 0xe2, 0xb1, 0xac, 0xdf, 0x3e, 0xdc, 0xb5, 0xae, - 0x64, 0xba, 0x94, 0xa8, 0x41, 0x83, 0x91, 0x3a, 0x0b, 0x6a, 0x5b, 0x0d, 0x46, 0xea, 0x4c, 0x3c, - 0x84, 0x3d, 0x99, 0x2e, 0x87, 0x33, 0x95, 0x14, 0xd1, 0x57, 0x91, 0xca, 0x28, 0x68, 0x99, 0x2e, - 0x4d, 0x2e, 0xb4, 0x5e, 0x25, 0x52, 0xb3, 0x89, 0x88, 0x8f, 0xc0, 0x7f, 0x1e, 0x46, 0x19, 0xdf, - 0x83, 0xda, 0x70, 0x40, 0x21, 0xf8, 0xb2, 0x36, 0x1c, 0xf0, 0x1b, 0xe0, 0x3d, 0x55, 0xe7, 0x81, - 0xd7, 0x63, 0xfd, 0x96, 0xc4, 0x25, 0xef, 0x42, 0xfd, 0x71, 0x5a, 0x26, 0x05, 0x85, 0xe1, 0x4b, - 0x0d, 0xc4, 0x31, 0xb4, 0x70, 0xff, 0x93, 0x48, 0xc5, 0x33, 0x2e, 0xb4, 0xb3, 0x2a, 0x13, 0xa7, - 0x28, 0x28, 0x95, 0xfa, 0xa0, 0x2e, 0xd4, 0xc9, 0x98, 0xdc, 0xb4, 0xa4, 0x06, 0xe2, 0x33, 0x00, - 0xd4, 0xe6, 0xda, 0xcf, 0x3d, 0xa8, 0x13, 0xa2, 0xe8, 0x2f, 0x3b, 0xd2, 0xca, 0x2b, 0x3c, 0x8d, - 0xa0, 0x49, 0x0b, 0x2c, 0xec, 0xca, 0x82, 0x39, 0x16, 0x28, 0xc5, 0x62, 0x0d, 0x4c, 0x22, 0x04, - 0xf8, 0x6d, 0xd8, 0x91, 0xe9, 0xd2, 0xe6, 0x5c, 0x21, 0xf1, 0x25, 0xc0, 0xa7, 0x59, 0x5a, 0x2e, - 0x28, 0x5d, 0xde, 0x87, 0x3a, 0xa1, 0x2a, 0x32, 0x6e, 0x23, 0x33, 0x87, 0x4a, 0x6d, 0xb0, 0xbd, - 0x5c, 0x58, 0xd6, 0x71, 0x39, 0xa7, 0x23, 0x3c, 0x89, 0x4b, 0xf1, 0x1d, 0x83, 0xe6, 0x24, 0x8c, - 0x57, 0xea, 0x49, 0x18, 0x53, 0xb8, 0x9e, 0xc4, 0xe5, 0xba, 0x1b, 0xcf, 0xb8, 0x79, 0x0b, 0x9a, - 0x4f, 0xe2, 0x34, 0x2c, 0xd0, 0x18, 0x7d, 0x31, 0xb9, 0xc2, 0xfc, 0x01, 0xc0, 0x40, 0x4d, 0xa3, - 0x79, 0x18, 0xa3, 0xd6, 0xa7, 0x4f, 0xf1, 0x86, 0x8d, 0xb3, 0xd2, 0x49, 0xc7, 0x48, 0x7c, 0x00, - 0x8d, 0x0a, 0xe1, 0x79, 0x93, 0x30, 0x2e, 0x55, 0x15, 0x83, 0x06, 0x28, 0x1d, 0x4f, 0xc3, 0x58, - 0x99, 0x28, 0x08, 0x88, 0x2f, 0x60, 0x57, 0xdf, 0x11, 0xec, 0xf6, 0xb1, 0x2a, 0x5e, 0xa1, 0x89, - 0x5e, 0xe9, 0xde, 0x88, 0x9f, 0x19, 0xf8, 0xb8, 0x32, 0x0e, 0x98, 0x75, 0xc0, 0xc1, 0x3f, 0x39, - 0x5f, 0xa8, 0xaa, 0xaa, 0xb4, 0xe6, 0x3d, 0x68, 0x8f, 0x0b, 0xbc, 0x56, 0x3a, 0x72, 0x7d, 0x9c, - 0x2b, 0xc2, 0x7a, 0x0d, 0x93, 0x42, 0xab, 0x7d, 0x4a, 0x61, 0x85, 0xf9, 0x1d, 0x68, 0x1d, 0xa5, - 0x69, 0xac, 0x95, 0xf5, 0x1e, 0xeb, 0x37, 0xa5, 0x15, 0xf0, 0x7d, 0x00, 0x53, 0xd9, 0x52, 0x05, - 0x3b, 0x54, 0x6b, 0x47, 0x22, 0xee, 0x43, 0x03, 0x23, 0x7d, 0x16, 0x2e, 0x6c, 0x6e, 0xec, 0xba, - 0xdc, 0xfe, 0x66, 0xd0, 0xf9, 0xbc, 0x54, 0xd9, 0xb9, 0x54, 0xdf, 0x94, 0x2a, 0x2f, 0xb0, 0xb6, - 0x84, 0x4d, 0x93, 0x12, 0xc0, 0x76, 0x1c, 0xbf, 0x08, 0xb3, 0x99, 0xae, 0x94, 0x2f, 0x2b, 0x84, - 0xb9, 0xda, 0x9a, 0xe7, 0x94, 0x6b, 0x53, 0xba, 0x22, 0x6a, 0x64, 0x35, 0x4f, 0x0b, 0x93, 0x4c, - 0x85, 0x78, 0x1f, 0xfe, 0x7f, 0xfc, 0x72, 0x1a, 0x97, 0x33, 0x25, 0xd3, 0xa5, 0xde, 0xbd, 0x43, - 0x06, 0x9b, 0x62, 0xfe, 0x36, 0xec, 0x55, 0x22, 0xc3, 0x88, 0x0d, 0x32, 0xdc, 0x90, 0xf2, 0x07, - 0xd0, 0x39, 0x9e, 0x9f, 0xaa, 0xd9, 0x4c, 0xcd, 0x06, 0x61, 0x11, 0x06, 0x4d, 0xca, 0x7b, 0x83, - 0x9f, 0xd6, 0x4c, 0xc4, 0xf7, 0x0c, 0x76, 0xab, 0xec, 0xf3, 0x45, 0x9a, 0xe4, 0x0a, 0x3f, 0xf1, - 0x71, 0x96, 0x99, 0x4f, 0x7c, 0x9c, 0x65, 0xfc, 0x3e, 0x34, 0xa4, 0xca, 0xcb, 0xb8, 0x30, 0x5d, - 0x72, 0xcb, 0x7a, 0x34, 0x7b, 0xcb, 0xb8, 0x90, 0xc6, 0x8a, 0x7f, 0x0c, 0x7b, 0x6b, 0x7d, 0xa8, - 0xa9, 0xba, 0x7d, 0xf8, 0xa6, 0xdd, 0xb7, 0xa6, 0x97, 0x1b, 0xe6, 0xe2, 0x17, 0x0f, 0xda, 0x8e, - 0xe7, 0x55, 0x93, 0x61, 0x7d, 0x76, 0xab, 0x26, 0xbb, 0x4b, 0x63, 0xe2, 0x0a, 0x92, 0x46, 0xb2, - 0xe9, 0x00, 0x1b, 0x55, 0x6d, 0xc9, 0x46, 0x96, 0xc2, 0xbc, 0xeb, 0x28, 0x0c, 0x87, 0xce, 0x8b, - 0x30, 0x39, 0x53, 0x33, 0x6a, 0xcb, 0xa6, 0x34, 0x90, 0x1f, 0x58, 0x56, 0xa0, 0xef, 0xb8, 0xc6, - 0x35, 0x46, 0x23, 0x2d, 0x73, 0x68, 0xfa, 0x1a, 0x0e, 0xf0, 0x5b, 0x51, 0xbf, 0x68, 0xc4, 0x3f, - 0x84, 0xb6, 0xa5, 0xaf, 0xbc, 0xfa, 0x44, 0x5d, 0xeb, 0xca, 0x2a, 0xa5, 0x6b, 0xc8, 0x3f, 0xd9, - 0x9c, 0x28, 0x41, 0x8b, 0xa2, 0x08, 0xd6, 0x32, 0x77, 0xf4, 0x72, 0x73, 0x02, 0x3d, 0x70, 0x46, - 0x5c, 0x00, 0xb4, 0xf9, 0xa6, 0xdd, 0xbc, 0x52, 0x49, 0x67, 0x10, 0xbe, 0xef, 0x4e, 0x81, 0xa0, - 0x4d, 0x7b, 0xba, 0xeb, 0x95, 0xd3, 0x3a, 0xe9, 0xd8, 0x89, 0x3f, 0x18, 0xec, 0x0e, 0xe7, 0x8b, - 0x34, 0x2b, 0x9c, 0x2b, 0x35, 0x4c, 0x66, 0xea, 0xa5, 0xb9, 0x52, 0x04, 0xb6, 0xcf, 0x0b, 0xa2, - 0x36, 0xbc, 0x5a, 0x74, 0x95, 0x7c, 0xa9, 0x81, 0x53, 0x4e, 0x7f, 0xad, 0x9c, 0x77, 0xa0, 0xa5, - 0x7b, 0x07, 0x55, 0x75, 0x52, 0x59, 0x81, 0x9e, 0xf7, 0x4b, 0x9a, 0xb1, 0x0d, 0x9a, 0xb1, 0x06, - 0x22, 0x8d, 0x68, 0x33, 0x52, 0x36, 0x49, 0xe9, 0x48, 0x50, 0x7f, 0x12, 0xcd, 0x55, 0x5e, 0x84, - 0xf3, 0x05, 0xde, 0x4b, 0xaf, 0xef, 0x49, 0x47, 0x22, 0xfe, 0x62, 0xc0, 0x75, 0x8e, 0x44, 0x3b, - 0xff, 0x5d, 0xa2, 0xd7, 0x27, 0xb4, 0x1e, 0x76, 0xe3, 0x52, 0xd8, 0xb7, 0x61, 0x87, 0xe2, 0x31, - 0x21, 0x57, 0x08, 0x59, 0xca, 0x72, 0xa4, 0xce, 0x97, 0x49, 0x57, 0xc4, 0x05, 0x74, 0x1c, 0x82, - 0xc6, 0xee, 0x42, 0xdf, 0x6b, 0x32, 0x31, 0x81, 0xee, 0x49, 0x16, 0x26, 0x79, 0x1c, 0x16, 0x0a, - 0x8f, 0x7b, 0x9d, 0xac, 0xb7, 0x3c, 0xde, 0xc4, 0x3b, 0x70, 0x6b, 0xc3, 0xaf, 0xe5, 0x22, 0x2c, - 0x83, 0x47, 0x65, 0xc0, 0xa5, 0x18, 0xc3, 0xcd, 0x95, 0xe9, 0x70, 0xf0, 0x5a, 0x11, 0x5c, 0x76, - 0xfa, 0xae, 0x93, 0x17, 0x39, 0xad, 0x8e, 0xdf, 0x16, 0xeb, 0x11, 0x04, 0x55, 0x6f, 0xeb, 0x97, - 0x63, 0x15, 0xc1, 0x24, 0x52, 0x4b, 0xb4, 0x1f, 0x85, 0x73, 0x55, 0x05, 0x41, 0x6b, 0x94, 0x11, - 0x17, 0xd7, 0xe8, 0xbd, 0x49, 0x6b, 0xf1, 0x03, 0x83, 0xee, 0x36, 0x27, 0xf4, 0xb8, 0x88, 0x55, - 0xa8, 0xd9, 0xb7, 0x29, 0x35, 0xe0, 0x0f, 0xa1, 0xfe, 0x6d, 0xa4, 0x96, 0x86, 0x7d, 0x85, 0xbd, - 0x80, 0x57, 0x45, 0x22, 0xf5, 0x06, 0x6c, 0x87, 0x47, 0xd3, 0x22, 0x4a, 0x13, 0xf3, 0x86, 0xd2, - 0x08, 0xcf, 0x39, 0x8a, 0xd3, 0xe9, 0xd7, 0x44, 0x72, 0xbe, 0xd4, 0x40, 0xfc, 0xc4, 0x4c, 0x6e, - 0xce, 0xf8, 0xfa, 0xd7, 0x0a, 0xeb, 0x1e, 0x36, 0xef, 0x10, 0xea, 0xe1, 0x40, 0xcf, 0x60, 0xfb, - 0xd4, 0x30, 0x10, 0xe7, 0x3e, 0x2e, 0x27, 0x61, 0xac, 0x2f, 0x72, 0x4b, 0xae, 0xf0, 0xf5, 0x9d, - 0x7f, 0x74, 0xe3, 0xd7, 0x8b, 0x7d, 0xf6, 0xdb, 0xc5, 0x3e, 0xfb, 0xfd, 0x62, 0x9f, 0xfd, 0xf8, - 0xe7, 0xfe, 0xff, 0x4e, 0x77, 0xe8, 0xc7, 0xe1, 0xbd, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd1, - 0xe5, 0x55, 0xc9, 0x48, 0x0c, 0x00, 0x00, + // 1196 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcd, 0x8e, 0x1b, 0x45, + 0x10, 0xa6, 0x3d, 0xe3, 0xb5, 0x5d, 0xf6, 0x6e, 0x42, 0xc7, 0x09, 0x23, 0x14, 0x36, 0x56, 0x2b, + 0x20, 0xc3, 0x61, 0xa3, 0x84, 0x10, 0xe5, 0x04, 0x64, 0xe3, 0x0d, 0x58, 0x51, 0x56, 0xa1, 0xbd, + 0x32, 0x37, 0xa4, 0x59, 0xbb, 0xd9, 0x8c, 0x18, 0xcf, 0x98, 0xf9, 0xc1, 0xd9, 0x23, 0xcf, 0x00, + 0x07, 0xc4, 0x13, 0xf0, 0x0e, 0xbc, 0x00, 0x47, 0x1e, 0x01, 0x96, 0x37, 0xe0, 0xca, 0x05, 0x55, + 0xf5, 0xb4, 0xbb, 0xed, 0xf5, 0x2e, 0x51, 0xc4, 0xad, 0xbf, 0xaa, 0xea, 0xea, 0xfa, 0x6a, 0xaa, + 0xab, 0x7a, 0xa0, 0x33, 0x2f, 0x8f, 0xe3, 0x68, 0xb2, 0x37, 0xcf, 0xd2, 0x22, 0xe5, 0xcd, 0x28, + 0x29, 0x54, 0x96, 0x84, 0xb1, 0xc8, 0xc1, 0x93, 0xe9, 0x82, 0x07, 0xd0, 0x78, 0x9c, 0xc6, 0xe5, + 0x2c, 0xc9, 0x03, 0xd6, 0xf3, 0xfa, 0xbe, 0x34, 0x90, 0x73, 0xf0, 0x9f, 0xaa, 0xd3, 0x3c, 0xf0, + 0x7a, 0x5e, 0xbf, 0x25, 0x69, 0xcd, 0x6f, 0x43, 0xfd, 0x51, 0x51, 0x64, 0x79, 0x50, 0xeb, 0x79, + 0xfd, 0xf6, 0xbd, 0x9d, 0x3d, 0xe3, 0x6e, 0x0f, 0xc5, 0x52, 0x2b, 0xd1, 0xa7, 0x4c, 0xc3, 0x2c, + 0x4a, 0x4e, 0x02, 0xbf, 0xc7, 0xfa, 0x1d, 0x69, 0xa0, 0x78, 0x06, 0xad, 0x51, 0x74, 0x92, 0xa8, + 0x29, 0x1e, 0x7d, 0x0b, 0xbc, 0xe7, 0x29, 0x1e, 0xcb, 0xfa, 0xed, 0x7b, 0xdb, 0xd6, 0x95, 0x4c, + 0x17, 0x12, 0x35, 0x68, 0x70, 0xa8, 0x4e, 0x82, 0xda, 0x46, 0x83, 0x43, 0x75, 0x22, 0x1e, 0xc2, + 0x8e, 0x4c, 0x17, 0xc3, 0xa9, 0x4a, 0x8a, 0xe8, 0xeb, 0x48, 0x65, 0x14, 0xb4, 0x4c, 0x17, 0x86, + 0x0b, 0xad, 0x97, 0x44, 0x6a, 0x96, 0x88, 0xf8, 0x18, 0xfc, 0xe7, 0x61, 0x94, 0xf1, 0x1d, 0xa8, + 0x0d, 0x07, 0x14, 0x82, 0x2f, 0x6b, 0xc3, 0x01, 0xbf, 0x0a, 0xde, 0x53, 0x75, 0x1a, 0x78, 0x3d, + 0xd6, 0x6f, 0x49, 0x5c, 0xf2, 0x2e, 0xd4, 0x1f, 0xa7, 0x65, 0x52, 0x50, 0x18, 0xbe, 0xd4, 0x40, + 0x1c, 0x40, 0x0b, 0xf7, 0x3f, 0x89, 0x54, 0x3c, 0xe5, 0x42, 0x3b, 0xab, 0x98, 0x38, 0x49, 0x41, + 0xa9, 0xd4, 0x07, 0x75, 0xa1, 0x4e, 0xc6, 0xe4, 0xa6, 0x25, 0x35, 0x10, 0x9f, 0x03, 0xa0, 0x36, + 0xd7, 0x7e, 0x6e, 0x43, 0x9d, 0x10, 0x45, 0x7f, 0xde, 0x91, 0x56, 0x5e, 0xe0, 0xe9, 0x1d, 0xa8, + 0x0f, 0x93, 0xe2, 0xc1, 0x7d, 0x54, 0x8f, 0xc3, 0xb8, 0x54, 0x14, 0x8d, 0x27, 0x35, 0x10, 0x25, + 0x34, 0xc9, 0x0e, 0xf3, 0xbe, 0x74, 0xc0, 0x1c, 0x07, 0x28, 0xc5, 0x5c, 0x0e, 0x0c, 0x4f, 0x02, + 0xfc, 0x06, 0x6c, 0xc9, 0x74, 0x61, 0x53, 0x52, 0x21, 0xfe, 0xae, 0x39, 0xc5, 0x27, 0xce, 0x57, + 0x6c, 0xa8, 0x14, 0x85, 0x39, 0xf6, 0x2b, 0x80, 0xcf, 0xb2, 0xb4, 0x9c, 0x53, 0xd2, 0x78, 0x1f, + 0xea, 0x84, 0x2a, 0x7e, 0xdc, 0x6e, 0x32, 0xb1, 0x49, 0x6d, 0xb0, 0x39, 0xe9, 0xf8, 0x71, 0x46, + 0xe5, 0x8c, 0x22, 0xf1, 0x24, 0x2e, 0xc5, 0xf7, 0x0c, 0x9a, 0xe3, 0x30, 0x5e, 0xaa, 0xc7, 0x61, + 0x5c, 0xf1, 0xc6, 0xe5, 0xaa, 0x1b, 0xcf, 0xb8, 0x79, 0x1b, 0x9a, 0x4f, 0xe2, 0x34, 0x2c, 0xd0, + 0x18, 0x7d, 0x31, 0xb9, 0xc4, 0xfc, 0x2e, 0xc0, 0x40, 0x4d, 0xa2, 0x59, 0x18, 0xa3, 0x56, 0x93, + 0x7b, 0xd3, 0xc6, 0x59, 0xe9, 0xa4, 0x63, 0x24, 0x3e, 0x82, 0x46, 0x85, 0x36, 0xe7, 0x1e, 0xa5, + 0xa3, 0x49, 0x18, 0x2b, 0x13, 0x05, 0x01, 0xf1, 0x25, 0x6c, 0xeb, 0x9b, 0x86, 0x77, 0x66, 0xa4, + 0x8a, 0x57, 0x28, 0xc5, 0x57, 0xba, 0x7d, 0xe2, 0x17, 0x06, 0x3e, 0xae, 0x8c, 0x03, 0x66, 0x1d, + 0x70, 0xf0, 0x8f, 0x4e, 0xe7, 0xaa, 0xca, 0x2a, 0xad, 0x79, 0x0f, 0xda, 0xa3, 0x02, 0x2f, 0xa7, + 0x8e, 0x5c, 0x1f, 0xe7, 0x8a, 0x30, 0x5f, 0xc3, 0xa4, 0xb0, 0x9f, 0xdb, 0x93, 0x4b, 0xcc, 0x6f, + 0x42, 0x6b, 0x3f, 0x4d, 0x63, 0xad, 0xac, 0xf7, 0x58, 0xbf, 0x29, 0xad, 0x80, 0xef, 0x02, 0x98, + 0xcc, 0x96, 0x2a, 0xd8, 0xa2, 0x5c, 0x3b, 0x12, 0x71, 0x07, 0x1a, 0x18, 0xe9, 0xb3, 0x70, 0x6e, + 0xb9, 0xb1, 0xcb, 0xb8, 0xfd, 0xc3, 0xa0, 0xf3, 0x45, 0xa9, 0xb2, 0x53, 0xa9, 0xbe, 0x2d, 0x55, + 0x5e, 0x60, 0x6e, 0x09, 0x9b, 0x5a, 0x26, 0x80, 0x55, 0x3b, 0x7a, 0x11, 0x66, 0x53, 0x9d, 0x29, + 0x5f, 0x56, 0x08, 0xb9, 0xda, 0x9c, 0xe7, 0xc4, 0xb5, 0x29, 0x5d, 0x11, 0xd5, 0xbb, 0x9a, 0xa5, + 0x85, 0x21, 0x53, 0x21, 0xde, 0x87, 0x2b, 0x07, 0x2f, 0x27, 0x71, 0x39, 0x55, 0x32, 0x5d, 0xe8, + 0xdd, 0x5b, 0x64, 0xb0, 0x2e, 0xe6, 0xef, 0xc1, 0x4e, 0x25, 0x32, 0x7d, 0xb5, 0x41, 0x86, 0x6b, + 0x52, 0x7e, 0x17, 0x3a, 0x07, 0xb3, 0x63, 0x35, 0x9d, 0xaa, 0xe9, 0x20, 0x2c, 0xc2, 0xa0, 0x49, + 0xbc, 0xd7, 0xba, 0xdc, 0x8a, 0x89, 0xf8, 0x81, 0xc1, 0x76, 0xc5, 0x3e, 0x9f, 0xa7, 0x49, 0xae, + 0xf0, 0x13, 0x1f, 0x64, 0x99, 0xf9, 0xc4, 0x07, 0x59, 0xc6, 0xef, 0x40, 0x43, 0xaa, 0xbc, 0x8c, + 0x0b, 0x53, 0x25, 0xd7, 0xad, 0x47, 0xb3, 0xb7, 0x8c, 0x0b, 0x69, 0xac, 0xf8, 0x27, 0xb0, 0xb3, + 0x52, 0x87, 0xba, 0xe1, 0xb7, 0xef, 0xbd, 0x65, 0xf7, 0xad, 0xe8, 0xe5, 0x9a, 0xb9, 0xf8, 0xd5, + 0x83, 0xb6, 0xe3, 0x79, 0x59, 0x64, 0x98, 0x9f, 0xed, 0xaa, 0xc8, 0x6e, 0xd1, 0xb0, 0xb9, 0xa0, + 0xd5, 0x63, 0x4f, 0xea, 0x00, 0x3b, 0xac, 0xca, 0x92, 0x1d, 0xda, 0x46, 0xe8, 0x5d, 0xd6, 0x08, + 0x71, 0x74, 0xbd, 0x08, 0x93, 0x13, 0x35, 0xa5, 0xb2, 0x6c, 0x4a, 0x03, 0xf9, 0x9e, 0xed, 0x0a, + 0xf4, 0x1d, 0x57, 0x7a, 0x8d, 0xd1, 0x48, 0xdb, 0x39, 0x74, 0x97, 0x1b, 0x0e, 0xf0, 0x5b, 0x51, + 0xbd, 0x68, 0xc4, 0x1f, 0x40, 0xdb, 0xb6, 0xaf, 0xbc, 0xfa, 0x44, 0x5d, 0xeb, 0xca, 0x2a, 0xa5, + 0x6b, 0xc8, 0x3f, 0x5d, 0x9f, 0x4b, 0x41, 0x8b, 0xa2, 0x08, 0x56, 0x98, 0x3b, 0x7a, 0xb9, 0x3e, + 0xc7, 0xee, 0x3a, 0x83, 0x32, 0x00, 0xda, 0x7c, 0xcd, 0x6e, 0x5e, 0xaa, 0xa4, 0x33, 0x4e, 0xef, + 0xbb, 0xb3, 0x24, 0x68, 0xd3, 0x9e, 0xee, 0x6a, 0xe6, 0xb4, 0x4e, 0x3a, 0x76, 0xe2, 0x4f, 0x06, + 0xdb, 0xc3, 0xd9, 0x3c, 0xcd, 0x0a, 0xe7, 0x4a, 0x0d, 0x93, 0xa9, 0x7a, 0x69, 0xae, 0x14, 0x81, + 0xcd, 0x53, 0x87, 0x5a, 0x1b, 0x5e, 0x2d, 0xba, 0x4a, 0xbe, 0xd4, 0xc0, 0x49, 0xa7, 0xbf, 0x92, + 0xce, 0x9b, 0xd0, 0xd2, 0xb5, 0x83, 0xaa, 0x3a, 0xa9, 0xac, 0x40, 0xbf, 0x1a, 0x16, 0x34, 0xa9, + 0x1b, 0x34, 0xa9, 0x0d, 0xc4, 0x36, 0xa2, 0xcd, 0x48, 0xd9, 0x24, 0xa5, 0x23, 0x41, 0xfd, 0x51, + 0x34, 0x53, 0x79, 0x11, 0xce, 0xe6, 0x78, 0x2f, 0xbd, 0xbe, 0x27, 0x1d, 0x89, 0xf8, 0x9b, 0x01, + 0xd7, 0x1c, 0xa9, 0xed, 0xfc, 0x7f, 0x44, 0x2f, 0x27, 0xb4, 0x1a, 0x76, 0xe3, 0x5c, 0xd8, 0x37, + 0x60, 0x8b, 0xe2, 0x31, 0x21, 0x57, 0x08, 0xbb, 0x94, 0xed, 0x91, 0x9a, 0x2f, 0x93, 0xae, 0x88, + 0x0b, 0xe8, 0x38, 0x0d, 0x1a, 0xab, 0x0b, 0x7d, 0xaf, 0xc8, 0xc4, 0x18, 0xba, 0x47, 0x59, 0x98, + 0xe4, 0x71, 0x58, 0x28, 0x3c, 0xee, 0x75, 0x58, 0x6f, 0x78, 0x02, 0x8a, 0xf7, 0xe1, 0xfa, 0x9a, + 0x5f, 0xdb, 0x8b, 0x30, 0x0d, 0x1e, 0xa5, 0x01, 0x97, 0x62, 0x04, 0xd7, 0x96, 0xa6, 0xc3, 0xc1, + 0x6b, 0x45, 0x70, 0xde, 0xe9, 0x07, 0x0e, 0x2f, 0x72, 0x5a, 0x1d, 0xbf, 0x29, 0xd6, 0x7d, 0x08, + 0xaa, 0xda, 0xd6, 0xef, 0xcf, 0x2a, 0x82, 0x71, 0xa4, 0x16, 0x68, 0x7f, 0x18, 0xce, 0x54, 0x15, + 0x04, 0xad, 0x51, 0x46, 0xbd, 0xb8, 0x46, 0xaf, 0x56, 0x5a, 0x8b, 0x1f, 0x19, 0x74, 0x37, 0x39, + 0xa1, 0xc7, 0x45, 0xac, 0x42, 0xdd, 0x7d, 0x9b, 0x52, 0x03, 0xfe, 0x10, 0xea, 0xdf, 0x45, 0x6a, + 0x61, 0xba, 0xaf, 0x70, 0x1e, 0x46, 0x17, 0x44, 0x22, 0xf5, 0x06, 0x2c, 0x87, 0x47, 0x93, 0x22, + 0x4a, 0x13, 0xf3, 0xd4, 0xd2, 0x08, 0xcf, 0xd9, 0x8f, 0xd3, 0xc9, 0x37, 0xd4, 0xe4, 0x7c, 0xa9, + 0x81, 0xf8, 0x99, 0x19, 0x6e, 0xce, 0xf8, 0xfa, 0xcf, 0x0c, 0xeb, 0x1a, 0x36, 0xef, 0x10, 0xaa, + 0xe1, 0x40, 0xcf, 0x60, 0xfb, 0xd4, 0x30, 0x10, 0xe7, 0x3e, 0x2e, 0xc7, 0x61, 0xac, 0x2f, 0x72, + 0x4b, 0x2e, 0xf1, 0xe5, 0x95, 0xbf, 0x7f, 0xf5, 0xb7, 0xb3, 0x5d, 0xf6, 0xfb, 0xd9, 0x2e, 0xfb, + 0xe3, 0x6c, 0x97, 0xfd, 0xf4, 0xd7, 0xee, 0x1b, 0xc7, 0x5b, 0xf4, 0xfb, 0xf1, 0xe1, 0xbf, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x2b, 0xc8, 0xa6, 0x89, 0x8e, 0x0c, 0x00, 0x00, } func (m *Row) Marshal() (dAtA []byte, err error) { @@ -2168,6 +2225,38 @@ func (m *PairsField) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Int64) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Int64) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Int64) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Value != 0 { + i = encodeVarintPublic(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *FieldRow) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2192,6 +2281,18 @@ func (m *FieldRow) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.Value != nil { + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPublic(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } if len(m.RowKey) > 0 { i -= len(m.RowKey) copy(dAtA[i:], m.RowKey) @@ -2597,20 +2698,20 @@ func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x18 } if len(m.Shards) > 0 { - dAtA10 := make([]byte, len(m.Shards)*10) - var j9 int + dAtA11 := make([]byte, len(m.Shards)*10) + var j10 int for _, num := range m.Shards { for num >= 1<<7 { - dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80) + dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j9++ + j10++ } - dAtA10[j9] = uint8(num) - j9++ + dAtA11[j10] = uint8(num) + j10++ } - i -= j9 - copy(dAtA[i:], dAtA10[:j9]) - i = encodeVarintPublic(dAtA, i, uint64(j9)) + i -= j10 + copy(dAtA[i:], dAtA11[:j10]) + i = encodeVarintPublic(dAtA, i, uint64(j10)) i-- dAtA[i] = 0x12 } @@ -2761,20 +2862,20 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.RowIDs) > 0 { - dAtA15 := make([]byte, len(m.RowIDs)*10) - var j14 int + dAtA16 := make([]byte, len(m.RowIDs)*10) + var j15 int for _, num := range m.RowIDs { for num >= 1<<7 { - dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80) + dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j14++ + j15++ } - dAtA15[j14] = uint8(num) - j14++ + dAtA16[j15] = uint8(num) + j15++ } - i -= j14 - copy(dAtA[i:], dAtA15[:j14]) - i = encodeVarintPublic(dAtA, i, uint64(j14)) + i -= j15 + copy(dAtA[i:], dAtA16[:j15]) + i = encodeVarintPublic(dAtA, i, uint64(j15)) i-- dAtA[i] = 0x3a } @@ -2882,57 +2983,57 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.Timestamps) > 0 { - dAtA19 := make([]byte, len(m.Timestamps)*10) - var j18 int + dAtA20 := make([]byte, len(m.Timestamps)*10) + var j19 int for _, num1 := range m.Timestamps { num := uint64(num1) for num >= 1<<7 { - dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80) + dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j18++ + j19++ } - dAtA19[j18] = uint8(num) - j18++ + dAtA20[j19] = uint8(num) + j19++ } - i -= j18 - copy(dAtA[i:], dAtA19[:j18]) - i = encodeVarintPublic(dAtA, i, uint64(j18)) + i -= j19 + copy(dAtA[i:], dAtA20[:j19]) + i = encodeVarintPublic(dAtA, i, uint64(j19)) i-- dAtA[i] = 0x32 } if len(m.ColumnIDs) > 0 { - dAtA21 := make([]byte, len(m.ColumnIDs)*10) - var j20 int + dAtA22 := make([]byte, len(m.ColumnIDs)*10) + var j21 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80) + dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j20++ + j21++ } - dAtA21[j20] = uint8(num) - j20++ + dAtA22[j21] = uint8(num) + j21++ } - i -= j20 - copy(dAtA[i:], dAtA21[:j20]) - i = encodeVarintPublic(dAtA, i, uint64(j20)) + i -= j21 + copy(dAtA[i:], dAtA22[:j21]) + i = encodeVarintPublic(dAtA, i, uint64(j21)) i-- dAtA[i] = 0x2a } if len(m.RowIDs) > 0 { - dAtA23 := make([]byte, len(m.RowIDs)*10) - var j22 int + dAtA24 := make([]byte, len(m.RowIDs)*10) + var j23 int for _, num := range m.RowIDs { for num >= 1<<7 { - dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80) + dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j22++ + j23++ } - dAtA23[j22] = uint8(num) - j22++ + dAtA24[j23] = uint8(num) + j23++ } - i -= j22 - copy(dAtA[i:], dAtA23[:j22]) - i = encodeVarintPublic(dAtA, i, uint64(j22)) + i -= j23 + copy(dAtA[i:], dAtA24[:j23]) + i = encodeVarintPublic(dAtA, i, uint64(j23)) i-- dAtA[i] = 0x22 } @@ -2993,9 +3094,9 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } if len(m.FloatValues) > 0 { for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- { - f24 := math.Float64bits(float64(m.FloatValues[iNdEx])) + f25 := math.Float64bits(float64(m.FloatValues[iNdEx])) i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f24)) + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f25)) } i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8)) i-- @@ -3011,39 +3112,39 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.Values) > 0 { - dAtA26 := make([]byte, len(m.Values)*10) - var j25 int + dAtA27 := make([]byte, len(m.Values)*10) + var j26 int for _, num1 := range m.Values { num := uint64(num1) for num >= 1<<7 { - dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80) + dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j25++ + j26++ } - dAtA26[j25] = uint8(num) - j25++ + dAtA27[j26] = uint8(num) + j26++ } - i -= j25 - copy(dAtA[i:], dAtA26[:j25]) - i = encodeVarintPublic(dAtA, i, uint64(j25)) + i -= j26 + copy(dAtA[i:], dAtA27[:j26]) + i = encodeVarintPublic(dAtA, i, uint64(j26)) i-- dAtA[i] = 0x32 } if len(m.ColumnIDs) > 0 { - dAtA28 := make([]byte, len(m.ColumnIDs)*10) - var j27 int + dAtA29 := make([]byte, len(m.ColumnIDs)*10) + var j28 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80) + dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j27++ + j28++ } - dAtA28[j27] = uint8(num) - j27++ + dAtA29[j28] = uint8(num) + j28++ } - i -= j27 - copy(dAtA[i:], dAtA28[:j27]) - i = encodeVarintPublic(dAtA, i, uint64(j27)) + i -= j28 + copy(dAtA[i:], dAtA29[:j28]) + i = encodeVarintPublic(dAtA, i, uint64(j28)) i-- dAtA[i] = 0x2a } @@ -3144,20 +3245,20 @@ func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.IDs) > 0 { - dAtA30 := make([]byte, len(m.IDs)*10) - var j29 int + dAtA31 := make([]byte, len(m.IDs)*10) + var j30 int for _, num := range m.IDs { for num >= 1<<7 { - dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80) + dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j29++ + j30++ } - dAtA30[j29] = uint8(num) - j29++ + dAtA31[j30] = uint8(num) + j30++ } - i -= j29 - copy(dAtA[i:], dAtA30[:j29]) - i = encodeVarintPublic(dAtA, i, uint64(j29)) + i -= j30 + copy(dAtA[i:], dAtA31[:j30]) + i = encodeVarintPublic(dAtA, i, uint64(j30)) i-- dAtA[i] = 0x1a } @@ -3189,20 +3290,20 @@ func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.IDs) > 0 { - dAtA32 := make([]byte, len(m.IDs)*10) - var j31 int + dAtA33 := make([]byte, len(m.IDs)*10) + var j32 int for _, num := range m.IDs { for num >= 1<<7 { - dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80) + dAtA33[j32] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j31++ + j32++ } - dAtA32[j31] = uint8(num) - j31++ + dAtA33[j32] = uint8(num) + j32++ } - i -= j31 - copy(dAtA[i:], dAtA32[:j31]) - i = encodeVarintPublic(dAtA, i, uint64(j31)) + i -= j32 + copy(dAtA[i:], dAtA33[:j32]) + i = encodeVarintPublic(dAtA, i, uint64(j32)) i-- dAtA[i] = 0x1a } @@ -3388,20 +3489,20 @@ func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error copy(dAtA[i:], m.XXX_unrecognized) } if len(m.ColumnIDs) > 0 { - dAtA34 := make([]byte, len(m.ColumnIDs)*10) - var j33 int + dAtA35 := make([]byte, len(m.ColumnIDs)*10) + var j34 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80) + dAtA35[j34] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j33++ + j34++ } - dAtA34[j33] = uint8(num) - j33++ + dAtA35[j34] = uint8(num) + j34++ } - i -= j33 - copy(dAtA[i:], dAtA34[:j33]) - i = encodeVarintPublic(dAtA, i, uint64(j33)) + i -= j34 + copy(dAtA[i:], dAtA35[:j34]) + i = encodeVarintPublic(dAtA, i, uint64(j34)) i-- dAtA[i] = 0x2a } @@ -3591,6 +3692,21 @@ func (m *PairsField) Size() (n int) { return n } +func (m *Int64) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Value != 0 { + n += 1 + sovPublic(uint64(m.Value)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *FieldRow) Size() (n int) { if m == nil { return 0 @@ -3608,6 +3724,10 @@ func (m *FieldRow) Size() (n int) { if l > 0 { n += 1 + l + sovPublic(uint64(l)) } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovPublic(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -5057,6 +5177,79 @@ func (m *PairsField) Unmarshal(dAtA []byte) error { } return nil } +func (m *Int64) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Int64: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Int64: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Value |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPublic(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPublic + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthPublic + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *FieldRow) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -5169,6 +5362,42 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error { } m.RowKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPublic + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPublic + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Value == nil { + m.Value = &Int64{} + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPublic(dAtA[iNdEx:]) diff --git a/internal/public.proto b/internal/public.proto index 9ff1eae68..902d27efc 100644 --- a/internal/public.proto +++ b/internal/public.proto @@ -35,10 +35,15 @@ message PairsField { string Field = 2; } -message FieldRow{ +message Int64 { + int64 Value = 1; +} + +message FieldRow { string Field = 1; uint64 RowID = 2; string RowKey = 3; + Int64 Value = 4; } message GroupCount{ diff --git a/server/grpc.go b/server/grpc.go index 045753f06..e858dee29 100644 --- a/server/grpc.go +++ b/server/grpc.go @@ -738,6 +738,8 @@ func makeRows(resp pilosa.QueryResponse, logger logger.Logger) chan *pb.RowRespo for _, fieldRow := range gc.Group { if fieldRow.RowKey != "" { ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "string"}) + } else if fieldRow.Value != nil { + ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "int64"}) } else { ci = append(ci, &pb.ColumnInfo{Name: fieldRow.Field, Datatype: "uint64"}) } @@ -753,8 +755,10 @@ func makeRows(resp pilosa.QueryResponse, logger logger.Logger) chan *pb.RowRespo for _, fieldRow := range gc.Group { if fieldRow.RowKey != "" { rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_StringVal{StringVal: fieldRow.RowKey}}) + } else if fieldRow.Value != nil { + rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: *fieldRow.Value}}) } else { - rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Uint64Val{Uint64Val: uint64(fieldRow.RowID)}}) + rowResp.Columns = append(rowResp.Columns, &pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Uint64Val{Uint64Val: fieldRow.RowID}}) } } rowResp.Columns = append(rowResp.Columns, diff --git a/server/grpc_internal_test.go b/server/grpc_internal_test.go index 722a6a694..54d57468a 100644 --- a/server/grpc_internal_test.go +++ b/server/grpc_internal_test.go @@ -30,6 +30,7 @@ func TestGRPC(t *testing.T) { type expColumn interface{} + va, vb := int64(-11), int64(-12) tests := []struct { result interface{} expHeaders []expHeader @@ -138,6 +139,13 @@ func TestGRPC(t *testing.T) { }, Count: 456, }, + pilosa.GroupCount{ + Group: []pilosa.FieldRow{ + {Field: "va", Value: &va}, + {Field: "vb", Value: &vb}, + }, + Count: 789, + }, }, []expHeader{ {"a", "uint64"}, @@ -148,6 +156,7 @@ func TestGRPC(t *testing.T) { [][]expColumn{ {uint64(10), uint64(11), uint64(123), int64(0)}, {uint64(10), uint64(12), uint64(456), int64(0)}, + {int64(va), int64(vb), uint64(789), int64(0)}, }, }, // []GroupCount (string)