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

Merge pull request #1799 from molecula/distinct-timestamp-count

Browse source 
[FB-1081] fix count on distinctTimestamp
This commit is contained in:
reese 2021-12-06 16:28:38 -06:00 • committed by GitHub
commit 8cd9dcd70d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 581 additions and 190 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
encoding/proto/proto.go
View file

@ -560,6 +560,9 @@ func (s Serializer) encodeQueryResponse(m *pilosa.QueryResponse) *pb.QueryRespon
case []*pilosa.Row:
resp.Results[i].Type = queryResultTypeRowMatrix
resp.Results[i].RowMatrix = s.encodeRowMatrix(result)
case pilosa.DistinctTimestamp:
resp.Results[i].Type = queryResultTypeDistinctTimestamp
resp.Results[i].DistinctTimestamp = s.encodeDistinctTimestamp(result)
case nil:
resp.Results[i].Type = queryResultTypeNil
default:
@ -1380,6 +1383,13 @@ func (s Serializer) decodeRowMatrix(pb *pb.RowMatrix) []*pilosa.Row {
return rows
}
func (s Serializer) decodeDistinctTimestamp(pb *pb.DistinctTimestamp) pilosa.DistinctTimestamp {
return pilosa.DistinctTimestamp{
Values: pb.Values,
Name: pb.Name,
}
}
func decodeTransaction(pb *pb.Transaction, trns *pilosa.Transaction) {
trns.ID = pb.ID
trns.Active = pb.Active
@ -1407,6 +1417,7 @@ const (
queryResultTypeSignedRow
queryResultTypeExtractedIDMatrix
queryResultTypeExtractedTable
queryResultTypeDistinctTimestamp
)
func (s Serializer) decodeQueryResult(pb *pb.QueryResult) interface{} {
@ -1443,6 +1454,8 @@ func (s Serializer) decodeQueryResult(pb *pb.QueryResult) interface{} {
return s.decodeExtractedTable(pb.ExtractedTable)
case queryResultTypeRowMatrix:
return s.decodeRowMatrix(pb.RowMatrix)
case queryResultTypeDistinctTimestamp:
return s.decodeDistinctTimestamp(pb.DistinctTimestamp)
}
panic(fmt.Sprintf("unknown type: %d", pb.Type))
}
@ -1694,6 +1707,13 @@ func (s Serializer) encodeRowIdentifiers(r pilosa.RowIdentifiers) *pb.RowIdentif
}
}
func (s Serializer) encodeDistinctTimestamp(d pilosa.DistinctTimestamp) *pb.DistinctTimestamp {
return &pb.DistinctTimestamp{
Values: d.Values,
Name: d.Name,
}
}
func (s Serializer) encodeGroupCounts(counts *pilosa.GroupCounts) *pb.GroupCounts {
groups := counts.Groups()
result := &pb.GroupCounts{

42
encoding/proto/proto_test.go
View file

@ -19,8 +19,9 @@ import (
"reflect"
"testing"
"github.com/molecula/featurebase/v2"
pilosa "github.com/molecula/featurebase/v2"
"github.com/molecula/featurebase/v2/ingest"
"github.com/molecula/featurebase/v2/pb"
)
func testOneRoundTrip(t *testing.T, s pilosa.Serializer, obj pilosa.Message, expectedMarshalErr error, expectedUnmarshalErr error, expectedMismatchErr error) {
@ -147,3 +148,42 @@ func TestIngestRoundTrip(t *testing.T) {
testOneRoundTrip(t, DefaultSerializer, tc.req, nil, nil, tc.err)
}
}
func TestEncodeDecodeDistinctTimestamp(t *testing.T) {
s := Serializer{}
pbTime := pb.DistinctTimestamp{
Values: []string{"this", "is", "fake", "timestamp", "values"},
Name: "pbtime",
}
piloTime := pilosa.DistinctTimestamp{
Values: []string{"this", "is", "fake", "timestamp", "values"},
Name: "pbtime",
}
decoded := s.decodeDistinctTimestamp(&pbTime)
if !reflect.DeepEqual(decoded, piloTime) {
t.Errorf("failed to decode DistinctTimestamp. expected %v got %v", piloTime, decoded)
}
encoded := s.encodeDistinctTimestamp(piloTime)
if !reflect.DeepEqual(encoded, &pbTime) {
t.Errorf("failed to encode DistinctTimestamp. expected %v got %v", &pbTime, encoded)
}
}
func TestDecodeQueryResult(t *testing.T) {
t.Run("DistinctTimestamp", func(t *testing.T) {
pbTime := pb.DistinctTimestamp{
Values: []string{"this", "is", "fake", "timestamp", "values"},
Name: "pbtime",
}
piloTime := pilosa.DistinctTimestamp{
Values: []string{"this", "is", "fake", "timestamp", "values"},
Name: "pbtime",
}
q := &pb.QueryResult{Type: queryResultTypeDistinctTimestamp, DistinctTimestamp: &pbTime}
s := Serializer{}
decoded := s.decodeQueryResult(q)
if !reflect.DeepEqual(decoded, piloTime) {
t.Errorf("failed to decode DistinctTimestamp. expected %v got %v", piloTime, decoded)
}
})
}

2
executor.go
View file

@ -5027,6 +5027,8 @@ func (e *executor) executeCount(ctx context.Context, qcx *Qcx, index string, c *
return row.Count(), nil
case SignedRow:
return row.Pos.Count() + row.Neg.Count(), nil
case DistinctTimestamp:
return uint64(len(row.Values)), nil
default:
return 0, errors.Errorf("cannot count result of type %T from call %q", row, child.String())
}

23
executor_test.go
View file

@ -6756,6 +6756,27 @@ func TestExecutor_Execute_CountDistinct(t *testing.T) {
})
}
func variousQueriesCountDistinctTimestamp(t *testing.T, c *test.Cluster) {
index := "test_index"
field := "ts"
// create an index and timestamp field
c.CreateField(t, index, pilosa.IndexOptions{}, field, pilosa.OptFieldTypeTimestamp(time.Unix(0, 0), "s"))
// add some data
data := []string{"2010-01-02T12:32:00Z", "2010-04-20T12:32:00Z", "2011-04-20T12:32:00Z"}
for i, datum := range data {
c.Query(t, index, fmt.Sprintf("Set(%d, ts=\"%s\")", i+10, datum))
}
// query the Count of Distinct vals in field ts
count := c.Query(t, index, "Count(Distinct(field=ts))").Results[0]
if count != uint64(len(data)) {
t.Fatalf("expected %v got %v", len(data), count)
}
}
// Ensure that a top-level, bare distinct on multiple nodes
// is handled correctly.
func TestExecutor_BareDistinct(t *testing.T) {
@ -7012,10 +7033,10 @@ func TestVariousQueries(t *testing.T) {
t.Run(fmt.Sprintf("%d-node", clusterSize), func(t *testing.T) {
c := test.MustRunCluster(t, clusterSize)
defer c.Close()
variousQueries(t, c)
variousQueriesOnTimeFields(t, c)
variousQueriesOnPercentiles(t, c)
variousQueriesCountDistinctTimestamp(t, c)
})
}
}

677
pb/public.pb.go
View file

