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

plug in in translation. adjust output format.

Browse source
This commit is contained in:
Travis Turner 2018-08-22 14:58:50 -05:00
parent de071d548a
commit 96b4086360
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
4 changed files with 120 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
encoding/proto/proto.go
View file

@ -1002,8 +1002,8 @@ func decodeGroupByCounts(a []*internal.GroupLine) pilosa.GroupByCounts {
other := make([]pilosa.GroupLine, len(a))
for i := range a {
other[i] = pilosa.GroupLine{
decodeFieldRows(a[i].Groups),
a[i].Total,
decodeFieldRows(a[i].Group),
a[i].Count,
}
}
return pilosa.GroupByCounts(other)
@ -1073,8 +1073,8 @@ func encodeGroupByCount(counts pilosa.GroupByCounts) []*internal.GroupLine {
result := make([]*internal.GroupLine, len(counts))
for i := range counts {
result[i] = &internal.GroupLine{
Groups: encodeFieldRows(counts[i].Groups),
Total: counts[i].Total,
Group: encodeFieldRows(counts[i].Group),
Count: counts[i].Count,
}
}
return result

58
executor.go
View file

@ -788,9 +788,9 @@ func (e *executor) executeGroupBy(ctx context.Context, index string, c *pql.Call
// FieldRow is used to distinguish rows in a group by result.
type FieldRow struct {
Field string
RowID uint64
RowKey string
Field string `json:"field"`
RowID uint64 `json:"rowID"`
RowKey string `json:"rowKey,omitempty"`
}
func (fr FieldRow) String() string {
@ -812,8 +812,8 @@ type gbi struct {
fieldRow FieldRow
}
type GroupLine struct {
Groups []FieldRow
Total uint64
Group []FieldRow `json:"group"`
Count uint64 `json:"count"`
}
// GroupByCounts is the return type for GroupBy queries.
@ -825,15 +825,15 @@ func (gbc GroupByCounts) Merge(other GroupByCounts) GroupByCounts {
total uint64
})
for i := range gbc {
m[uniqueGroupString(gbc[i].Groups)] = struct {
m[uniqueGroupString(gbc[i].Group)] = struct {
i int
total uint64
}{i, gbc[i].Total}
}
for i := range other {
o, found := m[uniqueGroupString(other[i].Groups)]
o, found := m[uniqueGroupString(other[i].Group)]
if found {
gbc[o.i].Total += other[i].Total
gbc[o.i].Count += other[i].Count
} else {
gbc = append(gbc, other[i])
}
@ -901,8 +901,8 @@ func (e *executor) executeGroupByShard(ctx context.Context, index string, c *pql
work = append(work, set)
}
for _, group := range product(work) {
group.gl.Total = group.row.Count()
if group.gl.Total > 0 {
group.gl.Count = group.row.Count()
if group.gl.Count > 0 {
results = append(results, group.gl)
}
}
@ -920,7 +920,7 @@ type ppi struct {
func product(input [][]gbi) []ppi {
if len(input) == 0 { // base return empty list
return []ppi{
{gl: GroupLine{Groups: make([]FieldRow, 0)}},
{gl: GroupLine{Group: make([]FieldRow, 0)}},
}
}
@ -929,9 +929,9 @@ func product(input [][]gbi) []ppi {
tail := product(input[1:]) // invoke product on remaining element
for h := range head { // for each head
for t := range tail { // iterate over the tail
s := ppi{gl: GroupLine{Groups: make([]FieldRow, 0)}}
s.gl.Groups = append([]FieldRow{head[h].fieldRow}, tail[t].gl.Groups...) // had to insert at the front to match input order
if tail[t].row != nil { // first time around nothing to intersect
s := ppi{gl: GroupLine{Group: make([]FieldRow, 0)}}
s.gl.Group = append([]FieldRow{head[h].fieldRow}, tail[t].gl.Group...) // had to insert at the front to match input order
if tail[t].row != nil { // first time around nothing to intersect
s.row = head[h].row.Intersect(tail[t].row)
} else {
s.row = head[h].row
@ -2091,7 +2091,37 @@ func (e *executor) translateResult(index string, idx *Index, call *pql.Call, res
return other, nil
}
}
case GroupByCounts:
other := make([]GroupLine, 0)
for _, gl := range result {
group := make([]FieldRow, len(gl.Group))
for i, g := range gl.Group {
group[i] = g
// TODO: It may be useful to cache this field lookup.
field := idx.Field(g.Field)
if field == nil {
return nil, ErrFieldNotFound
}
if field.keys() {
key, err := e.TranslateStore.TranslateRowToString(index, g.Field, g.RowID)
if err != nil {
return nil, err
}
group[i].RowKey = key
}
}
other = append(other, GroupLine{
Group: group,
Count: gl.Count,
})
}
return other, nil
}
return result, nil
}

140
internal/public.pb.go
View file

@ -133,8 +133,8 @@ func (m *FieldRow) GetRowID() uint64 {
}
type GroupLine struct {
Groups []*FieldRow `protobuf:"bytes,1,rep,name=Groups" json:"Groups,omitempty"`
Total uint64 `protobuf:"varint,2,opt,name=Total,proto3" json:"Total,omitempty"`
Group []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
Count uint64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
}
func (m *GroupLine) Reset() { *m = GroupLine{} }
@ -142,16 +142,16 @@ func (m *GroupLine) String() string { return proto.CompactTextString(
func (*GroupLine) ProtoMessage() {}
func (*GroupLine) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{3} }
func (m *GroupLine) GetGroups() []*FieldRow {
func (m *GroupLine) GetGroup() []*FieldRow {
if m != nil {
return m.Groups
return m.Group
}
return nil
}
func (m *GroupLine) GetTotal() uint64 {
func (m *GroupLine) GetCount() uint64 {
if m != nil {
return m.Total
return m.Count
}
return 0
}
@ -760,8 +760,8 @@ func (m *GroupLine) MarshalTo(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Groups) > 0 {
for _, msg := range m.Groups {
if len(m.Group) > 0 {
for _, msg := range m.Group {
dAtA[i] = 0xa
i++
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
@ -772,10 +772,10 @@ func (m *GroupLine) MarshalTo(dAtA []byte) (int, error) {
i += n
}
}
if m.Total != 0 {
if m.Count != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPublic(dAtA, i, uint64(m.Total))
i = encodeVarintPublic(dAtA, i, uint64(m.Count))
}
return i, nil
}
@ -1464,14 +1464,14 @@ func (m *FieldRow) Size() (n int) {
func (m *GroupLine) Size() (n int) {
var l int
_ = l
if len(m.Groups) > 0 {
for _, e := range m.Groups {
if len(m.Group) > 0 {
for _, e := range m.Group {
l = e.Size()
n += 1 + l + sovPublic(uint64(l))
}
}
if m.Total != 0 {
n += 1 + sovPublic(uint64(m.Total))
if m.Count != 0 {
n += 1 + sovPublic(uint64(m.Count))
}
return n
}
@ -2171,7 +2171,7 @@ func (m *GroupLine) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -2195,16 +2195,16 @@ func (m *GroupLine) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Groups = append(m.Groups, &FieldRow{})
if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
m.Group = append(m.Group, &FieldRow{})
if err := m.Group[len(m.Group)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
}
m.Total = 0
m.Count = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
@ -2214,7 +2214,7 @@ func (m *GroupLine) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Total |= (uint64(b) & 0x7F) << shift
m.Count |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
@ -4241,54 +4241,54 @@ var (
func init() { proto.RegisterFile("public.proto", fileDescriptorPublic) }
var fileDescriptorPublic = []byte{
// 783 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x6a, 0xdb, 0x48,
0x14, 0xde, 0xb1, 0x64, 0x5b, 0x3e, 0x8e, 0xbd, 0x61, 0x36, 0x9b, 0x15, 0x4b, 0xf0, 0x0a, 0xb1,
0x2c, 0x62, 0x2f, 0x1c, 0xf0, 0xc2, 0x42, 0x6f, 0x5a, 0xea, 0xfc, 0x14, 0x93, 0x26, 0xb4, 0x93,
0x34, 0xa5, 0x97, 0x4a, 0x3c, 0x24, 0x02, 0x59, 0xa3, 0x4a, 0x23, 0x1c, 0x3f, 0x47, 0x6e, 0xfa,
0x08, 0xbd, 0xe8, 0x83, 0xe4, 0xb2, 0x8f, 0xd0, 0xa6, 0x2f, 0x52, 0xe6, 0x8c, 0xc6, 0x92, 0x1d,
0x08, 0xbd, 0xe8, 0xdd, 0x7c, 0xe7, 0xcc, 0x1c, 0x7d, 0xdf, 0xf9, 0x13, 0x6c, 0xa4, 0xc5, 0x45,
0x1c, 0x5d, 0x0e, 0xd3, 0x4c, 0x48, 0x41, 0x9d, 0x28, 0x91, 0x3c, 0x4b, 0xc2, 0xd8, 0x7f, 0x07,
0x16, 0x13, 0x73, 0xea, 0x42, 0x7b, 0x4f, 0xc4, 0xc5, 0x2c, 0xc9, 0x5d, 0xe2, 0x59, 0x81, 0xcd,
0x0c, 0xa4, 0x7f, 0x43, 0xf3, 0xb9, 0x94, 0x59, 0xee, 0x36, 0x3c, 0x2b, 0xe8, 0x8e, 0xfa, 0x43,
0xf3, 0x74, 0xa8, 0xcc, 0x4c, 0x3b, 0x29, 0x05, 0xfb, 0x88, 0x2f, 0x72, 0xd7, 0xf2, 0xac, 0xa0,
0xc3, 0xf0, 0xec, 0x3f, 0x05, 0xfb, 0x55, 0x18, 0x65, 0xb4, 0x0f, 0x8d, 0xc9, 0xbe, 0x4b, 0x3c,
0x12, 0xd8, 0xac, 0x31, 0xd9, 0xa7, 0x5b, 0xd0, 0xdc, 0x13, 0x45, 0x22, 0xdd, 0x06, 0x9a, 0x34,
0xa0, 0x9b, 0x60, 0x1d, 0xf1, 0x85, 0x6b, 0x79, 0x24, 0xe8, 0x30, 0x75, 0xf4, 0xff, 0x07, 0xe7,
0x30, 0xe2, 0xf1, 0x54, 0xf1, 0xdb, 0x82, 0x26, 0x9e, 0x31, 0x4c, 0x87, 0x69, 0xa0, 0xac, 0x4c,
0xcc, 0x27, 0xfb, 0x26, 0x12, 0x02, 0xff, 0x18, 0x3a, 0x2f, 0x32, 0x51, 0xa4, 0x2f, 0xa3, 0x84,
0xd3, 0x7f, 0xa1, 0x85, 0x40, 0xeb, 0xea, 0x8e, 0x68, 0xc5, 0xdf, 0x04, 0x67, 0xe5, 0x0d, 0x15,
0xee, 0x4c, 0xc8, 0x30, 0x36, 0xe1, 0x10, 0xf8, 0x23, 0x70, 0xce, 0xc3, 0x78, 0x49, 0xf2, 0x3c,
0x8c, 0x91, 0x84, 0xc5, 0xd4, 0x71, 0x55, 0x8c, 0x55, 0x8a, 0xf1, 0xdf, 0x80, 0x35, 0x8e, 0x64,
0xc5, 0x8f, 0xd4, 0xf8, 0xd1, 0x3f, 0xc1, 0xd1, 0xc9, 0x5d, 0x12, 0x5f, 0x62, 0xba, 0x03, 0x9d,
0xb3, 0x68, 0xc6, 0x73, 0x19, 0xce, 0x52, 0xcc, 0x85, 0xc5, 0x2a, 0x83, 0xff, 0x16, 0x7a, 0xfa,
0xa6, 0x4a, 0xfa, 0x29, 0x97, 0x0f, 0x52, 0xfb, 0x63, 0xc5, 0x7a, 0x98, 0xea, 0x8f, 0x04, 0x6c,
0xe5, 0x33, 0x2e, 0xb2, 0x74, 0xa9, 0xca, 0x9e, 0x2d, 0x52, 0x5e, 0x32, 0xc5, 0x33, 0xf5, 0xa0,
0x7b, 0x2a, 0xb3, 0x28, 0xb9, 0x3a, 0x0f, 0xe3, 0x82, 0x97, 0x81, 0xea, 0x26, 0xa5, 0x71, 0x92,
0x48, 0xed, 0xb6, 0x51, 0xc6, 0x12, 0x2b, 0x8d, 0x63, 0x21, 0x62, 0xed, 0x6c, 0x7a, 0x24, 0x70,
0x58, 0x65, 0xa0, 0x03, 0x80, 0xc3, 0x58, 0x84, 0xe5, 0xdb, 0x96, 0x47, 0x02, 0xc2, 0x6a, 0x16,
0x7f, 0x17, 0xda, 0x8a, 0xe9, 0x71, 0x98, 0x56, 0x6a, 0xc9, 0x23, 0x6a, 0xfd, 0x3b, 0x02, 0x1b,
0xaf, 0x0b, 0x9e, 0x2d, 0x18, 0x7f, 0x5f, 0xf0, 0x1c, 0xab, 0x82, 0xd8, 0xf4, 0x12, 0x02, 0xba,
0x0d, 0xad, 0xd3, 0xeb, 0x30, 0x9b, 0xea, 0xdc, 0xd9, 0xac, 0x44, 0x4a, 0x6b, 0x95, 0xf3, 0x1c,
0xb5, 0x3a, 0xac, 0x6e, 0x52, 0x2f, 0x19, 0x9f, 0x09, 0x69, 0xc4, 0x94, 0x88, 0x06, 0xf0, 0xeb,
0xc1, 0xcd, 0x65, 0x5c, 0x4c, 0x39, 0x13, 0x73, 0xfd, 0xba, 0x85, 0x17, 0xd6, 0xcd, 0xf4, 0x1f,
0xe8, 0x97, 0x26, 0x33, 0x84, 0x6d, 0xbc, 0xb8, 0x66, 0xf5, 0x6f, 0x09, 0xf4, 0x4a, 0x29, 0x79,
0x2a, 0x92, 0x9c, 0xab, 0x7a, 0x1d, 0x64, 0x99, 0xa9, 0xd7, 0x41, 0x96, 0xd1, 0x5d, 0x68, 0x33,
0x9e, 0x17, 0xb1, 0x34, 0x4d, 0xf0, 0x7b, 0x95, 0x16, 0xf3, 0xb6, 0x88, 0x25, 0x33, 0xb7, 0xe8,
0x33, 0xe8, 0xaf, 0x34, 0x95, 0x1e, 0xe2, 0xee, 0xe8, 0x8f, 0xea, 0xdd, 0x8a, 0x9f, 0xad, 0x5d,
0xf7, 0x6f, 0x1b, 0xd0, 0xad, 0x45, 0xa6, 0x7f, 0xe1, 0x4a, 0x41, 0x4e, 0xdd, 0x51, 0xaf, 0x8a,
0xa2, 0x46, 0x0d, 0x97, 0xcd, 0x06, 0x90, 0x93, 0xb2, 0x9f, 0xc8, 0x89, 0xaa, 0xa2, 0x5a, 0x13,
0xe6, 0xb3, 0xb5, 0x2a, 0x2a, 0x33, 0xd3, 0x4e, 0x5c, 0x50, 0xd7, 0x61, 0x72, 0xc5, 0xa7, 0xd8,
0x4f, 0x0e, 0x33, 0x90, 0x0e, 0xab, 0xf9, 0xc4, 0x02, 0xac, 0xcc, 0xb8, 0xf1, 0xb0, 0x6a, 0x86,
0x4d, 0x43, 0xab, 0x5a, 0xf4, 0xca, 0x86, 0x56, 0x25, 0x54, 0xb3, 0xa9, 0x12, 0x8f, 0xc5, 0xd7,
0x88, 0x3e, 0x81, 0x1e, 0xee, 0x86, 0xf1, 0x02, 0xdf, 0xe6, 0xae, 0x83, 0x1c, 0x7f, 0xab, 0x3e,
0xb0, 0xdc, 0x34, 0x6c, 0xf5, 0xa6, 0xff, 0x95, 0x40, 0x6f, 0x32, 0x4b, 0x45, 0x26, 0x6b, 0x7d,
0x37, 0x49, 0xa6, 0xfc, 0xc6, 0xf4, 0x1d, 0x82, 0x6a, 0xb3, 0x35, 0xd6, 0x36, 0x1b, 0xf6, 0x1f,
0xf6, 0x9b, 0xcd, 0x34, 0xa8, 0xd1, 0xb4, 0x57, 0x68, 0xee, 0x40, 0xc7, 0x6c, 0x90, 0xdc, 0x6d,
0xa2, 0xab, 0x32, 0xa8, 0x89, 0x5a, 0xae, 0x10, 0xd5, 0x82, 0x56, 0x60, 0xb1, 0x9a, 0x45, 0xa5,
0x96, 0x89, 0x39, 0xae, 0xef, 0x36, 0xae, 0x6f, 0x03, 0xd5, 0x4b, 0x1d, 0x06, 0x9d, 0x0e, 0x3a,
0x6b, 0x16, 0xff, 0x13, 0x01, 0xaa, 0x35, 0xe2, 0x6c, 0xfe, 0x3c, 0xa1, 0x8f, 0x0b, 0xda, 0x86,
0x16, 0x7e, 0xcf, 0x88, 0x29, 0xd1, 0x1a, 0xdd, 0xf6, 0x3a, 0xdd, 0xf1, 0xe6, 0xdd, 0xfd, 0x80,
0x7c, 0xbe, 0x1f, 0x90, 0x2f, 0xf7, 0x03, 0xf2, 0xe1, 0xdb, 0xe0, 0x97, 0x8b, 0x16, 0xfe, 0x0e,
0xff, 0xfb, 0x1e, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xa1, 0x99, 0xa7, 0x1e, 0x07, 0x00, 0x00,
// 771 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x6e, 0xd3, 0x4c,
0x14, 0xfe, 0x27, 0x76, 0x12, 0xe7, 0xa4, 0xc9, 0x5f, 0x0d, 0xa5, 0x58, 0xa8, 0x0a, 0x96, 0x85,
0x90, 0x57, 0xa9, 0x14, 0x24, 0x24, 0x36, 0x20, 0xd2, 0x0b, 0x8a, 0x0a, 0x15, 0x4c, 0x4b, 0x11,
0x4b, 0xb7, 0x19, 0xb5, 0x96, 0x1c, 0x8f, 0xf1, 0x45, 0x69, 0x9e, 0xa3, 0x1b, 0x1e, 0x81, 0x05,
0x0f, 0xd2, 0x25, 0x8f, 0x00, 0xe5, 0x45, 0xd0, 0x9c, 0xf1, 0xd8, 0x4e, 0x8a, 0x2a, 0x16, 0xec,
0xe6, 0xfb, 0xce, 0x9c, 0xf1, 0x77, 0xae, 0x86, 0xb5, 0x38, 0x3f, 0x0d, 0x83, 0xb3, 0x61, 0x9c,
0x88, 0x4c, 0x50, 0x2b, 0x88, 0x32, 0x9e, 0x44, 0x7e, 0xe8, 0x7e, 0x02, 0x83, 0x89, 0x39, 0xb5,
0xa1, 0xbd, 0x23, 0xc2, 0x7c, 0x16, 0xa5, 0x36, 0x71, 0x0c, 0xcf, 0x64, 0x1a, 0xd2, 0xc7, 0xd0,
0x7c, 0x95, 0x65, 0x49, 0x6a, 0x37, 0x1c, 0xc3, 0xeb, 0x8e, 0xfa, 0x43, 0xed, 0x3a, 0x94, 0x34,
0x53, 0x46, 0x4a, 0xc1, 0x3c, 0xe0, 0x8b, 0xd4, 0x36, 0x1c, 0xc3, 0xeb, 0x30, 0x3c, 0xbb, 0x2f,
0xc0, 0x7c, 0xe7, 0x07, 0x09, 0xed, 0x43, 0x63, 0xb2, 0x6b, 0x13, 0x87, 0x78, 0x26, 0x6b, 0x4c,
0x76, 0xe9, 0x06, 0x34, 0x77, 0x44, 0x1e, 0x65, 0x76, 0x03, 0x29, 0x05, 0xe8, 0x3a, 0x18, 0x07,
0x7c, 0x61, 0x1b, 0x0e, 0xf1, 0x3a, 0x4c, 0x1e, 0xdd, 0x67, 0x60, 0xed, 0x07, 0x3c, 0x9c, 0x4a,
0x7d, 0x1b, 0xd0, 0xc4, 0x33, 0x3e, 0xd3, 0x61, 0x0a, 0x48, 0x96, 0x89, 0xf9, 0x64, 0x57, 0xbf,
0x84, 0xc0, 0x3d, 0x80, 0xce, 0xeb, 0x44, 0xe4, 0xf1, 0x9b, 0x20, 0xe2, 0xd4, 0x83, 0x26, 0x02,
0x0c, 0xab, 0x3b, 0xa2, 0x95, 0x7c, 0xfd, 0x36, 0x53, 0x17, 0xfe, 0x2c, 0xcb, 0x1d, 0x81, 0x75,
0xe2, 0x87, 0xa5, 0xc4, 0x13, 0x3f, 0x44, 0x09, 0x06, 0x93, 0xc7, 0x65, 0x1f, 0x43, 0xfb, 0x7c,
0x00, 0x63, 0x1c, 0x64, 0x95, 0x3a, 0x52, 0x53, 0x47, 0x1f, 0x82, 0xa5, 0x52, 0x5b, 0xca, 0x2e,
0x31, 0xdd, 0x82, 0xce, 0x71, 0x30, 0xe3, 0x69, 0xe6, 0xcf, 0x62, 0xcc, 0x84, 0xc1, 0x2a, 0xc2,
0xfd, 0x08, 0x3d, 0x75, 0x53, 0xa6, 0xfc, 0x88, 0x67, 0xb7, 0x12, 0xfb, 0x77, 0xa5, 0xba, 0x9d,
0xe8, 0xaf, 0x04, 0x4c, 0x69, 0xd3, 0x26, 0x52, 0x9a, 0x64, 0x5d, 0x8f, 0x17, 0x31, 0x2f, 0x94,
0xe2, 0x99, 0x3a, 0xd0, 0x3d, 0xca, 0x92, 0x20, 0x3a, 0x3f, 0xf1, 0xc3, 0x9c, 0x17, 0x0f, 0xd5,
0x29, 0x19, 0xe3, 0x24, 0xca, 0x94, 0xd9, 0xc4, 0x30, 0x4a, 0x2c, 0x63, 0x1c, 0x0b, 0x11, 0x2a,
0x63, 0xd3, 0x21, 0x9e, 0xc5, 0x2a, 0x82, 0x0e, 0x00, 0xf6, 0x43, 0xe1, 0x17, 0xbe, 0x2d, 0x87,
0x78, 0x84, 0xd5, 0x18, 0x77, 0x1b, 0xda, 0x52, 0xe9, 0x5b, 0x3f, 0xae, 0xa2, 0x25, 0x77, 0x44,
0xeb, 0x5e, 0x13, 0x58, 0x7b, 0x9f, 0xf3, 0x64, 0xc1, 0xf8, 0xe7, 0x9c, 0xa7, 0x58, 0x15, 0xc4,
0xba, 0x93, 0x10, 0xd0, 0x4d, 0x68, 0x1d, 0x5d, 0xf8, 0xc9, 0x54, 0xe5, 0xce, 0x64, 0x05, 0x92,
0xb1, 0x56, 0x39, 0x4f, 0x31, 0x56, 0x8b, 0xd5, 0x29, 0xe9, 0xc9, 0xf8, 0x4c, 0x64, 0x3a, 0x98,
0x02, 0x51, 0x0f, 0xfe, 0xdf, 0xbb, 0x3c, 0x0b, 0xf3, 0x29, 0x67, 0x62, 0xae, 0xbc, 0x5b, 0x78,
0x61, 0x95, 0xa6, 0x4f, 0xa0, 0x5f, 0x50, 0x7a, 0x04, 0xdb, 0x78, 0x71, 0x85, 0x75, 0xaf, 0x08,
0xf4, 0x8a, 0x50, 0xd2, 0x58, 0x44, 0x29, 0x97, 0xf5, 0xda, 0x4b, 0x12, 0x5d, 0xaf, 0xbd, 0x24,
0xa1, 0xdb, 0xd0, 0x66, 0x3c, 0xcd, 0xc3, 0x4c, 0x37, 0xc1, 0xfd, 0x2a, 0x2d, 0xda, 0x37, 0x0f,
0x33, 0xa6, 0x6f, 0xd1, 0x97, 0xd0, 0x5f, 0x6a, 0x2a, 0x35, 0xc2, 0xdd, 0xd1, 0x83, 0xca, 0x6f,
0xc9, 0xce, 0x56, 0xae, 0xbb, 0x57, 0x0d, 0xe8, 0xd6, 0x5e, 0xa6, 0x8f, 0x70, 0xa1, 0xa0, 0xa6,
0xee, 0xa8, 0x57, 0xbd, 0x22, 0x27, 0x0d, 0x57, 0xcd, 0x1a, 0x90, 0xc3, 0xa2, 0x9f, 0xc8, 0xa1,
0xac, 0xa2, 0x5c, 0x12, 0xfa, 0xb3, 0xb5, 0x2a, 0x4a, 0x9a, 0x29, 0x23, 0xae, 0xa7, 0x0b, 0x3f,
0x3a, 0xe7, 0x53, 0xec, 0x27, 0x8b, 0x69, 0x48, 0x87, 0xd5, 0x7c, 0x62, 0x01, 0x96, 0x46, 0x5c,
0x5b, 0x58, 0x35, 0xc3, 0xba, 0xa1, 0x65, 0x2d, 0x7a, 0x45, 0x43, 0xcb, 0x12, 0xca, 0xd9, 0x94,
0x89, 0xc7, 0xe2, 0x2b, 0x44, 0x9f, 0x43, 0x0f, 0x57, 0xc3, 0x78, 0x81, 0xbe, 0xa9, 0x6d, 0xa1,
0xc6, 0x7b, 0xd5, 0x07, 0xca, 0x3d, 0xc3, 0x96, 0x6f, 0xba, 0x3f, 0x09, 0xf4, 0x26, 0xb3, 0x58,
0x24, 0x59, 0xad, 0xef, 0x26, 0xd1, 0x94, 0x5f, 0xea, 0xbe, 0x43, 0x50, 0xed, 0xb5, 0xc6, 0xca,
0x5e, 0xc3, 0xfe, 0xc3, 0x7e, 0x33, 0x99, 0x02, 0x35, 0x99, 0xe6, 0x92, 0xcc, 0x2d, 0xe8, 0xe8,
0x0d, 0x92, 0xda, 0x4d, 0x34, 0x55, 0x84, 0x9c, 0xa8, 0x72, 0x85, 0xc8, 0x16, 0x34, 0x3c, 0x83,
0xd5, 0x18, 0x99, 0x5a, 0x26, 0xe6, 0xb8, 0xbc, 0xdb, 0xb8, 0xbc, 0x35, 0x94, 0x9e, 0xea, 0x19,
0x34, 0x5a, 0x68, 0xac, 0x31, 0xee, 0x37, 0x02, 0x54, 0xc5, 0x88, 0xb3, 0xf9, 0xef, 0x02, 0xbd,
0x3b, 0xa0, 0x4d, 0x68, 0xe1, 0xf7, 0x74, 0x30, 0x05, 0x5a, 0x91, 0xdb, 0x5e, 0x95, 0x3b, 0x5e,
0xbf, 0xbe, 0x19, 0x90, 0xef, 0x37, 0x03, 0xf2, 0xe3, 0x66, 0x40, 0xbe, 0xfc, 0x1a, 0xfc, 0x77,
0xda, 0xc2, 0x9f, 0xe1, 0xd3, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x21, 0xc1, 0x72, 0xc6, 0x1c,
0x07, 0x00, 0x00,
}

4
internal/public.proto
View file

@ -20,8 +20,8 @@ message FieldRow{
}
message GroupLine{
repeated FieldRow Groups = 1;
uint64 Total = 2;
repeated FieldRow Group = 1;
uint64 Count = 2;
}
message ValCount {