scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-08-28 02:44:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

change Rows() to RowIDs() and add RowIdentifiers return type to hold row keys

Browse source
This commit is contained in:
Travis Turner 2018-09-05 10:55:00 -05:00
parent f0666b2be0
commit 71ad297450
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
5 changed files with 506 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
encoding/proto/proto.go
View file

@ -366,6 +366,9 @@ func encodeQueryResponse(m *pilosa.QueryResponse) *internal.QueryResponse {
case []pilosa.GroupCount:
pb.Results[i].Type = queryResultTypeGroupCounts
pb.Results[i].GroupCounts = encodeGroupCounts(result)
case pilosa.RowIdentifiers:
pb.Results[i].Type = queryResultTypeRowIdentifiers
pb.Results[i].RowIdentifiers = encodeRowIdentifiers(result)
case nil:
pb.Results[i].Type = queryResultTypeNil
}
@ -898,7 +901,6 @@ func decodeQueryResponse(pb *internal.QueryResponse, m *pilosa.QueryResponse) {
}
m.Results = make([]interface{}, len(pb.Results))
decodeQueryResults(pb.Results, m.Results)
}
func decodeColumnAttrSets(pb []*internal.ColumnAttrSet, m []*pilosa.ColumnAttrSet) {
@ -930,6 +932,7 @@ const (
queryResultTypeBool
queryResultTypeRowIDs
queryResultTypeGroupCounts
queryResultTypeRowIdentifiers
)
func decodeQueryResult(pb *internal.QueryResult) interface{} {
@ -1069,6 +1072,14 @@ func encodeRow(r *pilosa.Row) *internal.Row {
}
}
func encodeRowIdentifiers(r pilosa.RowIdentifiers) *internal.RowIdentifiers {
return &internal.RowIdentifiers{
Rows: r.Rows,
Keys: r.Keys,
//Attrs: encodeAttrs(r.Attrs),
}
}
func encodeGroupCounts(counts []pilosa.GroupCount) []*internal.GroupCount {
result := make([]*internal.GroupCount, len(counts))
for i := range counts {

59
executor.go
View file

@ -196,9 +196,9 @@ func (e *executor) executeCall(ctx context.Context, index string, c *pql.Call, s
case "TopN":
e.Holder.Stats.CountWithCustomTags(c.Name, 1, 1.0, []string{indexTag})
return e.executeTopN(ctx, index, c, shards, opt)
case "Rows":
case "RowIDs":
e.Holder.Stats.CountWithCustomTags(c.Name, 1, 1.0, []string{indexTag})
return e.executeRows(ctx, index, c, shards, opt)
return e.executeRowIDs(ctx, index, c, shards, opt)
case "GroupBy":
e.Holder.Stats.CountWithCustomTags(c.Name, 1, 1.0, []string{indexTag})
return e.executeGroupBy(ctx, index, c, shards, opt)
@ -722,9 +722,23 @@ func (e *executor) executeDifferenceShard(ctx context.Context, index string, c *
return other, nil
}
// RowIdentifiers is a return type for a list of
// row ids or row keys. The names `Rows` and `Keys`
// are meant to follow the same convention as the
// Row query which returns `Columns` and `Keys`.
// TODO: Rename this to something better. Anything.
type RowIdentifiers struct {
Rows []uint64 `json:"rows"`
Keys []string `json:"keys,omitempty"`
}
// RowIDs is a query return type for just uint64 row ids.
// It should only be used internally (since RowIdentifiers
// is the external return type), but it is exported because
// the proto package needs access to it.
type RowIDs []uint64
func (r RowIDs) Merge(other RowIDs) RowIDs {
func (r RowIDs) merge(other RowIDs) RowIDs {
i, j := 0, 0
result := make(RowIDs, 0)
for i < len(r) && j < len(other) {
@ -942,15 +956,16 @@ func product(input [][]gbi) []ppi {
}
return res
}
func (e *executor) executeRows(ctx context.Context, index string, c *pql.Call, shards []uint64, opt *execOptions) (RowIDs, error) {
func (e *executor) executeRowIDs(ctx context.Context, index string, c *pql.Call, shards []uint64, opt *execOptions) (RowIDs, error) {
// Execute calls in bulk on each remote node and merge.
mapFn := func(shard uint64) (interface{}, error) {
return e.executeRowsShard(ctx, index, c, shard)
return e.executeRowIDsShard(ctx, index, c, shard)
}
// Merge returned results at coordinating node.
reduceFn := func(prev, v interface{}) interface{} {
other, _ := prev.(RowIDs)
return other.Merge(v.(RowIDs))
return other.merge(v.(RowIDs))
}
// Get full result set.
other, err := e.mapReduce(ctx, index, shards, c, opt, mapFn, reduceFn)
@ -976,7 +991,8 @@ func (e *executor) executeRows(ctx context.Context, index string, c *pql.Call, s
}
return results, nil
}
func (e *executor) executeRowsShard(ctx context.Context, index string, c *pql.Call, shard uint64) (RowIDs, error) {
func (e *executor) executeRowIDsShard(ctx context.Context, index string, c *pql.Call, shard uint64) (RowIDs, error) {
// Fetch index.
idx := e.Holder.Index(index)
if idx == nil {
@ -985,7 +1001,7 @@ func (e *executor) executeRowsShard(ctx context.Context, index string, c *pql.Ca
// Fetch field name from argument.
fieldName, ok := c.Args["field"].(string)
if !ok {
return nil, errors.New("Rows() argument required: field")
return nil, errors.New("RowIDs() argument required: field")
}
// Fetch field.
f := e.Holder.Field(index, fieldName)
@ -2121,6 +2137,31 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
})
}
return other, nil
case RowIDs:
other := RowIdentifiers{}
fieldName := callArgString(call, "field")
if fieldName == "" {
return nil, ErrFieldNotFound
}
if field := idx.Field(fieldName); field == nil {
return nil, ErrFieldNotFound
} else if field.keys() {
other.Keys = make([]string, len(result))
for i, id := range result {
key, err := e.TranslateStore.TranslateRowToString(index, fieldName, id)
if err != nil {
return nil, err
}
other.Keys[i] = key
}
} else {
other.Rows = result
}
return other, nil
}
return result, nil
@ -2171,7 +2212,7 @@ func needsShards(calls []*pql.Call) bool {
switch call.Name {
case "Clear", "Set", "SetRowAttrs", "SetColumnAttrs":
continue
case "Count", "TopN", "Rows":
case "Count", "TopN", "RowIDs":
return true
// default catches Bitmap calls
default:

22
executor_test.go
View file

@ -1639,7 +1639,7 @@ func benchmarkExistence(nn bool, b *testing.B) {
func BenchmarkExecutor_Existence_True(b *testing.B) { benchmarkExistence(true, b) }
func BenchmarkExecutor_Existence_False(b *testing.B) { benchmarkExistence(false, b) }
func TestExecutor_Execute_Rows(t *testing.T) {
func TestExecutor_Execute_RowIDs(t *testing.T) {
c := test.MustRunCluster(t, 1)
defer c.Close()
hldr := test.Holder{Holder: c[0].Server.Holder()}
@ -1649,24 +1649,28 @@ func TestExecutor_Execute_Rows(t *testing.T) {
hldr.SetBit("i", "general", 11, ShardWidth+2)
hldr.SetBit("i", "general", 12, 2)
hldr.SetBit("i", "general", 12, ShardWidth+2)
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `Rows(field=general)`}); err != nil {
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `RowIDs(field=general)`}); err != nil {
t.Fatal(err)
} else if columns := res.Results[0].(pilosa.RowIDs); !reflect.DeepEqual(columns, pilosa.RowIDs{10, 11, 12}) {
} else if columns := res.Results[0].(pilosa.RowIdentifiers); !reflect.DeepEqual(columns, pilosa.RowIdentifiers{Rows: []uint64{10, 11, 12}}) {
t.Fatalf("unexpected columns: %+v", columns)
}
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `Rows(field=general, limit=2)`}); err != nil {
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `RowIDs(field=general, limit=2)`}); err != nil {
t.Fatal(err)
} else if columns := res.Results[0].(pilosa.RowIDs); !reflect.DeepEqual(columns, pilosa.RowIDs{10, 11}) {
} else if columns := res.Results[0].(pilosa.RowIdentifiers); !reflect.DeepEqual(columns, pilosa.RowIdentifiers{Rows: []uint64{10, 11}}) {
t.Fatalf("unexpected columns: %+v", columns)
}
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `Rows(field=general, offset=1,limit=2)`}); err != nil {
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `RowIDs(field=general, offset=1,limit=2)`}); err != nil {
t.Fatal(err)
} else if columns := res.Results[0].(pilosa.RowIDs); !reflect.DeepEqual(columns, pilosa.RowIDs{11, 12}) {
} else if columns := res.Results[0].(pilosa.RowIdentifiers); !reflect.DeepEqual(columns, pilosa.RowIdentifiers{Rows: []uint64{11, 12}}) {
t.Fatalf("unexpected columns: %+v", columns)
}
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `Rows(field=general, column=2)`}); err != nil {
if res, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `RowIDs(field=general, column=2)`}); err != nil {
t.Fatal(err)
} else if columns := res.Results[0].(pilosa.RowIDs); !reflect.DeepEqual(columns, pilosa.RowIDs{11, 12}) {
} else if columns := res.Results[0].(pilosa.RowIdentifiers); !reflect.DeepEqual(columns, pilosa.RowIdentifiers{Rows: []uint64{11, 12}}) {
t.Fatalf("unexpected columns: %+v", columns)
}
}