@ -1297,6 +1297,61 @@ func (m *Decimal) GetScale() int64 {
return 0
}
type DistinctTimestamp struct {
Values []string `protobuf:"bytes,1,rep,name=Values,proto3" json:"Values,omitempty"`
Name string `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DistinctTimestamp) Reset() { *m = DistinctTimestamp{} }
func (m *DistinctTimestamp) String() string { return proto.CompactTextString(m) }
func (*DistinctTimestamp) ProtoMessage() {}
func (*DistinctTimestamp) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{20}
}
func (m *DistinctTimestamp) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *DistinctTimestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_DistinctTimestamp.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 *DistinctTimestamp) XXX_Merge(src proto.Message) {
xxx_messageInfo_DistinctTimestamp.Merge(m, src)
}
func (m *DistinctTimestamp) XXX_Size() int {
return m.Size()
}
func (m *DistinctTimestamp) XXX_DiscardUnknown() {
xxx_messageInfo_DistinctTimestamp.DiscardUnknown(m)
}
var xxx_messageInfo_DistinctTimestamp proto.InternalMessageInfo
func (m *DistinctTimestamp) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
func (m *DistinctTimestamp) GetName() string {
if m != nil {
return m.Name
}
return ""
}
type QueryRequest struct {
Query string `protobuf:"bytes,1,opt,name=Query,proto3" json:"Query,omitempty"`
Shards []uint64 `protobuf:"varint,2,rep,packed,name=Shards,proto3" json:"Shards,omitempty"`
@ -1313,7 +1368,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{20}
return fileDescriptor_413a91106d7bcce8, []int{21}
}
func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1396,7 +1451,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{21}
return fileDescriptor_413a91106d7bcce8, []int{22}
}
func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1462,6 +1517,7 @@ type QueryResult struct {
ExtractedTable *ExtractedTable `protobuf:"bytes,14,opt,name=ExtractedTable,proto3" json:"ExtractedTable,omitempty"`
RowMatrix *RowMatrix `protobuf:"bytes,15,opt,name=RowMatrix,proto3" json:"RowMatrix,omitempty"`
GroupCounts *GroupCounts `protobuf:"bytes,16,opt,name=GroupCounts,proto3" json:"GroupCounts,omitempty"`
DistinctTimestamp *DistinctTimestamp `protobuf:"bytes,17,opt,name=DistinctTimestamp,proto3" json:"DistinctTimestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1471,7 +1527,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{22}
return fileDescriptor_413a91106d7bcce8, []int{23}
}
func (m *QueryResult) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1612,6 +1668,13 @@ func (m *QueryResult) GetGroupCounts() *GroupCounts {
return nil
}
func (m *QueryResult) GetDistinctTimestamp() *DistinctTimestamp {
if m != nil {
return m.DistinctTimestamp
}
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"`
@ -1633,7 +1696,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{23}
return fileDescriptor_413a91106d7bcce8, []int{24}
}
func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1760,7 +1823,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{24}
return fileDescriptor_413a91106d7bcce8, []int{25}
}
func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1880,7 +1943,7 @@ func (m *AtomicRecord) Reset() { *m = AtomicRecord{} }
func (m *AtomicRecord) String() string { return proto.CompactTextString(m) }
func (*AtomicRecord) ProtoMessage() {}
func (*AtomicRecord) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{25}
return fileDescriptor_413a91106d7bcce8, []int{26}
}
func (m *AtomicRecord) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1948,7 +2011,7 @@ func (m *AtomicImportResponse) Reset() { *m = AtomicImportResponse{} }
func (m *AtomicImportResponse) String() string { return proto.CompactTextString(m) }
func (*AtomicImportResponse) ProtoMessage() {}
func (*AtomicImportResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{26}
return fileDescriptor_413a91106d7bcce8, []int{27}
}
func (m *AtomicImportResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1998,7 +2061,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{27}
return fileDescriptor_413a91106d7bcce8, []int{28}
}
func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2066,7 +2129,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{28}
return fileDescriptor_413a91106d7bcce8, []int{29}
}
func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2115,7 +2178,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{29}
return fileDescriptor_413a91106d7bcce8, []int{30}
}
func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2176,7 +2239,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{30}
return fileDescriptor_413a91106d7bcce8, []int{31}
}
func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2224,7 +2287,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{31}
return fileDescriptor_413a91106d7bcce8, []int{32}
}
func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2284,7 +2347,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{32}
return fileDescriptor_413a91106d7bcce8, []int{33}
}
func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2374,7 +2437,7 @@ func (m *GroupCounts) Reset() { *m = GroupCounts{} }
func (m *GroupCounts) String() string { return proto.CompactTextString(m) }
func (*GroupCounts) ProtoMessage() {}
func (*GroupCounts) Descriptor() ([]byte, []int) {
return fileDescriptor_413a91106d7bcce8, []int{33}
return fileDescriptor_413a91106d7bcce8, []int{34}
}
func (m *GroupCounts) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2438,6 +2501,7 @@ func init() {
proto.RegisterType((*GroupCount)(nil), "pb.GroupCount")
proto.RegisterType((*ValCount)(nil), "pb.ValCount")
proto.RegisterType((*Decimal)(nil), "pb.Decimal")
proto.RegisterType((*DistinctTimestamp)(nil), "pb.DistinctTimestamp")
proto.RegisterType((*QueryRequest)(nil), "pb.QueryRequest")
proto.RegisterType((*QueryResponse)(nil), "pb.QueryResponse")
proto.RegisterType((*QueryResult)(nil), "pb.QueryResult")
@ -2457,106 +2521,109 @@ func init() {
func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) }
var fileDescriptor_413a91106d7bcce8 = []byte{
// 1582 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5f, 0x6f, 0x1b, 0xd5,
0x12, 0xcf, 0xfe, 0xf1, 0xbf, 0xb1, 0xe3, 0xa4, 0xa7, 0x69, 0xef, 0xde, 0xde, 0xd4, 0xd7, 0x5d,
0x5d, 0x55, 0xee, 0x0d, 0x4a, 0x85, 0x81, 0x0a, 0x55, 0x02, 0x14, 0xc7, 0x29, 0x59, 0xb5, 0x49,
0xcb, 0x49, 0x08, 0x3c, 0xf0, 0xb2, 0xb1, 0x0f, 0xee, 0x8a, 0xb5, 0xd7, 0xac, 0xd7, 0x75, 0xfc,
0x09, 0xe0, 0x23, 0xf0, 0xc6, 0x13, 0x1f, 0x05, 0xc1, 0x1b, 0x3c, 0xf2, 0x88, 0xca, 0x17, 0x41,
0x33, 0xe7, 0xec, 0x5f, 0xbb, 0x55, 0x55, 0xf1, 0xb6, 0xf3, 0xe7, 0xcc, 0x99, 0xf9, 0xcd, 0x9c,
0x99, 0xb1, 0xa1, 0x31, 0x9d, 0x5f, 0xfa, 0xde, 0x60, 0x7f, 0x1a, 0x06, 0x51, 0xc0, 0xf4, 0xe9,
0xa5, 0xbd, 0x04, 0x83, 0x07, 0x0b, 0x66, 0x41, 0xe5, 0x30, 0xf0, 0xe7, 0xe3, 0xc9, 0xcc, 0xd2,
0xda, 0x46, 0xc7, 0xe4, 0x31, 0xc9, 0x18, 0x98, 0x8f, 0xc5, 0x72, 0x66, 0x19, 0x6d, 0xa3, 0x53,
0xe3, 0xf4, 0x8d, 0xda, 0x3c, 0x70, 0x43, 0x6f, 0x32, 0xb2, 0xcc, 0xb6, 0xd6, 0x69, 0xf0, 0x98,
0x64, 0x3b, 0x50, 0x72, 0x26, 0x43, 0x71, 0x65, 0x95, 0xda, 0x5a, 0xa7, 0xc6, 0x25, 0x81, 0xdc,
0x47, 0x9e, 0xf0, 0x87, 0x56, 0x59, 0x72, 0x89, 0xb0, 0x3b, 0x50, 0xe3, 0xc1, 0xe2, 0xc4, 0x8d,
0x42, 0xef, 0x8a, 0xfd, 0x07, 0x4c, 0x1e, 0x2c, 0xe4, 0xed, 0xf5, 0x6e, 0x65, 0x7f, 0x7a, 0xb9,
0xcf, 0x83, 0x05, 0x27, 0xa6, 0x7d, 0x00, 0xb5, 0x33, 0x6f, 0x34, 0x11, 0x43, 0x74, 0xf5, 0xdf,
0x60, 0x3c, 0x0b, 0x50, 0x51, 0xcb, 0x2a, 0x22, 0x0f, 0x45, 0xa7, 0x62, 0x64, 0xe9, 0x05, 0xd1,
0xa9, 0x18, 0xd9, 0x1f, 0x42, 0x93, 0x07, 0x0b, 0x67, 0x28, 0x26, 0x91, 0xf7, 0xb5, 0x27, 0x42,
0x0a, 0x2c, 0xb9, 0xd1, 0x94, 0x17, 0x25, 0xc1, 0xea, 0x69, 0xb0, 0xf6, 0x2d, 0x28, 0x3b, 0xfd,
0x27, 0xde, 0x2c, 0x62, 0xdb, 0x60, 0x38, 0xfd, 0xf8, 0x00, 0x7e, 0xda, 0x87, 0x70, 0xed, 0xe8,
0x2a, 0x0a, 0xdd, 0x41, 0x24, 0x86, 0x4e, 0x5f, 0x42, 0xc6, 0x9a, 0xa0, 0x3b, 0x7d, 0xf2, 0xcf,
0xe4, 0xba, 0xd3, 0x67, 0x2d, 0x30, 0x2f, 0x5c, 0x5f, 0x1a, 0xad, 0x77, 0x01, 0xdd, 0x92, 0x06,
0x39, 0xf1, 0xed, 0xaf, 0x72, 0x46, 0x14, 0x1e, 0x37, 0xa1, 0x4c, 0x28, 0xc9, 0xeb, 0x6a, 0x5c,
0x51, 0xec, 0x7e, 0x9a, 0x28, 0x69, 0xef, 0x06, 0xda, 0x5b, 0x71, 0x22, 0xc9, 0x9f, 0x7d, 0x1b,
0x2a, 0x8f, 0xc5, 0x92, 0xfc, 0x8f, 0xa3, 0xd3, 0x32, 0xd1, 0xfd, 0xa6, 0xc1, 0xf5, 0xe4, 0xf4,
0xb9, 0x7b, 0xe9, 0x8b, 0x0b, 0xd7, 0x9f, 0x0b, 0xd6, 0x8a, 0x63, 0xd5, 0xf2, 0x3e, 0x1f, 0x6f,
0x50, 0xe4, 0xec, 0x4e, 0x82, 0x14, 0x2a, 0xd4, 0x51, 0x41, 0x5d, 0x73, 0xbc, 0xa1, 0xaa, 0x64,
0x17, 0xaa, 0xbd, 0x33, 0x87, 0xcc, 0x59, 0x46, 0x5b, 0xeb, 0x18, 0xc7, 0x1b, 0x3c, 0xe1, 0xb0,
0x5b, 0x50, 0x39, 0x99, 0x47, 0xe2, 0xca, 0xe9, 0x53, 0x0d, 0x99, 0xc7, 0x1b, 0x3c, 0x66, 0xe0,
0x49, 0xfa, 0x7c, 0x2c, 0x96, 0xb2, 0x90, 0xf0, 0x64, 0xcc, 0x61, 0x3b, 0x60, 0xf6, 0x82, 0xc0,
0xa7, 0x62, 0xaa, 0xe2, 0x6d, 0x48, 0xf5, 0x2a, 0x50, 0x22, 0xc3, 0xf6, 0x15, 0xec, 0xe4, 0x03,
0x52, 0x69, 0x61, 0x60, 0xa0, 0x3d, 0x4d, 0xd9, 0x43, 0x82, 0x6d, 0x53, 0xaa, 0x74, 0x75, 0x3f,
0x26, 0xeb, 0x3e, 0x94, 0xc9, 0x8c, 0x2c, 0xf8, 0x7a, 0xf7, 0x5f, 0x39, 0x78, 0x53, 0x80, 0xb8,
0x52, 0xeb, 0xd5, 0x08, 0xdf, 0xa7, 0xa1, 0xd3, 0xb7, 0x3f, 0x2a, 0x42, 0x49, 0x39, 0x43, 0xd8,
0x4f, 0xdd, 0xb1, 0x90, 0x37, 0x73, 0xfa, 0x46, 0xde, 0xf9, 0x72, 0x2a, 0xe8, 0xea, 0x1a, 0xa7,
0x6f, 0x7b, 0x0e, 0xcd, 0xfc, 0x71, 0x74, 0x26, 0x53, 0x04, 0x6b, 0x9d, 0x21, 0x79, 0x52, 0x1d,
0xdd, 0x62, 0x75, 0x58, 0xab, 0x27, 0x8a, 0x05, 0xf2, 0x31, 0x98, 0xcf, 0x5c, 0x2f, 0x5c, 0x29,
0xdb, 0x6d, 0x89, 0x97, 0x41, 0x1e, 0x1a, 0x12, 0xf8, 0xd2, 0x61, 0x30, 0x9f, 0x44, 0x12, 0x30,
0x2e, 0x09, 0xfb, 0x13, 0xa8, 0xe1, 0x79, 0x19, 0xeb, 0xae, 0x34, 0xa6, 0xea, 0xa6, 0x8a, 0xb7,
0x23, 0xcd, 0xe5, 0x15, 0x49, 0x1f, 0xd0, 0xb3, 0x7d, 0xa0, 0x07, 0x80, 0xd2, 0x99, 0xb4, 0xd0,
0x82, 0x12, 0x51, 0x2a, 0xe4, 0xd4, 0x84, 0x64, 0xbf, 0xc2, 0xc6, 0x6d, 0xec, 0x3b, 0xd1, 0x83,
0xf7, 0x51, 0x2c, 0x2b, 0x0e, 0x3d, 0x30, 0xb8, 0xaa, 0x89, 0x00, 0xaa, 0x12, 0xa8, 0x60, 0x91,
0x1a, 0xd0, 0x32, 0x06, 0x90, 0x8b, 0xfd, 0xa1, 0x1f, 0xc7, 0x46, 0x04, 0xbe, 0x42, 0x1e, 0x2c,
0x52, 0x18, 0x14, 0xc5, 0xfe, 0x1b, 0xdf, 0x62, 0x52, 0x9c, 0x35, 0x7a, 0x1f, 0x78, 0x7f, 0x7c,
0xe1, 0x97, 0x00, 0x9f, 0x86, 0xc1, 0x7c, 0x4a, 0x10, 0x31, 0x1b, 0x4a, 0x44, 0xa9, 0x98, 0x1a,
0xa8, 0x1e, 0xfb, 0xc3, 0xa5, 0x68, 0x3d, 0xb8, 0x98, 0x84, 0x83, 0xd1, 0x48, 0x3e, 0x1f, 0x8e,
0x9f, 0xf6, 0x8f, 0x1a, 0x54, 0x2f, 0x5c, 0x3f, 0x11, 0x5f, 0xb8, 0xbe, 0x8a, 0x15, 0x3f, 0xf3,
0x66, 0x8c, 0xd8, 0xcc, 0x2d, 0xa8, 0x3e, 0xf2, 0x03, 0x37, 0x42, 0x65, 0xb4, 0xa5, 0xf1, 0x84,
0x66, 0x7b, 0x00, 0x7d, 0x31, 0xf0, 0xc6, 0xae, 0x8f, 0x52, 0x33, 0x7d, 0xcf, 0x8a, 0xcb, 0x33,
0x62, 0x66, 0x43, 0xe3, 0xdc, 0x1b, 0x8b, 0x59, 0xe4, 0x8e, 0xa7, 0xa8, 0x2e, 0xdb, 0x7c, 0x8e,
0x67, 0x7f, 0x00, 0x15, 0x75, 0x62, 0x7d, 0x36, 0x90, 0x7b, 0x36, 0x70, 0x7d, 0x11, 0xfb, 0x48,
0x84, 0xfd, 0xb3, 0x06, 0x8d, 0xcf, 0xe6, 0x22, 0x5c, 0x72, 0xf1, 0xed, 0x5c, 0xcc, 0x22, 0x54,
0x23, 0x3a, 0x4e, 0x14, 0x11, 0x98, 0x92, 0xb3, 0xe7, 0x6e, 0x38, 0x94, 0x15, 0x6e, 0x72, 0x45,
0x51, 0xaa, 0xc4, 0x38, 0x88, 0x04, 0xf9, 0x54, 0xe5, 0x8a, 0x62, 0x7b, 0xd0, 0x38, 0x1a, 0x5f,
0x8a, 0xe1, 0x50, 0x0c, 0xfb, 0x6e, 0xe4, 0x5a, 0xd5, 0xfc, 0x80, 0xc9, 0x09, 0xd9, 0xff, 0x60,
0xf3, 0x59, 0x28, 0xce, 0x43, 0x77, 0x32, 0xf3, 0xdd, 0x48, 0x0c, 0xad, 0x1a, 0xd9, 0xca, 0x33,
0xd9, 0x2e, 0xd4, 0x4e, 0xdc, 0xab, 0x13, 0x31, 0x0e, 0xc2, 0xa5, 0x05, 0x14, 0x43, 0xca, 0xb0,
0x9f, 0xc0, 0xa6, 0x0a, 0x63, 0x36, 0x0d, 0x26, 0x33, 0x81, 0x49, 0x3a, 0x0a, 0x43, 0x15, 0x05,
0x7e, 0xb2, 0x7b, 0x50, 0xe1, 0x62, 0x36, 0xf7, 0xa3, 0xf8, 0x99, 0x6e, 0xa1, 0x3b, 0xf1, 0xa9,
0xb9, 0x1f, 0xf1, 0x58, 0x6e, 0xff, 0x54, 0x82, 0x7a, 0x46, 0x90, 0x34, 0x0e, 0x6c, 0x7e, 0x9b,
0xb2, 0x71, 0xe0, 0xd8, 0xe3, 0xc1, 0x62, 0x65, 0x22, 0x62, 0xb1, 0x37, 0x40, 0x3b, 0x55, 0x15,
0xa5, 0x9d, 0xa6, 0x6f, 0xcb, 0x58, 0xff, 0xb6, 0x70, 0x0b, 0x78, 0xee, 0x4e, 0x46, 0x62, 0x48,
0x75, 0x50, 0xe5, 0x31, 0xc9, 0x3a, 0x69, 0xd1, 0x11, 0xbe, 0xaa, 0x88, 0x63, 0x1e, 0x4f, 0x4b,
0x52, 0x3e, 0x19, 0x9c, 0x1d, 0x15, 0x99, 0x1f, 0x49, 0xb1, 0x07, 0xd0, 0x7c, 0xea, 0x0f, 0xd3,
0x47, 0x31, 0x53, 0x99, 0x68, 0xa2, 0x9d, 0x94, 0xcd, 0x0b, 0x5a, 0xec, 0x61, 0x71, 0x70, 0x53,
0x4e, 0xea, 0x5d, 0xa6, 0xe2, 0xcc, 0x48, 0x78, 0x71, 0xc4, 0xef, 0x65, 0xf6, 0x06, 0x4a, 0x54,
0xbd, 0xbb, 0x89, 0xc7, 0x12, 0x26, 0xcf, 0xec, 0x15, 0xfb, 0xd9, 0x36, 0x64, 0xd5, 0x49, 0xbb,
0x19, 0x23, 0x24, 0xb9, 0x3c, 0xdb, 0xa8, 0xf6, 0x32, 0x7d, 0xcf, 0x6a, 0xa4, 0xc6, 0x13, 0x26,
0xcf, 0xf4, 0xc5, 0xc3, 0x35, 0x33, 0xde, 0xda, 0xa4, 0x43, 0xc5, 0x01, 0x2e, 0x85, 0x7c, 0xcd,
0x4e, 0xf0, 0xb0, 0x38, 0x20, 0xac, 0x66, 0x0a, 0x45, 0x5e, 0xc2, 0x8b, 0xa3, 0x64, 0x2f, 0xb3,
0x6c, 0x59, 0x5b, 0xa9, 0xb7, 0x09, 0x93, 0x67, 0x96, 0xb1, 0x77, 0xa1, 0x9e, 0x4d, 0xd4, 0x36,
0xa9, 0x6f, 0xe5, 0x13, 0x35, 0xe3, 0x59, 0x1d, 0xfb, 0x17, 0x1d, 0x36, 0x9d, 0xf1, 0x34, 0x08,
0xa3, 0xcc, 0xf3, 0x95, 0xab, 0xa0, 0xb6, 0x76, 0x15, 0xd4, 0x0b, 0xdd, 0x97, 0x9e, 0x31, 0x35,
0x27, 0x93, 0x4b, 0x22, 0x53, 0x4a, 0x66, 0xae, 0x94, 0x76, 0xa1, 0x26, 0x87, 0x17, 0x8a, 0x4a,
0x24, 0x4a, 0x19, 0x72, 0x39, 0x5d, 0xd0, 0x72, 0x52, 0xa1, 0x45, 0x27, 0x26, 0x59, 0x0b, 0x40,
0xaa, 0x91, 0xb0, 0x4a, 0xc2, 0x0c, 0x07, 0xe5, 0x49, 0x23, 0x9b, 0x59, 0xe5, 0xb6, 0xd1, 0x31,
0x78, 0x86, 0xc3, 0xee, 0x42, 0x93, 0x82, 0x38, 0x0c, 0x05, 0xf6, 0x81, 0x83, 0x88, 0x4a, 0xd1,
0xe0, 0x05, 0x2e, 0xea, 0x51, 0x58, 0xa9, 0x9e, 0x6c, 0x12, 0x05, 0x2e, 0xf5, 0x6a, 0x5f, 0xb8,
0x21, 0x15, 0x5b, 0x95, 0x4b, 0xc2, 0xfe, 0x43, 0x07, 0x26, 0x91, 0x94, 0x8b, 0xc6, 0x3f, 0x06,
0xe7, 0xeb, 0x61, 0xcb, 0x83, 0x53, 0x59, 0x01, 0xe7, 0x66, 0xb2, 0x18, 0x49, 0x60, 0x14, 0xc5,
0xda, 0x50, 0x8f, 0x47, 0x09, 0x0a, 0x11, 0x55, 0x8d, 0x67, 0x59, 0x38, 0x33, 0xce, 0x22, 0xfc,
0x75, 0xa0, 0x54, 0x6a, 0x64, 0x3b, 0xc7, 0x5b, 0x03, 0x2d, 0xbc, 0x21, 0xb4, 0xf5, 0xd7, 0x43,
0xdb, 0xc8, 0x42, 0xfb, 0x9d, 0x06, 0x8d, 0x83, 0x28, 0x18, 0x7b, 0x03, 0x2e, 0x06, 0x41, 0x38,
0x7c, 0x35, 0xa8, 0x12, 0x3e, 0x3d, 0x0b, 0x5f, 0x07, 0x0c, 0xe7, 0x45, 0xa8, 0x5a, 0xe7, 0x4d,
0x9a, 0xf8, 0x2b, 0x59, 0xe2, 0xa8, 0xc2, 0xee, 0x80, 0xee, 0x84, 0x54, 0xb3, 0xf5, 0xee, 0xb5,
0x54, 0x31, 0xd6, 0xd1, 0x9d, 0xd0, 0x7e, 0x07, 0x76, 0xa4, 0x23, 0xb1, 0x48, 0xcd, 0x8a, 0x1d,
0x28, 0x1d, 0x85, 0x61, 0x10, 0x4f, 0x0b, 0x49, 0xe0, 0x4a, 0x9b, 0x8c, 0x1f, 0x4c, 0xc6, 0xdb,
0xd4, 0xc4, 0xba, 0xdf, 0x71, 0x6d, 0xa8, 0x9f, 0x06, 0xd1, 0x17, 0xa1, 0x17, 0x51, 0x37, 0x91,
0x3d, 0x3f, 0xcb, 0xb2, 0xef, 0xc1, 0x8d, 0xc2, 0xcd, 0xe9, 0x50, 0xc3, 0x32, 0x32, 0xd2, 0xdf,
0x42, 0x67, 0x70, 0x3d, 0x51, 0x75, 0xfa, 0x6f, 0xe5, 0xe3, 0xaa, 0xd1, 0xff, 0x67, 0x22, 0x27,
0xa3, 0xea, 0xfa, 0x35, 0xd1, 0xd8, 0x3d, 0xb0, 0x14, 0x9a, 0xf2, 0xc7, 0xa8, 0xf2, 0xe0, 0xc2,
0x13, 0x8b, 0x57, 0xed, 0xe0, 0xb4, 0x11, 0xe8, 0xf4, 0x13, 0x96, 0xbe, 0xed, 0xef, 0x75, 0xd8,
0x59, 0x67, 0x24, 0x2d, 0x28, 0x2d, 0x53, 0x50, 0xac, 0x0b, 0xa5, 0x17, 0x9e, 0x58, 0xc4, 0x63,
0x7c, 0x37, 0x93, 0xec, 0x15, 0x1f, 0xb8, 0x54, 0xc5, 0x87, 0x74, 0x30, 0x88, 0xbc, 0x60, 0x12,
0xef, 0x94, 0x92, 0xc2, 0x1b, 0x7a, 0x7e, 0x30, 0xf8, 0x46, 0xfe, 0x1c, 0xe2, 0x92, 0x58, 0xf3,
0x30, 0x4a, 0x6f, 0xf8, 0x30, 0xca, 0x6b, 0x1f, 0x46, 0x07, 0xb6, 0x3e, 0x9f, 0x0e, 0xdd, 0x48,
0x1c, 0x5d, 0x79, 0xb3, 0x48, 0x4c, 0x06, 0xc2, 0xaa, 0x50, 0x44, 0x45, 0xb6, 0x7d, 0x96, 0x1b,
0x02, 0xd8, 0x3d, 0x0e, 0x46, 0xa3, 0x50, 0x8c, 0xdc, 0x28, 0x86, 0x31, 0x65, 0xb0, 0xbb, 0x50,
0x26, 0xe5, 0x18, 0x89, 0xe2, 0x54, 0x57, 0xd2, 0xde, 0xf6, 0xaf, 0x2f, 0x5b, 0xda, 0xef, 0x2f,
0x5b, 0xda, 0x9f, 0x2f, 0x5b, 0xda, 0x0f, 0x7f, 0xb5, 0x36, 0x2e, 0xcb, 0xf4, 0x5f, 0xc4, 0x7b,
0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x88, 0x20, 0x3d, 0x60, 0x9b, 0x10, 0x00, 0x00,
// 1618 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5d, 0x6f, 0x1b, 0x45,
0x17, 0xce, 0xee, 0xfa, 0xf3, 0xd8, 0x71, 0x92, 0x69, 0xda, 0x77, 0xdf, 0xbe, 0xa9, 0x5f, 0x77,
0x85, 0x2a, 0x97, 0xa0, 0x54, 0x18, 0xa8, 0x50, 0x25, 0xa8, 0xe2, 0x38, 0x25, 0x56, 0x9b, 0xb4,
0x4c, 0x42, 0xe0, 0x82, 0x9b, 0x8d, 0x3d, 0xb8, 0x2b, 0xd6, 0x5e, 0xb3, 0x5e, 0xd7, 0xc9, 0x2f,
0x80, 0x9f, 0xc0, 0x1d, 0xbf, 0x06, 0xc1, 0x1d, 0x5c, 0x72, 0x89, 0xca, 0x1d, 0xbf, 0x02, 0x9d,
0x33, 0x33, 0xfb, 0x65, 0xb7, 0xaa, 0x2a, 0xee, 0xf6, 0x7c, 0xcc, 0x99, 0x39, 0xcf, 0xf9, 0xb4,
0xa1, 0x3e, 0x9d, 0x5f, 0xf8, 0xde, 0x60, 0x6f, 0x1a, 0x06, 0x51, 0xc0, 0xcc, 0xe9, 0x85, 0x73,
0x05, 0x16, 0x0f, 0x16, 0xcc, 0x86, 0xf2, 0x41, 0xe0, 0xcf, 0xc7, 0x93, 0x99, 0x6d, 0xb4, 0xac,
0x76, 0x81, 0x6b, 0x92, 0x31, 0x28, 0x3c, 0x16, 0x57, 0x33, 0xdb, 0x6a, 0x59, 0xed, 0x2a, 0xa7,
0x6f, 0xd4, 0xe6, 0x81, 0x1b, 0x7a, 0x93, 0x91, 0x5d, 0x68, 0x19, 0xed, 0x3a, 0xd7, 0x24, 0xdb,
0x86, 0x62, 0x7f, 0x32, 0x14, 0x97, 0x76, 0xb1, 0x65, 0xb4, 0xab, 0x5c, 0x12, 0xc8, 0x7d, 0xe4,
0x09, 0x7f, 0x68, 0x97, 0x24, 0x97, 0x08, 0xa7, 0x0d, 0x55, 0x1e, 0x2c, 0x8e, 0xdd, 0x28, 0xf4,
0x2e, 0xd9, 0xff, 0xa0, 0xc0, 0x83, 0x85, 0xbc, 0xbd, 0xd6, 0x29, 0xef, 0x4d, 0x2f, 0xf6, 0x78,
0xb0, 0xe0, 0xc4, 0x74, 0xf6, 0xa1, 0x7a, 0xea, 0x8d, 0x26, 0x62, 0x88, 0x4f, 0xfd, 0x2f, 0x58,
0xcf, 0x02, 0x54, 0x34, 0xd2, 0x8a, 0xc8, 0x43, 0xd1, 0x89, 0x18, 0xd9, 0x66, 0x4e, 0x74, 0x22,
0x46, 0xce, 0xc7, 0xd0, 0xe0, 0xc1, 0xa2, 0x3f, 0x14, 0x93, 0xc8, 0xfb, 0xc6, 0x13, 0x21, 0x39,
0x16, 0xdf, 0x58, 0x90, 0x17, 0xc5, 0xce, 0x9a, 0x89, 0xb3, 0xce, 0x4d, 0x28, 0xf5, 0x7b, 0x4f,
0xbc, 0x59, 0xc4, 0x36, 0xc1, 0xea, 0xf7, 0xf4, 0x01, 0xfc, 0x74, 0x0e, 0x60, 0xeb, 0xf0, 0x32,
0x0a, 0xdd, 0x41, 0x24, 0x86, 0xfd, 0x9e, 0x84, 0x8c, 0x35, 0xc0, 0xec, 0xf7, 0xe8, 0x7d, 0x05,
0x6e, 0xf6, 0x7b, 0xac, 0x09, 0x85, 0x73, 0xd7, 0x97, 0x46, 0x6b, 0x1d, 0xc0, 0x67, 0x49, 0x83,
0x9c, 0xf8, 0xce, 0xd7, 0x19, 0x23, 0x0a, 0x8f, 0x1b, 0x50, 0x22, 0x94, 0xe4, 0x75, 0x55, 0xae,
0x28, 0x76, 0x2f, 0x09, 0x94, 0xb4, 0x77, 0x1d, 0xed, 0x2d, 0x3d, 0x22, 0x8e, 0x9f, 0x73, 0x0b,
0xca, 0x8f, 0xc5, 0x15, 0xbd, 0x5f, 0x7b, 0x67, 0xa4, 0xbc, 0xfb, 0xcd, 0x80, 0x6b, 0xf1, 0xe9,
0x33, 0xf7, 0xc2, 0x17, 0xe7, 0xae, 0x3f, 0x17, 0xac, 0xa9, 0x7d, 0x35, 0xb2, 0x6f, 0x3e, 0x5a,
0x23, 0xcf, 0xd9, 0xed, 0x18, 0x29, 0x54, 0xa8, 0xa1, 0x82, 0xba, 0xe6, 0x68, 0x4d, 0x65, 0xc9,
0x0e, 0x54, 0xba, 0xa7, 0x7d, 0x32, 0x67, 0x5b, 0x2d, 0xa3, 0x6d, 0x1d, 0xad, 0xf1, 0x98, 0xc3,
0x6e, 0x42, 0xf9, 0x78, 0x1e, 0x89, 0xcb, 0x7e, 0x8f, 0x72, 0xa8, 0x70, 0xb4, 0xc6, 0x35, 0x03,
0x4f, 0xd2, 0xe7, 0x63, 0x71, 0x25, 0x13, 0x09, 0x4f, 0x6a, 0x0e, 0xdb, 0x86, 0x42, 0x37, 0x08,
0x7c, 0x4a, 0xa6, 0x0a, 0xde, 0x86, 0x54, 0xb7, 0x0c, 0x45, 0x32, 0xec, 0x5c, 0xc2, 0x76, 0xd6,
0x21, 0x15, 0x16, 0x06, 0x16, 0xda, 0x33, 0x94, 0x3d, 0x24, 0xd8, 0x26, 0x85, 0xca, 0x54, 0xf7,
0x63, 0xb0, 0xee, 0x41, 0x89, 0xcc, 0xc8, 0x84, 0xaf, 0x75, 0xfe, 0x93, 0x81, 0x37, 0x01, 0x88,
0x2b, 0xb5, 0x6e, 0x95, 0xf0, 0x7d, 0x1a, 0xf6, 0x7b, 0xce, 0x27, 0x79, 0x28, 0x29, 0x66, 0x08,
0xfb, 0x89, 0x3b, 0x16, 0xf2, 0x66, 0x4e, 0xdf, 0xc8, 0x3b, 0xbb, 0x9a, 0x0a, 0xba, 0xba, 0xca,
0xe9, 0xdb, 0x99, 0x43, 0x23, 0x7b, 0x1c, 0x1f, 0x93, 0x4a, 0x82, 0x95, 0x8f, 0x21, 0x79, 0x9c,
0x1d, 0x9d, 0x7c, 0x76, 0xd8, 0xcb, 0x27, 0xf2, 0x09, 0xf2, 0x29, 0x14, 0x9e, 0xb9, 0x5e, 0xb8,
0x94, 0xb6, 0x9b, 0x12, 0x2f, 0x8b, 0x5e, 0x68, 0x49, 0xe0, 0x8b, 0x07, 0xc1, 0x7c, 0x12, 0x49,
0xc0, 0xb8, 0x24, 0x9c, 0x87, 0x50, 0xc5, 0xf3, 0xd2, 0xd7, 0x1d, 0x69, 0x4c, 0xe5, 0x4d, 0x05,
0x6f, 0x47, 0x9a, 0xcb, 0x2b, 0xe2, 0x3e, 0x60, 0xa6, 0xfb, 0x40, 0x17, 0x00, 0xa5, 0x33, 0x69,
0xa1, 0x09, 0x45, 0xa2, 0x94, 0xcb, 0x89, 0x09, 0xc9, 0x7e, 0x85, 0x8d, 0x5b, 0xd8, 0x77, 0xa2,
0xfb, 0x1f, 0xa2, 0x58, 0x66, 0x1c, 0xbe, 0xc0, 0xe2, 0x2a, 0x27, 0x02, 0xa8, 0x48, 0xa0, 0x82,
0x45, 0x62, 0xc0, 0x48, 0x19, 0x40, 0x2e, 0xf6, 0x87, 0x9e, 0xf6, 0x8d, 0x08, 0xac, 0x42, 0x1e,
0x2c, 0x12, 0x18, 0x14, 0xc5, 0xfe, 0xaf, 0x6f, 0x29, 0x90, 0x9f, 0x55, 0xaa, 0x0f, 0xbc, 0x5f,
0x5f, 0xf8, 0x15, 0xc0, 0x67, 0x61, 0x30, 0x9f, 0x12, 0x44, 0xcc, 0x81, 0x22, 0x51, 0xca, 0xa7,
0x3a, 0xaa, 0xeb, 0xf7, 0x70, 0x29, 0x5a, 0x0d, 0x2e, 0x06, 0x61, 0x7f, 0x34, 0x92, 0xe5, 0xc3,
0xf1, 0xd3, 0xf9, 0xc9, 0x80, 0xca, 0xb9, 0xeb, 0xc7, 0xe2, 0x73, 0xd7, 0x57, 0xbe, 0xe2, 0x67,
0xd6, 0x8c, 0xa5, 0xcd, 0xdc, 0x84, 0xca, 0x23, 0x3f, 0x70, 0x23, 0x54, 0x46, 0x5b, 0x06, 0x8f,
0x69, 0xb6, 0x0b, 0xd0, 0x13, 0x03, 0x6f, 0xec, 0xfa, 0x28, 0x2d, 0x24, 0xf5, 0xac, 0xb8, 0x3c,
0x25, 0x66, 0x0e, 0xd4, 0xcf, 0xbc, 0xb1, 0x98, 0x45, 0xee, 0x78, 0x8a, 0xea, 0xb2, 0xcd, 0x67,
0x78, 0xce, 0x47, 0x50, 0x56, 0x27, 0x56, 0x47, 0x03, 0xb9, 0xa7, 0x03, 0xd7, 0x17, 0xfa, 0x8d,
0x44, 0x38, 0x0f, 0x61, 0xab, 0xe7, 0xcd, 0x22, 0x6f, 0x32, 0x88, 0x62, 0x73, 0x18, 0x00, 0x55,
0x8e, 0xaa, 0x0d, 0x4a, 0x2a, 0xae, 0x29, 0x33, 0xa9, 0x29, 0xe7, 0x67, 0x03, 0xea, 0x9f, 0xcf,
0x45, 0x78, 0xc5, 0xc5, 0x77, 0x73, 0x31, 0x8b, 0xf0, 0x1e, 0xa2, 0x75, 0xa4, 0x89, 0x40, 0x93,
0xa7, 0xcf, 0xdd, 0x70, 0x28, 0x4b, 0xa4, 0xc0, 0x15, 0x45, 0xb1, 0x16, 0xe3, 0x20, 0x12, 0xe4,
0x54, 0x85, 0x2b, 0x8a, 0xed, 0x42, 0xfd, 0x70, 0x7c, 0x21, 0x86, 0x43, 0x31, 0xec, 0xb9, 0x91,
0x6b, 0x57, 0xb2, 0x13, 0x2a, 0x23, 0x64, 0xef, 0xc0, 0xfa, 0xb3, 0x50, 0x9c, 0x85, 0xee, 0x64,
0xe6, 0xbb, 0x91, 0x18, 0xda, 0x55, 0xb2, 0x95, 0x65, 0xb2, 0x1d, 0xa8, 0x1e, 0xbb, 0x97, 0xc7,
0x62, 0x1c, 0x84, 0x57, 0x36, 0x10, 0x08, 0x09, 0xc3, 0x79, 0x02, 0xeb, 0xca, 0x8d, 0xd9, 0x34,
0x98, 0xcc, 0x04, 0x46, 0xf9, 0x30, 0x0c, 0x95, 0x17, 0xf8, 0xc9, 0xee, 0x42, 0x99, 0x8b, 0xd9,
0xdc, 0x8f, 0x74, 0x9d, 0x6f, 0xe0, 0x73, 0xf4, 0xa9, 0xb9, 0x1f, 0x71, 0x2d, 0x77, 0xfe, 0x2e,
0x42, 0x2d, 0x25, 0x88, 0x3b, 0x0f, 0x76, 0xcf, 0x75, 0xd9, 0x79, 0x70, 0x6e, 0xf2, 0x60, 0xb1,
0x34, 0x52, 0xb1, 0x5a, 0xea, 0x60, 0x9c, 0xa8, 0x94, 0x34, 0x4e, 0x92, 0xe2, 0xb4, 0x56, 0x17,
0x27, 0xae, 0x11, 0xcf, 0xdd, 0xc9, 0x48, 0x0c, 0x29, 0x91, 0x2a, 0x5c, 0x93, 0xac, 0x9d, 0x64,
0x2d, 0xe1, 0xab, 0xaa, 0x40, 0xf3, 0x78, 0x92, 0xd3, 0xb2, 0xe6, 0x70, 0xf8, 0x94, 0x65, 0x7c,
0x24, 0xc5, 0xee, 0x43, 0xe3, 0xa9, 0x3f, 0x4c, 0xaa, 0x6a, 0xa6, 0x22, 0xd1, 0x40, 0x3b, 0x09,
0x9b, 0xe7, 0xb4, 0xd8, 0x83, 0xfc, 0xe4, 0xa7, 0x98, 0xd4, 0x3a, 0x4c, 0xf9, 0x99, 0x92, 0xf0,
0xfc, 0x8e, 0xb0, 0x9b, 0x5a, 0x3c, 0x28, 0x50, 0xb5, 0xce, 0x3a, 0x1e, 0x8b, 0x99, 0x3c, 0xb5,
0x98, 0xec, 0xa5, 0xfb, 0x98, 0x5d, 0x23, 0xed, 0x86, 0x46, 0x48, 0x72, 0x79, 0xba, 0xd3, 0xed,
0xa6, 0x1a, 0xa7, 0x5d, 0x4f, 0x8c, 0xc7, 0x4c, 0x9e, 0x6a, 0xac, 0x07, 0x2b, 0x96, 0x04, 0x7b,
0x9d, 0x0e, 0xe5, 0x37, 0x00, 0x29, 0xe4, 0x2b, 0x96, 0x8a, 0x07, 0xf9, 0x09, 0x63, 0x37, 0x12,
0x28, 0xb2, 0x12, 0x9e, 0x9f, 0x45, 0xbb, 0xa9, 0x6d, 0xcd, 0xde, 0x48, 0x5e, 0x1b, 0x33, 0x79,
0x6a, 0x9b, 0x7b, 0x1f, 0x6a, 0xe9, 0x40, 0x6d, 0x92, 0xfa, 0x46, 0x36, 0x50, 0x33, 0x9e, 0xd6,
0x41, 0x07, 0x97, 0xca, 0xdf, 0xde, 0x4a, 0x1c, 0x5c, 0x12, 0xf2, 0x65, 0x7d, 0xe7, 0x17, 0x13,
0xd6, 0xfb, 0xe3, 0x69, 0x10, 0x46, 0xa9, 0x1e, 0x20, 0x17, 0x52, 0x63, 0xe5, 0x42, 0x6a, 0xe6,
0x66, 0x00, 0xf5, 0x02, 0x6a, 0x91, 0x05, 0x2e, 0x89, 0x54, 0x3e, 0x16, 0x32, 0xf9, 0xb8, 0x03,
0x55, 0x39, 0x42, 0x51, 0x54, 0x24, 0x51, 0xc2, 0x90, 0x2b, 0xf2, 0x82, 0x56, 0xa4, 0x32, 0x75,
0x2e, 0x4d, 0xb2, 0x26, 0x80, 0x54, 0x23, 0x61, 0x85, 0x84, 0x29, 0x0e, 0xca, 0x63, 0x87, 0x66,
0x76, 0xa9, 0x65, 0xb5, 0x2d, 0x9e, 0xe2, 0xb0, 0x3b, 0xd0, 0x20, 0x27, 0x0e, 0x42, 0x81, 0xcd,
0x64, 0x3f, 0xa2, 0x7c, 0xb6, 0x78, 0x8e, 0x8b, 0x7a, 0xe4, 0x56, 0xa2, 0x27, 0x3b, 0x4d, 0x8e,
0x4b, 0x13, 0xc3, 0x17, 0x6e, 0x48, 0x19, 0x5b, 0xe1, 0x92, 0x70, 0xfe, 0x30, 0x81, 0x49, 0x24,
0xe5, 0xba, 0xf3, 0xaf, 0xc1, 0xf9, 0x7a, 0xd8, 0xb2, 0xe0, 0x94, 0x97, 0xc0, 0x49, 0xe6, 0x81,
0x04, 0x46, 0xcf, 0x83, 0x16, 0xd4, 0xf4, 0x40, 0x43, 0x21, 0xa2, 0x6a, 0xf0, 0x34, 0x0b, 0x27,
0xd7, 0x69, 0x84, 0xbf, 0x51, 0x94, 0x4a, 0x95, 0x6c, 0x67, 0x78, 0x2b, 0xa0, 0x85, 0x37, 0x84,
0xb6, 0xf6, 0x7a, 0x68, 0xeb, 0x69, 0x68, 0xbf, 0x37, 0xa0, 0xbe, 0x1f, 0x05, 0x63, 0x6f, 0xc0,
0xc5, 0x20, 0x08, 0x87, 0xaf, 0x06, 0x55, 0xc2, 0x67, 0xa6, 0xe1, 0x6b, 0x83, 0xd5, 0x7f, 0x11,
0xaa, 0xfe, 0x7b, 0x83, 0xf6, 0x8e, 0xa5, 0x28, 0x71, 0x54, 0x61, 0xb7, 0xc1, 0xec, 0x87, 0x94,
0xb3, 0xb5, 0xce, 0x56, 0xa2, 0xa8, 0x75, 0xcc, 0x7e, 0xe8, 0xbc, 0x07, 0xdb, 0xf2, 0x21, 0x5a,
0xa4, 0x06, 0xce, 0x36, 0x14, 0x0f, 0xc3, 0x30, 0xd0, 0x23, 0x47, 0x12, 0xb8, 0x58, 0xc7, 0x33,
0x0c, 0x83, 0xf1, 0x36, 0x39, 0xb1, 0xea, 0xd7, 0x64, 0x0b, 0x6a, 0x27, 0x41, 0xf4, 0x65, 0xe8,
0x45, 0xd4, 0x92, 0xe4, 0xe0, 0x48, 0xb3, 0x9c, 0xbb, 0x70, 0x3d, 0x77, 0x73, 0x32, 0x19, 0x31,
0x8d, 0xac, 0xe4, 0x17, 0xd9, 0x29, 0x5c, 0x8b, 0x55, 0xfb, 0xbd, 0xb7, 0x7a, 0xe3, 0xb2, 0xd1,
0x77, 0x53, 0x9e, 0x93, 0x51, 0x75, 0xfd, 0x0a, 0x6f, 0x9c, 0x2e, 0xd8, 0x0a, 0x4d, 0xf9, 0x93,
0x58, 0xbd, 0xe0, 0xdc, 0x13, 0x8b, 0x57, 0xfd, 0x12, 0xa0, 0xb5, 0xc2, 0xa4, 0x1f, 0xd2, 0xf4,
0xed, 0xfc, 0x60, 0xc2, 0xf6, 0x2a, 0x23, 0x49, 0x42, 0x19, 0xa9, 0x84, 0x62, 0x1d, 0x28, 0xbe,
0xf0, 0xc4, 0x42, 0xef, 0x02, 0x3b, 0xa9, 0x60, 0x2f, 0xbd, 0x81, 0x4b, 0x55, 0x2c, 0xa4, 0xfd,
0x41, 0xe4, 0x05, 0x13, 0xbd, 0xd9, 0x4a, 0x0a, 0x6f, 0xe8, 0xfa, 0xc1, 0xe0, 0x5b, 0xf9, 0xa3,
0x8c, 0x4b, 0x62, 0x45, 0x61, 0x14, 0xdf, 0xb0, 0x30, 0x4a, 0x2b, 0x0b, 0xa3, 0x0d, 0x1b, 0x5f,
0x4c, 0x87, 0x6e, 0x24, 0x0e, 0x2f, 0xbd, 0x59, 0x24, 0x26, 0x03, 0x61, 0x97, 0xc9, 0xa3, 0x3c,
0xdb, 0x39, 0xcd, 0x4c, 0x12, 0xec, 0x1e, 0xfb, 0xa3, 0x51, 0x28, 0x46, 0x6e, 0xa4, 0x61, 0x4c,
0x18, 0xec, 0x0e, 0x94, 0x48, 0x59, 0x23, 0x91, 0x5f, 0x0d, 0x94, 0xb4, 0xbb, 0xf9, 0xeb, 0xcb,
0xa6, 0xf1, 0xfb, 0xcb, 0xa6, 0xf1, 0xe7, 0xcb, 0xa6, 0xf1, 0xe3, 0x5f, 0xcd, 0xb5, 0x8b, 0x12,
0xfd, 0x23, 0xf2, 0xc1, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xec, 0x75, 0x7f, 0x8e, 0x21, 0x11,
0x00, 0x00,
}
func (m *Row) Marshal() (dAtA []byte, err error) {
@ -3640,6 +3707,49 @@ func (m *Decimal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *DistinctTimestamp) 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 *DistinctTimestamp) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *DistinctTimestamp) 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 len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0x12
}
if len(m.Values) > 0 {
for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Values[iNdEx])
copy(dAtA[i:], m.Values[iNdEx])
i = encodeVarintPublic(dAtA, i, uint64(len(m.Values[iNdEx])))
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *QueryRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -3803,6 +3913,20 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.DistinctTimestamp != nil {
{
size, err := m.DistinctTimestamp.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintPublic(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x8a
}
if m.GroupCounts != nil {
{
size, err := m.GroupCounts.MarshalToSizedBuffer(dAtA[:i])
@ -3916,20 +4040,20 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
}
if len(m.RowIDs) > 0 {
dAtA25 := make([]byte, len(m.RowIDs)*10)
var j24 int
dAtA26 := make([]byte, len(m.RowIDs)*10)
var j25 int
for _, num := range m.RowIDs {
for num >= 1<<7 {
dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j24++
j25++
}
dAtA25[j24] = uint8(num)
j24++
dAtA26[j25] = uint8(num)
j25++
}
i -= j24
copy(dAtA[i:], dAtA25[:j24])
i = encodeVarintPublic(dAtA, i, uint64(j24))
i -= j25
copy(dAtA[i:], dAtA26[:j25])
i = encodeVarintPublic(dAtA, i, uint64(j25))
i--
dAtA[i] = 0x3a
}
@ -4057,57 +4181,57 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
}
if len(m.Timestamps) > 0 {
dAtA29 := make([]byte, len(m.Timestamps)*10)
var j28 int
dAtA30 := make([]byte, len(m.Timestamps)*10)
var j29 int
for _, num1 := range m.Timestamps {
num := uint64(num1)
for num >= 1<<7 {
dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80)
dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j28++
j29++
}
dAtA29[j28] = uint8(num)
j28++
dAtA30[j29] = uint8(num)
j29++
}
i -= j28
copy(dAtA[i:], dAtA29[:j28])
i = encodeVarintPublic(dAtA, i, uint64(j28))
i -= j29
copy(dAtA[i:], dAtA30[:j29])
i = encodeVarintPublic(dAtA, i, uint64(j29))
i--
dAtA[i] = 0x32
}
if len(m.ColumnIDs) > 0 {
dAtA31 := make([]byte, len(m.ColumnIDs)*10)
var j30 int
dAtA32 := make([]byte, len(m.ColumnIDs)*10)
var j31 int
for _, num := range m.ColumnIDs {
for num >= 1<<7 {
dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80)
dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j30++
j31++
}
dAtA31[j30] = uint8(num)
j30++
dAtA32[j31] = uint8(num)
j31++
}
i -= j30
copy(dAtA[i:], dAtA31[:j30])
i = encodeVarintPublic(dAtA, i, uint64(j30))
i -= j31
copy(dAtA[i:], dAtA32[:j31])
i = encodeVarintPublic(dAtA, i, uint64(j31))
i--
dAtA[i] = 0x2a
}
if len(m.RowIDs) > 0 {
dAtA33 := make([]byte, len(m.RowIDs)*10)
var j32 int
dAtA34 := make([]byte, len(m.RowIDs)*10)
var j33 int
for _, num := range m.RowIDs {
for num >= 1<<7 {
dAtA33[j32] = uint8(uint64(num)&0x7f | 0x80)
dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j32++
j33++
}
dAtA33[j32] = uint8(num)
j32++
dAtA34[j33] = uint8(num)
j33++
}
i -= j32
copy(dAtA[i:], dAtA33[:j32])
i = encodeVarintPublic(dAtA, i, uint64(j32))
i -= j33
copy(dAtA[i:], dAtA34[:j33])
i = encodeVarintPublic(dAtA, i, uint64(j33))
i--
dAtA[i] = 0x22
}
@ -4188,9 +4312,9 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
if len(m.FloatValues) > 0 {
for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- {
f34 := math.Float64bits(float64(m.FloatValues[iNdEx]))
f35 := math.Float64bits(float64(m.FloatValues[iNdEx]))
i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f34))
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f35))
}
i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
i--
@ -4206,39 +4330,39 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
}
if len(m.Values) > 0 {
dAtA36 := make([]byte, len(m.Values)*10)
var j35 int
dAtA37 := make([]byte, len(m.Values)*10)
var j36 int
for _, num1 := range m.Values {
num := uint64(num1)
for num >= 1<<7 {
dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80)
dAtA37[j36] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j35++
j36++
}
dAtA36[j35] = uint8(num)
j35++
dAtA37[j36] = uint8(num)
j36++
}
i -= j35
copy(dAtA[i:], dAtA36[:j35])
i = encodeVarintPublic(dAtA, i, uint64(j35))
i -= j36
copy(dAtA[i:], dAtA37[:j36])
i = encodeVarintPublic(dAtA, i, uint64(j36))
i--
dAtA[i] = 0x32
}
if len(m.ColumnIDs) > 0 {
dAtA38 := make([]byte, len(m.ColumnIDs)*10)
var j37 int
dAtA39 := make([]byte, len(m.ColumnIDs)*10)
var j38 int
for _, num := range m.ColumnIDs {
for num >= 1<<7 {
dAtA38[j37] = uint8(uint64(num)&0x7f | 0x80)
dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j37++
j38++
}
dAtA38[j37] = uint8(num)
j37++
dAtA39[j38] = uint8(num)
j38++
}
i -= j37
copy(dAtA[i:], dAtA38[:j37])
i = encodeVarintPublic(dAtA, i, uint64(j37))
i -= j38
copy(dAtA[i:], dAtA39[:j38])
i = encodeVarintPublic(dAtA, i, uint64(j38))
i--
dAtA[i] = 0x2a
}
@ -4450,20 +4574,20 @@ func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.IDs) > 0 {
dAtA40 := make([]byte, len(m.IDs)*10)
var j39 int
dAtA41 := make([]byte, len(m.IDs)*10)
var j40 int
for _, num := range m.IDs {
for num >= 1<<7 {
dAtA40[j39] = uint8(uint64(num)&0x7f | 0x80)
dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j39++
j40++
}
dAtA40[j39] = uint8(num)
j39++
dAtA41[j40] = uint8(num)
j40++
}
i -= j39
copy(dAtA[i:], dAtA40[:j39])
i = encodeVarintPublic(dAtA, i, uint64(j39))
i -= j40
copy(dAtA[i:], dAtA41[:j40])
i = encodeVarintPublic(dAtA, i, uint64(j40))
i--
dAtA[i] = 0x1a
}
@ -4495,20 +4619,20 @@ func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.IDs) > 0 {
dAtA42 := make([]byte, len(m.IDs)*10)
var j41 int
dAtA43 := make([]byte, len(m.IDs)*10)
var j42 int
for _, num := range m.IDs {
for num >= 1<<7 {
dAtA42[j41] = uint8(uint64(num)&0x7f | 0x80)
dAtA43[j42] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j41++
j42++
}
dAtA42[j41] = uint8(num)
j41++
dAtA43[j42] = uint8(num)
j42++
}
i -= j41
copy(dAtA[i:], dAtA42[:j41])
i = encodeVarintPublic(dAtA, i, uint64(j41))
i -= j42
copy(dAtA[i:], dAtA43[:j42])
i = encodeVarintPublic(dAtA, i, uint64(j42))
i--
dAtA[i] = 0x1a
}
@ -5267,6 +5391,28 @@ func (m *Decimal) Size() (n int) {
return n
}
func (m *DistinctTimestamp) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Values) > 0 {
for _, s := range m.Values {
l = len(s)
n += 1 + l + sovPublic(uint64(l))
}
}
l = len(m.Name)
if l > 0 {
n += 1 + l + sovPublic(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *QueryRequest) Size() (n int) {
if m == nil {
return 0
@ -5401,6 +5547,10 @@ func (m *QueryResult) Size() (n int) {
l = m.GroupCounts.Size()
n += 2 + l + sovPublic(uint64(l))
}
if m.DistinctTimestamp != nil {
l = m.DistinctTimestamp.Size()
n += 2 + l + sovPublic(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -8375,6 +8525,121 @@ func (m *Decimal) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *DistinctTimestamp) 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: DistinctTimestamp: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: DistinctTimestamp: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Values", 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 < 0 {
return ErrInvalidLengthPublic
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", 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 < 0 {
return ErrInvalidLengthPublic
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPublic(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (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 *QueryRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -9335,6 +9600,42 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 17:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field DistinctTimestamp", 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.DistinctTimestamp == nil {
m.DistinctTimestamp = &DistinctTimestamp{}
}
if err := m.DistinctTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPublic(dAtA[iNdEx:])

7
pb/public.proto
View file

@ -117,6 +117,12 @@ message Decimal {
int64 Scale = 2;
}
message DistinctTimestamp {
repeated string Values = 1;
string Name = 2;
}
message QueryRequest {
string Query = 1;
repeated uint64 Shards = 2;
@ -154,6 +160,7 @@ message QueryResult {
ExtractedTable ExtractedTable = 14;
RowMatrix RowMatrix = 15;
GroupCounts GroupCounts = 16;
DistinctTimestamp DistinctTimestamp = 17;
}
message ImportRequest {