554
internal/public.pb.go
View file

@ -9,6 +9,7 @@
It has these top-level messages:
Row
RowIdentifiers
Pair
FieldRow
GroupCount
@ -76,6 +77,30 @@ func (m *Row) GetAttrs() []*Attr {
return nil
}
type RowIdentifiers struct {
Rows []uint64 `protobuf:"varint,1,rep,packed,name=Rows" json:"Rows,omitempty"`
Keys []string `protobuf:"bytes,2,rep,name=Keys" json:"Keys,omitempty"`
}
func (m *RowIdentifiers) Reset() { *m = RowIdentifiers{} }
func (m *RowIdentifiers) String() string { return proto.CompactTextString(m) }
func (*RowIdentifiers) ProtoMessage() {}
func (*RowIdentifiers) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{1} }
func (m *RowIdentifiers) GetRows() []uint64 {
if m != nil {
return m.Rows
}
return nil
}
func (m *RowIdentifiers) GetKeys() []string {
if m != nil {
return m.Keys
}
return nil
}
type Pair struct {
ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
Key string `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
@ -85,7 +110,7 @@ type Pair struct {
func (m *Pair) Reset() { *m = Pair{} }
func (m *Pair) String() string { return proto.CompactTextString(m) }
func (*Pair) ProtoMessage() {}
func (*Pair) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{1} }
func (*Pair) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{2} }
func (m *Pair) GetID() uint64 {
if m != nil {
@ -116,7 +141,7 @@ type FieldRow struct {
func (m *FieldRow) Reset() { *m = FieldRow{} }
func (m *FieldRow) String() string { return proto.CompactTextString(m) }
func (*FieldRow) ProtoMessage() {}
func (*FieldRow) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{2} }
func (*FieldRow) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{3} }
func (m *FieldRow) GetField() string {
if m != nil {
@ -140,7 +165,7 @@ type GroupCount struct {
func (m *GroupCount) Reset() { *m = GroupCount{} }
func (m *GroupCount) String() string { return proto.CompactTextString(m) }
func (*GroupCount) ProtoMessage() {}
func (*GroupCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{3} }
func (*GroupCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{4} }
func (m *GroupCount) GetGroup() []*FieldRow {
if m != nil {
@ -164,7 +189,7 @@ type ValCount struct {
func (m *ValCount) Reset() { *m = ValCount{} }
func (m *ValCount) String() string { return proto.CompactTextString(m) }
func (*ValCount) ProtoMessage() {}
func (*ValCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{4} }
func (*ValCount) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{5} }
func (m *ValCount) GetVal() int64 {
if m != nil {
@ -189,7 +214,7 @@ type Bit struct {
func (m *Bit) Reset() { *m = Bit{} }
func (m *Bit) String() string { return proto.CompactTextString(m) }
func (*Bit) ProtoMessage() {}
func (*Bit) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{5} }
func (*Bit) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{6} }
func (m *Bit) GetRowID() uint64 {
if m != nil {
@ -221,7 +246,7 @@ type ColumnAttrSet struct {
func (m *ColumnAttrSet) Reset() { *m = ColumnAttrSet{} }
func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) }
func (*ColumnAttrSet) ProtoMessage() {}
func (*ColumnAttrSet) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{6} }
func (*ColumnAttrSet) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{7} }
func (m *ColumnAttrSet) GetID() uint64 {
if m != nil {
@ -256,7 +281,7 @@ type Attr struct {
func (m *Attr) Reset() { *m = Attr{} }
func (m *Attr) String() string { return proto.CompactTextString(m) }
func (*Attr) ProtoMessage() {}
func (*Attr) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{7} }
func (*Attr) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{8} }
func (m *Attr) GetKey() string {
if m != nil {
@ -307,7 +332,7 @@ type AttrMap struct {
func (m *AttrMap) Reset() { *m = AttrMap{} }
func (m *AttrMap) String() string { return proto.CompactTextString(m) }
func (*AttrMap) ProtoMessage() {}
func (*AttrMap) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{8} }
func (*AttrMap) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{9} }
func (m *AttrMap) GetAttrs() []*Attr {
if m != nil {
@ -328,7 +353,7 @@ type QueryRequest struct {
func (m *QueryRequest) Reset() { *m = QueryRequest{} }
func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRequest) ProtoMessage() {}
func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{9} }
func (*QueryRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{10} }
func (m *QueryRequest) GetQuery() string {
if m != nil {
@ -381,7 +406,7 @@ type QueryResponse struct {
func (m *QueryResponse) Reset() { *m = QueryResponse{} }
func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
func (*QueryResponse) ProtoMessage() {}
func (*QueryResponse) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{10} }
func (*QueryResponse) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{11} }
func (m *QueryResponse) GetErr() string {
if m != nil {
@ -405,20 +430,21 @@ func (m *QueryResponse) GetColumnAttrSets() []*ColumnAttrSet {
}
type QueryResult struct {
Type uint32 `protobuf:"varint,6,opt,name=Type,proto3" json:"Type,omitempty"`
Row *Row `protobuf:"bytes,1,opt,name=Row" json:"Row,omitempty"`
N uint64 `protobuf:"varint,2,opt,name=N,proto3" json:"N,omitempty"`
Pairs []*Pair `protobuf:"bytes,3,rep,name=Pairs" json:"Pairs,omitempty"`
Changed bool `protobuf:"varint,4,opt,name=Changed,proto3" json:"Changed,omitempty"`
ValCount *ValCount `protobuf:"bytes,5,opt,name=ValCount" json:"ValCount,omitempty"`
RowIDs []uint64 `protobuf:"varint,7,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
GroupCounts []*GroupCount `protobuf:"bytes,8,rep,name=GroupCounts" json:"GroupCounts,omitempty"`
Type uint32 `protobuf:"varint,6,opt,name=Type,proto3" json:"Type,omitempty"`
Row *Row `protobuf:"bytes,1,opt,name=Row" json:"Row,omitempty"`
N uint64 `protobuf:"varint,2,opt,name=N,proto3" json:"N,omitempty"`
Pairs []*Pair `protobuf:"bytes,3,rep,name=Pairs" json:"Pairs,omitempty"`
Changed bool `protobuf:"varint,4,opt,name=Changed,proto3" json:"Changed,omitempty"`
ValCount *ValCount `protobuf:"bytes,5,opt,name=ValCount" json:"ValCount,omitempty"`
RowIDs []uint64 `protobuf:"varint,7,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
GroupCounts []*GroupCount `protobuf:"bytes,8,rep,name=GroupCounts" json:"GroupCounts,omitempty"`
RowIdentifiers *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers" json:"RowIdentifiers,omitempty"`
}
func (m *QueryResult) Reset() { *m = QueryResult{} }
func (m *QueryResult) String() string { return proto.CompactTextString(m) }
func (*QueryResult) ProtoMessage() {}
func (*QueryResult) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{11} }
func (*QueryResult) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{12} }
func (m *QueryResult) GetType() uint32 {
if m != nil {
@ -476,6 +502,13 @@ func (m *QueryResult) GetGroupCounts() []*GroupCount {
return nil
}
func (m *QueryResult) GetRowIdentifiers() *RowIdentifiers {
if m != nil {
return m.RowIdentifiers
}
return nil
}
type ImportRequest struct {
Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
@ -490,7 +523,7 @@ type ImportRequest struct {
func (m *ImportRequest) Reset() { *m = ImportRequest{} }
func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
func (*ImportRequest) ProtoMessage() {}
func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{12} }
func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{13} }
func (m *ImportRequest) GetIndex() string {
if m != nil {
@ -560,7 +593,7 @@ type ImportValueRequest struct {
func (m *ImportValueRequest) Reset() { *m = ImportValueRequest{} }
func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) }
func (*ImportValueRequest) ProtoMessage() {}
func (*ImportValueRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{13} }
func (*ImportValueRequest) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{14} }
func (m *ImportValueRequest) GetIndex() string {
if m != nil {
@ -606,6 +639,7 @@ func (m *ImportValueRequest) GetValues() []int64 {
func init() {
proto.RegisterType((*Row)(nil), "internal.Row")
proto.RegisterType((*RowIdentifiers)(nil), "internal.RowIdentifiers")
proto.RegisterType((*Pair)(nil), "internal.Pair")
proto.RegisterType((*FieldRow)(nil), "internal.FieldRow")
proto.RegisterType((*GroupCount)(nil), "internal.GroupCount")
@ -682,6 +716,56 @@ func (m *Row) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *RowIdentifiers) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *RowIdentifiers) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Rows) > 0 {
dAtA4 := make([]byte, len(m.Rows)*10)
var j3 int
for _, num := range m.Rows {
for num >= 1<<7 {
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j3++
}
dAtA4[j3] = uint8(num)
j3++
}
dAtA[i] = 0xa
i++
i = encodeVarintPublic(dAtA, i, uint64(j3))
i += copy(dAtA[i:], dAtA4[:j3])
}
if len(m.Keys) > 0 {
for _, s := range m.Keys {
dAtA[i] = 0x12
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
return i, nil
}
func (m *Pair) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -990,21 +1074,21 @@ func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
i += copy(dAtA[i:], m.Query)
}
if len(m.Shards) > 0 {
dAtA4 := make([]byte, len(m.Shards)*10)
var j3 int
dAtA6 := make([]byte, len(m.Shards)*10)
var j5 int
for _, num := range m.Shards {
for num >= 1<<7 {
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j3++
j5++
}
dAtA4[j3] = uint8(num)
j3++
dAtA6[j5] = uint8(num)
j5++
}
dAtA[i] = 0x12
i++
i = encodeVarintPublic(dAtA, i, uint64(j3))
i += copy(dAtA[i:], dAtA4[:j3])
i = encodeVarintPublic(dAtA, i, uint64(j5))
i += copy(dAtA[i:], dAtA6[:j5])
}
if m.ColumnAttrs {
dAtA[i] = 0x18
@ -1116,11 +1200,11 @@ func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintPublic(dAtA, i, uint64(m.Row.Size()))
n5, err := m.Row.MarshalTo(dAtA[i:])
n7, err := m.Row.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
i += n7
}
if m.N != 0 {
dAtA[i] = 0x10
@ -1153,11 +1237,11 @@ func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintPublic(dAtA, i, uint64(m.ValCount.Size()))
n6, err := m.ValCount.MarshalTo(dAtA[i:])
n8, err := m.ValCount.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
i += n8
}
if m.Type != 0 {
dAtA[i] = 0x30
@ -1165,21 +1249,21 @@ func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintPublic(dAtA, i, uint64(m.Type))
}
if len(m.RowIDs) > 0 {
dAtA8 := make([]byte, len(m.RowIDs)*10)
var j7 int
dAtA10 := make([]byte, len(m.RowIDs)*10)
var j9 int
for _, num := range m.RowIDs {
for num >= 1<<7 {
dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j7++
j9++
}
dAtA8[j7] = uint8(num)
j7++
dAtA10[j9] = uint8(num)
j9++
}
dAtA[i] = 0x3a
i++
i = encodeVarintPublic(dAtA, i, uint64(j7))
i += copy(dAtA[i:], dAtA8[:j7])
i = encodeVarintPublic(dAtA, i, uint64(j9))
i += copy(dAtA[i:], dAtA10[:j9])
}
if len(m.GroupCounts) > 0 {
for _, msg := range m.GroupCounts {
@ -1193,6 +1277,16 @@ func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
i += n
}
}
if m.RowIdentifiers != nil {
dAtA[i] = 0x4a
i++
i = encodeVarintPublic(dAtA, i, uint64(m.RowIdentifiers.Size()))
n11, err := m.RowIdentifiers.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n11
}
return i, nil
}
@ -1229,56 +1323,56 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
}
if len(m.RowIDs) > 0 {
dAtA10 := make([]byte, len(m.RowIDs)*10)
var j9 int
dAtA13 := make([]byte, len(m.RowIDs)*10)
var j12 int
for _, num := range m.RowIDs {
for num >= 1<<7 {
dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j9++
j12++
}
dAtA10[j9] = uint8(num)
j9++
dAtA13[j12] = uint8(num)
j12++
}
dAtA[i] = 0x22
i++
i = encodeVarintPublic(dAtA, i, uint64(j9))
i += copy(dAtA[i:], dAtA10[:j9])
i = encodeVarintPublic(dAtA, i, uint64(j12))
i += copy(dAtA[i:], dAtA13[:j12])
}
if len(m.ColumnIDs) > 0 {
dAtA12 := make([]byte, len(m.ColumnIDs)*10)
var j11 int
dAtA15 := make([]byte, len(m.ColumnIDs)*10)
var j14 int
for _, num := range m.ColumnIDs {
for num >= 1<<7 {
dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j11++
j14++
}
dAtA12[j11] = uint8(num)
j11++
dAtA15[j14] = uint8(num)
j14++
}
dAtA[i] = 0x2a
i++
i = encodeVarintPublic(dAtA, i, uint64(j11))
i += copy(dAtA[i:], dAtA12[:j11])
i = encodeVarintPublic(dAtA, i, uint64(j14))
i += copy(dAtA[i:], dAtA15[:j14])
}
if len(m.Timestamps) > 0 {
dAtA14 := make([]byte, len(m.Timestamps)*10)
var j13 int
dAtA17 := make([]byte, len(m.Timestamps)*10)
var j16 int
for _, num1 := range m.Timestamps {
num := uint64(num1)
for num >= 1<<7 {
dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j13++
j16++
}
dAtA14[j13] = uint8(num)
j13++
dAtA17[j16] = uint8(num)
j16++
}
dAtA[i] = 0x32
i++
i = encodeVarintPublic(dAtA, i, uint64(j13))
i += copy(dAtA[i:], dAtA14[:j13])
i = encodeVarintPublic(dAtA, i, uint64(j16))
i += copy(dAtA[i:], dAtA17[:j16])
}
if len(m.RowKeys) > 0 {
for _, s := range m.RowKeys {
@ -1346,39 +1440,39 @@ func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
}
if len(m.ColumnIDs) > 0 {
dAtA16 := make([]byte, len(m.ColumnIDs)*10)
var j15 int
dAtA19 := make([]byte, len(m.ColumnIDs)*10)
var j18 int
for _, num := range m.ColumnIDs {
for num >= 1<<7 {
dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j15++
j18++
}
dAtA16[j15] = uint8(num)
j15++
dAtA19[j18] = uint8(num)
j18++
}
dAtA[i] = 0x2a
i++
i = encodeVarintPublic(dAtA, i, uint64(j15))
i += copy(dAtA[i:], dAtA16[:j15])
i = encodeVarintPublic(dAtA, i, uint64(j18))
i += copy(dAtA[i:], dAtA19[:j18])
}
if len(m.Values) > 0 {
dAtA18 := make([]byte, len(m.Values)*10)
var j17 int
dAtA21 := make([]byte, len(m.Values)*10)
var j20 int
for _, num1 := range m.Values {
num := uint64(num1)
for num >= 1<<7 {
dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j17++
j20++
}
dAtA18[j17] = uint8(num)
j17++
dAtA21[j20] = uint8(num)
j20++
}
dAtA[i] = 0x32
i++
i = encodeVarintPublic(dAtA, i, uint64(j17))
i += copy(dAtA[i:], dAtA18[:j17])
i = encodeVarintPublic(dAtA, i, uint64(j20))
i += copy(dAtA[i:], dAtA21[:j20])
}
if len(m.ColumnKeys) > 0 {
for _, s := range m.ColumnKeys {
@ -1432,6 +1526,25 @@ func (m *Row) Size() (n int) {
return n
}
func (m *RowIdentifiers) Size() (n int) {
var l int
_ = l
if len(m.Rows) > 0 {
l = 0
for _, e := range m.Rows {
l += sovPublic(uint64(e))
}
n += 1 + sovPublic(uint64(l)) + l
}
if len(m.Keys) > 0 {
for _, s := range m.Keys {
l = len(s)
n += 1 + l + sovPublic(uint64(l))
}
}
return n
}
func (m *Pair) Size() (n int) {
var l int
_ = l
@ -1650,6 +1763,10 @@ func (m *QueryResult) Size() (n int) {
n += 1 + l + sovPublic(uint64(l))
}
}
if m.RowIdentifiers != nil {
l = m.RowIdentifiers.Size()
n += 1 + l + sovPublic(uint64(l))
}
return n
}
@ -1925,6 +2042,147 @@ func (m *Row) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *RowIdentifiers) 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: RowIdentifiers: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RowIdentifiers: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType == 0 {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Rows = append(m.Rows, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthPublic
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
for iNdEx < postIndex {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Rows = append(m.Rows, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthPublic
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Keys = append(m.Keys, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPublic(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Pair) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -3461,6 +3719,39 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RowIdentifiers", 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 > l {
return io.ErrUnexpectedEOF
}
if m.RowIdentifiers == nil {
m.RowIdentifiers = &RowIdentifiers{}
}
if err := m.RowIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPublic(dAtA[iNdEx:])
@ -4241,53 +4532,56 @@ var (
func init() { proto.RegisterFile("public.proto", fileDescriptorPublic) }
var fileDescriptorPublic = []byte{
// 764 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x4a,
0x14, 0xbe, 0x13, 0x3b, 0x89, 0x73, 0xd2, 0xe4, 0x56, 0xa3, 0xde, 0x5e, 0x0b, 0x55, 0xc1, 0xb2,
0x10, 0xf2, 0x2a, 0x95, 0x82, 0xd4, 0x25, 0x88, 0xfe, 0xa1, 0xa8, 0x50, 0xc1, 0xb4, 0x14, 0xb1,
0x74, 0x9b, 0x51, 0x6b, 0xc9, 0xf1, 0x18, 0xff, 0x28, 0xcd, 0x5b, 0x20, 0xb1, 0xe1, 0x11, 0x58,
0xf0, 0x20, 0x5d, 0xf2, 0x08, 0x50, 0x5e, 0x04, 0xcd, 0x19, 0x4f, 0xc6, 0x49, 0x51, 0xc5, 0x82,
0x9d, 0xbf, 0xef, 0xcc, 0x39, 0xf9, 0xce, 0x6f, 0x60, 0x2d, 0x2d, 0xcf, 0xe3, 0xe8, 0x62, 0x98,
0x66, 0xa2, 0x10, 0xd4, 0x89, 0x92, 0x82, 0x67, 0x49, 0x18, 0xfb, 0xef, 0xc1, 0x62, 0x62, 0x46,
0x5d, 0x68, 0xef, 0x89, 0xb8, 0x9c, 0x26, 0xb9, 0x4b, 0x3c, 0x2b, 0xb0, 0x99, 0x86, 0xf4, 0x11,
0x34, 0x9f, 0x17, 0x45, 0x96, 0xbb, 0x0d, 0xcf, 0x0a, 0xba, 0xa3, 0xfe, 0x50, 0xbb, 0x0e, 0x25,
0xcd, 0x94, 0x91, 0x52, 0xb0, 0x8f, 0xf8, 0x3c, 0x77, 0x2d, 0xcf, 0x0a, 0x3a, 0x0c, 0xbf, 0xfd,
0xa7, 0x60, 0xbf, 0x0e, 0xa3, 0x8c, 0xf6, 0xa1, 0x31, 0xde, 0x77, 0x89, 0x47, 0x02, 0x9b, 0x35,
0xc6, 0xfb, 0x74, 0x03, 0x9a, 0x7b, 0xa2, 0x4c, 0x0a, 0xb7, 0x81, 0x94, 0x02, 0x74, 0x1d, 0xac,
0x23, 0x3e, 0x77, 0x2d, 0x8f, 0x04, 0x1d, 0x26, 0x3f, 0xfd, 0x1d, 0x70, 0x0e, 0x23, 0x1e, 0x4f,
0xa4, 0xbe, 0x0d, 0x68, 0xe2, 0x37, 0x86, 0xe9, 0x30, 0x05, 0x24, 0xcb, 0xc4, 0x6c, 0xbc, 0xaf,
0x23, 0x21, 0xf0, 0x5f, 0x02, 0xbc, 0xc8, 0x44, 0x99, 0xaa, 0xb8, 0x01, 0x34, 0x11, 0x61, 0x5e,
0xdd, 0x11, 0x35, 0xfa, 0x75, 0x70, 0xa6, 0x1e, 0xfc, 0x5e, 0x97, 0x3f, 0x02, 0xe7, 0x2c, 0x8c,
0x17, 0x1a, 0xcf, 0xc2, 0x18, 0x35, 0x58, 0x4c, 0x7e, 0x2e, 0xfb, 0x58, 0xda, 0xe7, 0x2d, 0x58,
0xbb, 0x51, 0x61, 0xe4, 0x91, 0x9a, 0x3c, 0xfa, 0x00, 0x1c, 0x55, 0xdb, 0x85, 0xee, 0x05, 0xa6,
0x5b, 0xd0, 0x39, 0x8d, 0xa6, 0x3c, 0x2f, 0xc2, 0x69, 0x8a, 0xa5, 0xb0, 0x98, 0x21, 0xfc, 0x77,
0xd0, 0x53, 0x2f, 0x65, 0xcd, 0x4f, 0x78, 0x71, 0xa7, 0xb2, 0x7f, 0xd6, 0xab, 0xbb, 0x95, 0xfe,
0x42, 0xc0, 0x96, 0x36, 0x6d, 0x22, 0x0b, 0x93, 0x6c, 0xec, 0xe9, 0x3c, 0xe5, 0x95, 0x52, 0xfc,
0xa6, 0x1e, 0x74, 0x4f, 0x8a, 0x2c, 0x4a, 0x2e, 0xcf, 0xc2, 0xb8, 0xe4, 0x55, 0xa0, 0x3a, 0x25,
0x73, 0x1c, 0x27, 0x85, 0x32, 0xdb, 0x98, 0xc6, 0x02, 0xcb, 0x1c, 0x77, 0x85, 0x88, 0x95, 0xb1,
0xe9, 0x91, 0xc0, 0x61, 0x86, 0xa0, 0x03, 0x80, 0xc3, 0x58, 0x84, 0x95, 0x6f, 0xcb, 0x23, 0x01,
0x61, 0x35, 0xc6, 0xdf, 0x86, 0xb6, 0x54, 0xfa, 0x2a, 0x4c, 0x4d, 0xb6, 0xe4, 0x9e, 0x6c, 0xfd,
0x1b, 0x02, 0x6b, 0x6f, 0x4a, 0x9e, 0xcd, 0x19, 0xff, 0x50, 0xf2, 0x1c, 0xbb, 0x82, 0x58, 0x8f,
0x12, 0x02, 0xba, 0x09, 0xad, 0x93, 0xab, 0x30, 0x9b, 0xa8, 0xda, 0xd9, 0xac, 0x42, 0x32, 0x57,
0x53, 0xf3, 0x1c, 0x73, 0x75, 0x58, 0x9d, 0x92, 0x9e, 0x8c, 0x4f, 0x45, 0xa1, 0x93, 0xa9, 0x10,
0x0d, 0xe0, 0xdf, 0x83, 0xeb, 0x8b, 0xb8, 0x9c, 0x70, 0x26, 0x66, 0xca, 0xbb, 0x85, 0x0f, 0x56,
0x69, 0xfa, 0x18, 0xfa, 0x15, 0xa5, 0x77, 0xb0, 0x8d, 0x0f, 0x57, 0x58, 0xff, 0x13, 0x81, 0x5e,
0x95, 0x4a, 0x9e, 0x8a, 0x24, 0xe7, 0xb2, 0x5f, 0x07, 0x59, 0xa6, 0xfb, 0x75, 0x90, 0x65, 0x74,
0x1b, 0xda, 0x8c, 0xe7, 0x65, 0x5c, 0xe8, 0x21, 0xf8, 0xcf, 0x94, 0x45, 0xfb, 0x96, 0x71, 0xc1,
0xf4, 0x2b, 0xfa, 0x0c, 0xfa, 0x4b, 0x43, 0xa5, 0x76, 0xb8, 0x3b, 0xfa, 0xdf, 0xf8, 0x2d, 0xd9,
0xd9, 0xca, 0x73, 0xff, 0x63, 0x03, 0xba, 0xb5, 0xc8, 0xf4, 0x21, 0x5e, 0x14, 0xd4, 0xd4, 0x1d,
0xf5, 0x4c, 0x14, 0xb9, 0x69, 0x78, 0x6b, 0xd6, 0x80, 0x1c, 0x57, 0xf3, 0x44, 0x8e, 0x65, 0x17,
0xe5, 0x95, 0xd0, 0x3f, 0x5b, 0xeb, 0xa2, 0xa4, 0x99, 0x32, 0xe2, 0x7d, 0xba, 0x0a, 0x93, 0x4b,
0x3e, 0xc1, 0x79, 0x72, 0x98, 0x86, 0x74, 0x68, 0xf6, 0x13, 0x1b, 0xb0, 0xb4, 0xe2, 0xda, 0xc2,
0xcc, 0x0e, 0xeb, 0x81, 0x96, 0xbd, 0xe8, 0x55, 0x03, 0x2d, 0x5b, 0x28, 0x77, 0x53, 0x16, 0x1e,
0x9b, 0xaf, 0x10, 0xdd, 0x81, 0xae, 0xb9, 0x24, 0xb9, 0xeb, 0xa0, 0xc2, 0x0d, 0x13, 0xde, 0x18,
0x59, 0xfd, 0xa1, 0xff, 0x83, 0x40, 0x6f, 0x3c, 0x4d, 0x45, 0x56, 0xd4, 0x86, 0x6e, 0x9c, 0x4c,
0xf8, 0xb5, 0x1e, 0x3a, 0x04, 0xe6, 0xaa, 0x35, 0x56, 0xae, 0x1a, 0x0e, 0x1f, 0x0e, 0x9b, 0xcd,
0x14, 0xa8, 0x69, 0xb4, 0x97, 0x34, 0x6e, 0x41, 0x47, 0x9f, 0x8f, 0xdc, 0x6d, 0xa2, 0xc9, 0x10,
0x72, 0x9d, 0x16, 0xf7, 0x43, 0xce, 0x9f, 0x15, 0x58, 0xac, 0xc6, 0xc8, 0xba, 0x32, 0x31, 0xc3,
0xd3, 0xdd, 0xc6, 0xd3, 0xad, 0xa1, 0xf4, 0x54, 0x61, 0xd0, 0xe8, 0xa0, 0xb1, 0xc6, 0xf8, 0x5f,
0x09, 0x50, 0x95, 0x23, 0x2e, 0xe6, 0xdf, 0x4b, 0xf4, 0xfe, 0x84, 0x36, 0xa1, 0x85, 0xbf, 0xa7,
0x93, 0xa9, 0xd0, 0x8a, 0xdc, 0xf6, 0xaa, 0xdc, 0xdd, 0xf5, 0x9b, 0xdb, 0x01, 0xf9, 0x76, 0x3b,
0x20, 0xdf, 0x6f, 0x07, 0xe4, 0xf3, 0xcf, 0xc1, 0x3f, 0xe7, 0x2d, 0xfc, 0x2b, 0x7c, 0xf2, 0x2b,
0x00, 0x00, 0xff, 0xff, 0x25, 0x1f, 0x0d, 0xa8, 0x1a, 0x07, 0x00, 0x00,
// 804 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x6e, 0xdb, 0x46,
0x14, 0xed, 0x88, 0x94, 0x44, 0x5d, 0x59, 0xaa, 0x31, 0x70, 0x5d, 0xa2, 0x30, 0x54, 0x82, 0x28,
0x0a, 0xae, 0x64, 0x40, 0x05, 0x8c, 0xae, 0xfa, 0xf0, 0xab, 0x10, 0xdc, 0x1a, 0xcd, 0xd8, 0x71,
0x90, 0x25, 0x6d, 0x4d, 0x6c, 0x02, 0x14, 0x87, 0xe1, 0x03, 0xb2, 0xbe, 0x23, 0x9b, 0x7c, 0x42,
0x16, 0xf9, 0x10, 0x2f, 0x83, 0x7c, 0x41, 0xe2, 0xfc, 0x48, 0x30, 0x77, 0x38, 0x1a, 0x8a, 0x0e,
0x8c, 0x2c, 0xb2, 0x9b, 0x73, 0x5f, 0xbc, 0xe7, 0xbe, 0x08, 0x1b, 0x69, 0x79, 0x19, 0x47, 0x57,
0xe3, 0x34, 0x13, 0x85, 0xa0, 0x4e, 0x94, 0x14, 0x3c, 0x4b, 0xc2, 0xd8, 0x7f, 0x0e, 0x16, 0x13,
0x0b, 0xea, 0x42, 0xf7, 0x40, 0xc4, 0xe5, 0x3c, 0xc9, 0x5d, 0xe2, 0x59, 0x81, 0xcd, 0x34, 0xa4,
0xbf, 0x40, 0xfb, 0xef, 0xa2, 0xc8, 0x72, 0xb7, 0xe5, 0x59, 0x41, 0x7f, 0x32, 0x1c, 0x6b, 0xd7,
0xb1, 0x14, 0x33, 0xa5, 0xa4, 0x14, 0xec, 0x13, 0xbe, 0xcc, 0x5d, 0xcb, 0xb3, 0x82, 0x1e, 0xc3,
0xb7, 0xff, 0x3b, 0x0c, 0x99, 0x58, 0x4c, 0x67, 0x3c, 0x29, 0xa2, 0x17, 0x11, 0x57, 0x56, 0x4c,
0x2c, 0xf4, 0x27, 0xf0, 0xbd, 0xf2, 0x6c, 0xd5, 0x3c, 0xff, 0x00, 0xfb, 0xff, 0x30, 0xca, 0xe8,
0x10, 0x5a, 0xd3, 0x43, 0x97, 0x78, 0x24, 0xb0, 0x59, 0x6b, 0x7a, 0x48, 0xb7, 0xa0, 0x7d, 0x20,
0xca, 0xa4, 0x70, 0x5b, 0x28, 0x52, 0x80, 0x6e, 0x82, 0x75, 0xc2, 0x97, 0xae, 0xe5, 0x91, 0xa0,
0xc7, 0xe4, 0xd3, 0xdf, 0x03, 0xe7, 0x38, 0xe2, 0xf1, 0x4c, 0x32, 0xdb, 0x82, 0x36, 0xbe, 0x31,
0x4c, 0x8f, 0x29, 0x20, 0xa5, 0x32, 0xb7, 0x43, 0x1d, 0x09, 0x81, 0xff, 0x2f, 0xc0, 0x3f, 0x99,
0x28, 0x53, 0x15, 0x37, 0x80, 0x36, 0x22, 0x4c, 0xb7, 0x3f, 0xa1, 0x86, 0xb9, 0x0e, 0xce, 0x94,
0xc1, 0x97, 0xf3, 0xf2, 0x27, 0xe0, 0x5c, 0x84, 0xf1, 0x2a, 0xc7, 0x8b, 0x30, 0xc6, 0x1c, 0x2c,
0x26, 0x9f, 0xeb, 0x3e, 0x96, 0xf6, 0x79, 0x0a, 0xd6, 0x7e, 0x54, 0x98, 0xf4, 0x48, 0x2d, 0x3d,
0xfa, 0x13, 0x38, 0xaa, 0x2b, 0xab, 0xbc, 0x57, 0x98, 0xee, 0x40, 0xef, 0x3c, 0x9a, 0xf3, 0xbc,
0x08, 0xe7, 0x29, 0x96, 0xc2, 0x62, 0x46, 0xe0, 0x3f, 0x83, 0x81, 0xb2, 0x94, 0xdd, 0x3a, 0xe3,
0xc5, 0x83, 0xca, 0x7e, 0x5d, 0x97, 0x1f, 0x56, 0xfa, 0x0d, 0x01, 0x5b, 0xea, 0xb4, 0x8a, 0xac,
0x54, 0xb2, 0xb1, 0xe7, 0xcb, 0x94, 0x57, 0x99, 0xe2, 0x9b, 0x7a, 0xd0, 0x3f, 0x2b, 0xb2, 0x28,
0xb9, 0xbe, 0x08, 0xe3, 0x92, 0x57, 0x81, 0xea, 0x22, 0xc9, 0x71, 0x9a, 0x14, 0x4a, 0x6d, 0x23,
0x8d, 0x15, 0x96, 0x1c, 0xf7, 0x85, 0x88, 0x95, 0xb2, 0xed, 0x91, 0xc0, 0x61, 0x46, 0x40, 0x47,
0x00, 0xc7, 0xb1, 0x08, 0x2b, 0xdf, 0x8e, 0x47, 0x02, 0xc2, 0x6a, 0x12, 0x7f, 0x17, 0xba, 0x32,
0xd3, 0xff, 0xc2, 0xd4, 0xb0, 0x25, 0x8f, 0xb0, 0xf5, 0xef, 0x08, 0x6c, 0x3c, 0x29, 0x79, 0xb6,
0x64, 0xfc, 0x65, 0xc9, 0x73, 0xec, 0x0a, 0x62, 0x3d, 0x4a, 0x08, 0xe8, 0x36, 0x74, 0xce, 0x6e,
0xc2, 0x6c, 0xa6, 0x6a, 0x67, 0xb3, 0x0a, 0x49, 0xae, 0xa6, 0xe6, 0x39, 0x72, 0x75, 0x58, 0x5d,
0x24, 0x3d, 0x19, 0x9f, 0x8b, 0x42, 0x93, 0xa9, 0x10, 0x0d, 0xe0, 0xfb, 0xa3, 0xdb, 0xab, 0xb8,
0x9c, 0x71, 0x26, 0x16, 0xca, 0xbb, 0x83, 0x06, 0x4d, 0x31, 0xfd, 0x15, 0x86, 0x95, 0x48, 0x6f,
0x6f, 0x17, 0x0d, 0x1b, 0x52, 0xff, 0x15, 0x81, 0x41, 0x45, 0x25, 0x4f, 0x45, 0x92, 0x73, 0xd9,
0xaf, 0xa3, 0x2c, 0xd3, 0xfd, 0x3a, 0xca, 0x32, 0xba, 0x0b, 0x5d, 0xc6, 0xf3, 0x32, 0x2e, 0xf4,
0x10, 0xfc, 0x60, 0xca, 0xa2, 0x7d, 0xcb, 0xb8, 0x60, 0xda, 0x8a, 0xfe, 0x09, 0xc3, 0xb5, 0xa1,
0x52, 0xdb, 0xdf, 0x9f, 0xfc, 0x68, 0xfc, 0xd6, 0xf4, 0xac, 0x61, 0xee, 0xbf, 0x6f, 0x41, 0xbf,
0x16, 0x99, 0xfe, 0x8c, 0xb7, 0x08, 0x73, 0xea, 0x4f, 0x06, 0x26, 0x8a, 0xdc, 0x34, 0xbc, 0x52,
0x1b, 0x40, 0x4e, 0xab, 0x79, 0x22, 0xa7, 0xb2, 0x8b, 0xf2, 0x4a, 0xe8, 0xcf, 0xd6, 0xba, 0x28,
0xc5, 0x4c, 0x29, 0xf1, 0xb2, 0xdd, 0x84, 0xc9, 0x35, 0x9f, 0xe1, 0x3c, 0x39, 0x4c, 0x43, 0x3a,
0x36, 0xfb, 0x89, 0x0d, 0x58, 0x5b, 0x71, 0xad, 0x61, 0x66, 0x87, 0xf5, 0x40, 0xcb, 0x5e, 0x0c,
0xaa, 0x81, 0x96, 0x2d, 0x94, 0xbb, 0x29, 0x0b, 0x8f, 0xcd, 0x57, 0x88, 0xee, 0x41, 0xdf, 0x5c,
0x92, 0xdc, 0x75, 0x30, 0xc3, 0x2d, 0x13, 0xde, 0x28, 0x59, 0xdd, 0x90, 0xfe, 0xd5, 0xbc, 0x99,
0x6e, 0x0f, 0x33, 0x73, 0xd7, 0xaa, 0x51, 0xd3, 0xb3, 0x86, 0xbd, 0xff, 0x91, 0xc0, 0x60, 0x3a,
0x4f, 0x45, 0x56, 0xd4, 0xc6, 0x76, 0x9a, 0xcc, 0xf8, 0xad, 0x1e, 0x5b, 0x04, 0xe6, 0x2e, 0xb6,
0x1a, 0x77, 0x11, 0xc7, 0x17, 0xc7, 0xd5, 0x66, 0x0a, 0xd4, 0x58, 0xda, 0x6b, 0x2c, 0x77, 0xa0,
0xa7, 0x0f, 0x50, 0xee, 0xb6, 0x51, 0x65, 0x04, 0x72, 0x21, 0x57, 0x17, 0x48, 0x4e, 0xb0, 0x15,
0x58, 0xac, 0x26, 0x91, 0x9d, 0x61, 0x62, 0x81, 0xc7, 0xbf, 0x8b, 0xc7, 0x5f, 0x43, 0xe9, 0xa9,
0xc2, 0xa0, 0xd2, 0x41, 0x65, 0x4d, 0xe2, 0xbf, 0x25, 0x40, 0x15, 0x47, 0x5c, 0xed, 0x6f, 0x47,
0xf4, 0x71, 0x42, 0xdb, 0xd0, 0xc1, 0xef, 0x69, 0x32, 0x15, 0x6a, 0xa4, 0xdb, 0x6d, 0xa6, 0xbb,
0xbf, 0x79, 0x77, 0x3f, 0x22, 0xef, 0xee, 0x47, 0xe4, 0xc3, 0xfd, 0x88, 0xbc, 0xfe, 0x34, 0xfa,
0xee, 0xb2, 0x83, 0xbf, 0xe1, 0xdf, 0x3e, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa6, 0x62, 0xa8, 0x25,
0x96, 0x07, 0x00, 0x00,
}

7
internal/public.proto
View file

@ -8,6 +8,12 @@ message Row {
repeated Attr Attrs = 2;
}
message RowIdentifiers {
repeated uint64 Rows = 1;
repeated string Keys = 2;
//repeated Attr Attrs = 3;
}
message Pair {
uint64 ID = 1;
string Key = 3;
@ -78,6 +84,7 @@ message QueryResult {
ValCount ValCount = 5;
repeated uint64 RowIDs = 7;
repeated GroupCount GroupCounts = 8;
RowIdentifiers RowIdentifiers = 9;
}
message ImportRequest {