mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-09-07 17:15:56 +00:00
5cb37834a0
This PR adds a field name (string) to the return types
which represent the values from a specific field. For example,
a TopN query on field `x` would be `TopN(x)` and have results
like:
```
[]Pair{
{ID: 14, Count: 10},
{ID: 3, Count: 8},
{ID: 7, Count: 3},
}
```
In order to know what field this result type refers to, we wrap
`[]Pair` in a new struct called `PairsField` which contains an
addition `Field` string where `x` is stored.
This is useful for informing the gRPC server how to construct
more appropriate headers for the result stream (in this case,
the column headers can now be "x" and "count").
Similar logic was applied to `RowIdentifiers` and `Pair` as well.
7486 lines
169 KiB
Go
7486 lines
169 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: public.proto
|
|
|
|
package internal
|
|
|
|
import proto "github.com/golang/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
|
|
import encoding_binary "encoding/binary"
|
|
|
|
import io "io"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
|
|
|
|
type Row struct {
|
|
Columns []uint64 `protobuf:"varint,1,rep,packed,name=Columns" json:"Columns,omitempty"`
|
|
Keys []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
|
|
Attrs []*Attr `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
|
|
Roaring []byte `protobuf:"bytes,4,opt,name=Roaring,proto3" json:"Roaring,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Row) Reset() { *m = Row{} }
|
|
func (m *Row) String() string { return proto.CompactTextString(m) }
|
|
func (*Row) ProtoMessage() {}
|
|
func (*Row) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{0}
|
|
}
|
|
func (m *Row) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Row.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *Row) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Row.Merge(dst, src)
|
|
}
|
|
func (m *Row) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Row) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Row.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Row proto.InternalMessageInfo
|
|
|
|
func (m *Row) GetColumns() []uint64 {
|
|
if m != nil {
|
|
return m.Columns
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Row) GetKeys() []string {
|
|
if m != nil {
|
|
return m.Keys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Row) GetAttrs() []*Attr {
|
|
if m != nil {
|
|
return m.Attrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Row) GetRoaring() []byte {
|
|
if m != nil {
|
|
return m.Roaring
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SignedRow struct {
|
|
Pos *Row `protobuf:"bytes,1,opt,name=Pos" json:"Pos,omitempty"`
|
|
Neg *Row `protobuf:"bytes,2,opt,name=Neg" json:"Neg,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SignedRow) Reset() { *m = SignedRow{} }
|
|
func (m *SignedRow) String() string { return proto.CompactTextString(m) }
|
|
func (*SignedRow) ProtoMessage() {}
|
|
func (*SignedRow) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{1}
|
|
}
|
|
func (m *SignedRow) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SignedRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SignedRow.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *SignedRow) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SignedRow.Merge(dst, src)
|
|
}
|
|
func (m *SignedRow) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SignedRow) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SignedRow.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SignedRow proto.InternalMessageInfo
|
|
|
|
func (m *SignedRow) GetPos() *Row {
|
|
if m != nil {
|
|
return m.Pos
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SignedRow) GetNeg() *Row {
|
|
if m != nil {
|
|
return m.Neg
|
|
}
|
|
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"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *RowIdentifiers) Reset() { *m = RowIdentifiers{} }
|
|
func (m *RowIdentifiers) String() string { return proto.CompactTextString(m) }
|
|
func (*RowIdentifiers) ProtoMessage() {}
|
|
func (*RowIdentifiers) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{2}
|
|
}
|
|
func (m *RowIdentifiers) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *RowIdentifiers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_RowIdentifiers.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *RowIdentifiers) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_RowIdentifiers.Merge(dst, src)
|
|
}
|
|
func (m *RowIdentifiers) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *RowIdentifiers) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_RowIdentifiers.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_RowIdentifiers proto.InternalMessageInfo
|
|
|
|
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"`
|
|
Count uint64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Pair) Reset() { *m = Pair{} }
|
|
func (m *Pair) String() string { return proto.CompactTextString(m) }
|
|
func (*Pair) ProtoMessage() {}
|
|
func (*Pair) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{3}
|
|
}
|
|
func (m *Pair) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *Pair) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Pair.Merge(dst, src)
|
|
}
|
|
func (m *Pair) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Pair) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Pair.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Pair proto.InternalMessageInfo
|
|
|
|
func (m *Pair) GetID() uint64 {
|
|
if m != nil {
|
|
return m.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Pair) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Pair) GetCount() uint64 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type PairField struct {
|
|
Pair *Pair `protobuf:"bytes,1,opt,name=Pair" json:"Pair,omitempty"`
|
|
Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PairField) Reset() { *m = PairField{} }
|
|
func (m *PairField) String() string { return proto.CompactTextString(m) }
|
|
func (*PairField) ProtoMessage() {}
|
|
func (*PairField) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{4}
|
|
}
|
|
func (m *PairField) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PairField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PairField.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *PairField) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PairField.Merge(dst, src)
|
|
}
|
|
func (m *PairField) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PairField) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PairField.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PairField proto.InternalMessageInfo
|
|
|
|
func (m *PairField) GetPair() *Pair {
|
|
if m != nil {
|
|
return m.Pair
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PairField) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type PairsField struct {
|
|
Pairs []*Pair `protobuf:"bytes,1,rep,name=Pairs" json:"Pairs,omitempty"`
|
|
Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PairsField) Reset() { *m = PairsField{} }
|
|
func (m *PairsField) String() string { return proto.CompactTextString(m) }
|
|
func (*PairsField) ProtoMessage() {}
|
|
func (*PairsField) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{5}
|
|
}
|
|
func (m *PairsField) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PairsField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PairsField.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *PairsField) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PairsField.Merge(dst, src)
|
|
}
|
|
func (m *PairsField) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PairsField) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PairsField.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PairsField proto.InternalMessageInfo
|
|
|
|
func (m *PairsField) GetPairs() []*Pair {
|
|
if m != nil {
|
|
return m.Pairs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PairsField) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type FieldRow struct {
|
|
Field string `protobuf:"bytes,1,opt,name=Field,proto3" json:"Field,omitempty"`
|
|
RowID uint64 `protobuf:"varint,2,opt,name=RowID,proto3" json:"RowID,omitempty"`
|
|
RowKey string `protobuf:"bytes,3,opt,name=RowKey,proto3" json:"RowKey,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *FieldRow) Reset() { *m = FieldRow{} }
|
|
func (m *FieldRow) String() string { return proto.CompactTextString(m) }
|
|
func (*FieldRow) ProtoMessage() {}
|
|
func (*FieldRow) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{6}
|
|
}
|
|
func (m *FieldRow) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *FieldRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_FieldRow.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *FieldRow) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_FieldRow.Merge(dst, src)
|
|
}
|
|
func (m *FieldRow) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *FieldRow) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_FieldRow.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_FieldRow proto.InternalMessageInfo
|
|
|
|
func (m *FieldRow) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *FieldRow) GetRowID() uint64 {
|
|
if m != nil {
|
|
return m.RowID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *FieldRow) GetRowKey() string {
|
|
if m != nil {
|
|
return m.RowKey
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type GroupCount struct {
|
|
Group []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
|
|
Count uint64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
|
|
Sum int64 `protobuf:"varint,3,opt,name=Sum,proto3" json:"Sum,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GroupCount) Reset() { *m = GroupCount{} }
|
|
func (m *GroupCount) String() string { return proto.CompactTextString(m) }
|
|
func (*GroupCount) ProtoMessage() {}
|
|
func (*GroupCount) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{7}
|
|
}
|
|
func (m *GroupCount) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GroupCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GroupCount.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *GroupCount) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GroupCount.Merge(dst, src)
|
|
}
|
|
func (m *GroupCount) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GroupCount) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GroupCount.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GroupCount proto.InternalMessageInfo
|
|
|
|
func (m *GroupCount) GetGroup() []*FieldRow {
|
|
if m != nil {
|
|
return m.Group
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GroupCount) GetCount() uint64 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *GroupCount) GetSum() int64 {
|
|
if m != nil {
|
|
return m.Sum
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type ValCount struct {
|
|
Val int64 `protobuf:"varint,1,opt,name=Val,proto3" json:"Val,omitempty"`
|
|
Count int64 `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ValCount) Reset() { *m = ValCount{} }
|
|
func (m *ValCount) String() string { return proto.CompactTextString(m) }
|
|
func (*ValCount) ProtoMessage() {}
|
|
func (*ValCount) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{8}
|
|
}
|
|
func (m *ValCount) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ValCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ValCount.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ValCount) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ValCount.Merge(dst, src)
|
|
}
|
|
func (m *ValCount) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ValCount) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ValCount.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ValCount proto.InternalMessageInfo
|
|
|
|
func (m *ValCount) GetVal() int64 {
|
|
if m != nil {
|
|
return m.Val
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ValCount) GetCount() int64 {
|
|
if m != nil {
|
|
return m.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type ColumnAttrSet 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"`
|
|
Attrs []*Attr `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ColumnAttrSet) Reset() { *m = ColumnAttrSet{} }
|
|
func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) }
|
|
func (*ColumnAttrSet) ProtoMessage() {}
|
|
func (*ColumnAttrSet) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{9}
|
|
}
|
|
func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ColumnAttrSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ColumnAttrSet.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ColumnAttrSet) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ColumnAttrSet.Merge(dst, src)
|
|
}
|
|
func (m *ColumnAttrSet) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ColumnAttrSet) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ColumnAttrSet.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ColumnAttrSet proto.InternalMessageInfo
|
|
|
|
func (m *ColumnAttrSet) GetID() uint64 {
|
|
if m != nil {
|
|
return m.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ColumnAttrSet) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ColumnAttrSet) GetAttrs() []*Attr {
|
|
if m != nil {
|
|
return m.Attrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Attr struct {
|
|
Key string `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
|
|
Type uint64 `protobuf:"varint,2,opt,name=Type,proto3" json:"Type,omitempty"`
|
|
StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3" json:"StringValue,omitempty"`
|
|
IntValue int64 `protobuf:"varint,4,opt,name=IntValue,proto3" json:"IntValue,omitempty"`
|
|
BoolValue bool `protobuf:"varint,5,opt,name=BoolValue,proto3" json:"BoolValue,omitempty"`
|
|
FloatValue float64 `protobuf:"fixed64,6,opt,name=FloatValue,proto3" json:"FloatValue,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Attr) Reset() { *m = Attr{} }
|
|
func (m *Attr) String() string { return proto.CompactTextString(m) }
|
|
func (*Attr) ProtoMessage() {}
|
|
func (*Attr) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{10}
|
|
}
|
|
func (m *Attr) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Attr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Attr.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *Attr) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Attr.Merge(dst, src)
|
|
}
|
|
func (m *Attr) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Attr) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Attr.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Attr proto.InternalMessageInfo
|
|
|
|
func (m *Attr) GetKey() string {
|
|
if m != nil {
|
|
return m.Key
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Attr) GetType() uint64 {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Attr) GetStringValue() string {
|
|
if m != nil {
|
|
return m.StringValue
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Attr) GetIntValue() int64 {
|
|
if m != nil {
|
|
return m.IntValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Attr) GetBoolValue() bool {
|
|
if m != nil {
|
|
return m.BoolValue
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Attr) GetFloatValue() float64 {
|
|
if m != nil {
|
|
return m.FloatValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type AttrMap struct {
|
|
Attrs []*Attr `protobuf:"bytes,1,rep,name=Attrs" json:"Attrs,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *AttrMap) Reset() { *m = AttrMap{} }
|
|
func (m *AttrMap) String() string { return proto.CompactTextString(m) }
|
|
func (*AttrMap) ProtoMessage() {}
|
|
func (*AttrMap) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{11}
|
|
}
|
|
func (m *AttrMap) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *AttrMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_AttrMap.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *AttrMap) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_AttrMap.Merge(dst, src)
|
|
}
|
|
func (m *AttrMap) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *AttrMap) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_AttrMap.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_AttrMap proto.InternalMessageInfo
|
|
|
|
func (m *AttrMap) GetAttrs() []*Attr {
|
|
if m != nil {
|
|
return m.Attrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QueryRequest struct {
|
|
Query string `protobuf:"bytes,1,opt,name=Query,proto3" json:"Query,omitempty"`
|
|
Shards []uint64 `protobuf:"varint,2,rep,packed,name=Shards" json:"Shards,omitempty"`
|
|
ColumnAttrs bool `protobuf:"varint,3,opt,name=ColumnAttrs,proto3" json:"ColumnAttrs,omitempty"`
|
|
Remote bool `protobuf:"varint,5,opt,name=Remote,proto3" json:"Remote,omitempty"`
|
|
ExcludeRowAttrs bool `protobuf:"varint,6,opt,name=ExcludeRowAttrs,proto3" json:"ExcludeRowAttrs,omitempty"`
|
|
ExcludeColumns bool `protobuf:"varint,7,opt,name=ExcludeColumns,proto3" json:"ExcludeColumns,omitempty"`
|
|
EmbeddedData []*Row `protobuf:"bytes,8,rep,name=EmbeddedData" json:"EmbeddedData,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{12}
|
|
}
|
|
func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *QueryRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryRequest.Merge(dst, src)
|
|
}
|
|
func (m *QueryRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryRequest proto.InternalMessageInfo
|
|
|
|
func (m *QueryRequest) GetQuery() string {
|
|
if m != nil {
|
|
return m.Query
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *QueryRequest) GetShards() []uint64 {
|
|
if m != nil {
|
|
return m.Shards
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryRequest) GetColumnAttrs() bool {
|
|
if m != nil {
|
|
return m.ColumnAttrs
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryRequest) GetRemote() bool {
|
|
if m != nil {
|
|
return m.Remote
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryRequest) GetExcludeRowAttrs() bool {
|
|
if m != nil {
|
|
return m.ExcludeRowAttrs
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryRequest) GetExcludeColumns() bool {
|
|
if m != nil {
|
|
return m.ExcludeColumns
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryRequest) GetEmbeddedData() []*Row {
|
|
if m != nil {
|
|
return m.EmbeddedData
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QueryResponse struct {
|
|
Err string `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
|
|
Results []*QueryResult `protobuf:"bytes,2,rep,name=Results" json:"Results,omitempty"`
|
|
ColumnAttrSets []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets" json:"ColumnAttrSets,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{13}
|
|
}
|
|
func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryResponse.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *QueryResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryResponse.Merge(dst, src)
|
|
}
|
|
func (m *QueryResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryResponse proto.InternalMessageInfo
|
|
|
|
func (m *QueryResponse) GetErr() string {
|
|
if m != nil {
|
|
return m.Err
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *QueryResponse) GetResults() []*QueryResult {
|
|
if m != nil {
|
|
return m.Results
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResponse) GetColumnAttrSets() []*ColumnAttrSet {
|
|
if m != nil {
|
|
return m.ColumnAttrSets
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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"`
|
|
RowIdentifiers *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers" json:"RowIdentifiers,omitempty"`
|
|
SignedRow *SignedRow `protobuf:"bytes,10,opt,name=SignedRow" json:"SignedRow,omitempty"`
|
|
PairsField *PairsField `protobuf:"bytes,11,opt,name=PairsField" json:"PairsField,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{14}
|
|
}
|
|
func (m *QueryResult) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *QueryResult) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryResult.Merge(dst, src)
|
|
}
|
|
func (m *QueryResult) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryResult) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryResult.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryResult proto.InternalMessageInfo
|
|
|
|
func (m *QueryResult) GetType() uint32 {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryResult) GetRow() *Row {
|
|
if m != nil {
|
|
return m.Row
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetN() uint64 {
|
|
if m != nil {
|
|
return m.N
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryResult) GetPairs() []*Pair {
|
|
if m != nil {
|
|
return m.Pairs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetChanged() bool {
|
|
if m != nil {
|
|
return m.Changed
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryResult) GetValCount() *ValCount {
|
|
if m != nil {
|
|
return m.ValCount
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetRowIDs() []uint64 {
|
|
if m != nil {
|
|
return m.RowIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetGroupCounts() []*GroupCount {
|
|
if m != nil {
|
|
return m.GroupCounts
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetRowIdentifiers() *RowIdentifiers {
|
|
if m != nil {
|
|
return m.RowIdentifiers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetSignedRow() *SignedRow {
|
|
if m != nil {
|
|
return m.SignedRow
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *QueryResult) GetPairsField() *PairsField {
|
|
if m != nil {
|
|
return m.PairsField
|
|
}
|
|
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"`
|
|
Shard uint64 `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
|
|
RowIDs []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
|
|
ColumnIDs []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
|
|
RowKeys []string `protobuf:"bytes,7,rep,name=RowKeys" json:"RowKeys,omitempty"`
|
|
ColumnKeys []string `protobuf:"bytes,8,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
|
|
Timestamps []int64 `protobuf:"varint,6,rep,packed,name=Timestamps" json:"Timestamps,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{15}
|
|
}
|
|
func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ImportRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ImportRequest.Merge(dst, src)
|
|
}
|
|
func (m *ImportRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ImportRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ImportRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ImportRequest proto.InternalMessageInfo
|
|
|
|
func (m *ImportRequest) GetIndex() string {
|
|
if m != nil {
|
|
return m.Index
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportRequest) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportRequest) GetShard() uint64 {
|
|
if m != nil {
|
|
return m.Shard
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ImportRequest) GetRowIDs() []uint64 {
|
|
if m != nil {
|
|
return m.RowIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportRequest) GetColumnIDs() []uint64 {
|
|
if m != nil {
|
|
return m.ColumnIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportRequest) GetRowKeys() []string {
|
|
if m != nil {
|
|
return m.RowKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportRequest) GetColumnKeys() []string {
|
|
if m != nil {
|
|
return m.ColumnKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportRequest) GetTimestamps() []int64 {
|
|
if m != nil {
|
|
return m.Timestamps
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ImportValueRequest 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"`
|
|
Shard uint64 `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
|
|
ColumnIDs []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
|
|
ColumnKeys []string `protobuf:"bytes,7,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
|
|
Values []int64 `protobuf:"varint,6,rep,packed,name=Values" json:"Values,omitempty"`
|
|
FloatValues []float64 `protobuf:"fixed64,8,rep,packed,name=FloatValues" json:"FloatValues,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{16}
|
|
}
|
|
func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ImportValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ImportValueRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ImportValueRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ImportValueRequest.Merge(dst, src)
|
|
}
|
|
func (m *ImportValueRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ImportValueRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ImportValueRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ImportValueRequest proto.InternalMessageInfo
|
|
|
|
func (m *ImportValueRequest) GetIndex() string {
|
|
if m != nil {
|
|
return m.Index
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetShard() uint64 {
|
|
if m != nil {
|
|
return m.Shard
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetColumnIDs() []uint64 {
|
|
if m != nil {
|
|
return m.ColumnIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetColumnKeys() []string {
|
|
if m != nil {
|
|
return m.ColumnKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetValues() []int64 {
|
|
if m != nil {
|
|
return m.Values
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportValueRequest) GetFloatValues() []float64 {
|
|
if m != nil {
|
|
return m.FloatValues
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TranslateKeysRequest 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"`
|
|
Keys []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{17}
|
|
}
|
|
func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TranslateKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TranslateKeysRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *TranslateKeysRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TranslateKeysRequest.Merge(dst, src)
|
|
}
|
|
func (m *TranslateKeysRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TranslateKeysRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TranslateKeysRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TranslateKeysRequest proto.InternalMessageInfo
|
|
|
|
func (m *TranslateKeysRequest) GetIndex() string {
|
|
if m != nil {
|
|
return m.Index
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TranslateKeysRequest) GetField() string {
|
|
if m != nil {
|
|
return m.Field
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *TranslateKeysRequest) GetKeys() []string {
|
|
if m != nil {
|
|
return m.Keys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TranslateKeysResponse struct {
|
|
IDs []uint64 `protobuf:"varint,3,rep,packed,name=IDs" json:"IDs,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{18}
|
|
}
|
|
func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TranslateKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TranslateKeysResponse.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *TranslateKeysResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TranslateKeysResponse.Merge(dst, src)
|
|
}
|
|
func (m *TranslateKeysResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TranslateKeysResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TranslateKeysResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TranslateKeysResponse proto.InternalMessageInfo
|
|
|
|
func (m *TranslateKeysResponse) GetIDs() []uint64 {
|
|
if m != nil {
|
|
return m.IDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ImportRoaringRequestView struct {
|
|
Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
|
|
Data []byte `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ImportRoaringRequestView) Reset() { *m = ImportRoaringRequestView{} }
|
|
func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) }
|
|
func (*ImportRoaringRequestView) ProtoMessage() {}
|
|
func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{19}
|
|
}
|
|
func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ImportRoaringRequestView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ImportRoaringRequestView.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ImportRoaringRequestView.Merge(dst, src)
|
|
}
|
|
func (m *ImportRoaringRequestView) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ImportRoaringRequestView) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ImportRoaringRequestView.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ImportRoaringRequestView proto.InternalMessageInfo
|
|
|
|
func (m *ImportRoaringRequestView) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportRoaringRequestView) GetData() []byte {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ImportRoaringRequest struct {
|
|
Clear bool `protobuf:"varint,1,opt,name=Clear,proto3" json:"Clear,omitempty"`
|
|
Views []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views" json:"views,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
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_public_48374b395a722341, []int{20}
|
|
}
|
|
func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ImportRoaringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ImportRoaringRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ImportRoaringRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ImportRoaringRequest.Merge(dst, src)
|
|
}
|
|
func (m *ImportRoaringRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ImportRoaringRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ImportRoaringRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ImportRoaringRequest proto.InternalMessageInfo
|
|
|
|
func (m *ImportRoaringRequest) GetClear() bool {
|
|
if m != nil {
|
|
return m.Clear
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ImportRoaringRequest) GetViews() []*ImportRoaringRequestView {
|
|
if m != nil {
|
|
return m.Views
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ImportColumnAttrsRequest struct {
|
|
Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
|
|
Shard int64 `protobuf:"varint,2,opt,name=Shard,proto3" json:"Shard,omitempty"`
|
|
AttrKey string `protobuf:"bytes,3,opt,name=AttrKey,proto3" json:"AttrKey,omitempty"`
|
|
AttrVals []string `protobuf:"bytes,4,rep,name=AttrVals" json:"AttrVals,omitempty"`
|
|
ColumnIDs []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) Reset() { *m = ImportColumnAttrsRequest{} }
|
|
func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*ImportColumnAttrsRequest) ProtoMessage() {}
|
|
func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_public_48374b395a722341, []int{21}
|
|
}
|
|
func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ImportColumnAttrsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ImportColumnAttrsRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalTo(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (dst *ImportColumnAttrsRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ImportColumnAttrsRequest.Merge(dst, src)
|
|
}
|
|
func (m *ImportColumnAttrsRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ImportColumnAttrsRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ImportColumnAttrsRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ImportColumnAttrsRequest proto.InternalMessageInfo
|
|
|
|
func (m *ImportColumnAttrsRequest) GetIndex() string {
|
|
if m != nil {
|
|
return m.Index
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) GetShard() int64 {
|
|
if m != nil {
|
|
return m.Shard
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) GetAttrKey() string {
|
|
if m != nil {
|
|
return m.AttrKey
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) GetAttrVals() []string {
|
|
if m != nil {
|
|
return m.AttrVals
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) GetColumnIDs() []uint64 {
|
|
if m != nil {
|
|
return m.ColumnIDs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*Row)(nil), "internal.Row")
|
|
proto.RegisterType((*SignedRow)(nil), "internal.SignedRow")
|
|
proto.RegisterType((*RowIdentifiers)(nil), "internal.RowIdentifiers")
|
|
proto.RegisterType((*Pair)(nil), "internal.Pair")
|
|
proto.RegisterType((*PairField)(nil), "internal.PairField")
|
|
proto.RegisterType((*PairsField)(nil), "internal.PairsField")
|
|
proto.RegisterType((*FieldRow)(nil), "internal.FieldRow")
|
|
proto.RegisterType((*GroupCount)(nil), "internal.GroupCount")
|
|
proto.RegisterType((*ValCount)(nil), "internal.ValCount")
|
|
proto.RegisterType((*ColumnAttrSet)(nil), "internal.ColumnAttrSet")
|
|
proto.RegisterType((*Attr)(nil), "internal.Attr")
|
|
proto.RegisterType((*AttrMap)(nil), "internal.AttrMap")
|
|
proto.RegisterType((*QueryRequest)(nil), "internal.QueryRequest")
|
|
proto.RegisterType((*QueryResponse)(nil), "internal.QueryResponse")
|
|
proto.RegisterType((*QueryResult)(nil), "internal.QueryResult")
|
|
proto.RegisterType((*ImportRequest)(nil), "internal.ImportRequest")
|
|
proto.RegisterType((*ImportValueRequest)(nil), "internal.ImportValueRequest")
|
|
proto.RegisterType((*TranslateKeysRequest)(nil), "internal.TranslateKeysRequest")
|
|
proto.RegisterType((*TranslateKeysResponse)(nil), "internal.TranslateKeysResponse")
|
|
proto.RegisterType((*ImportRoaringRequestView)(nil), "internal.ImportRoaringRequestView")
|
|
proto.RegisterType((*ImportRoaringRequest)(nil), "internal.ImportRoaringRequest")
|
|
proto.RegisterType((*ImportColumnAttrsRequest)(nil), "internal.ImportColumnAttrsRequest")
|
|
}
|
|
func (m *Row) 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 *Row) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Columns) > 0 {
|
|
dAtA2 := make([]byte, len(m.Columns)*10)
|
|
var j1 int
|
|
for _, num := range m.Columns {
|
|
for num >= 1<<7 {
|
|
dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j1++
|
|
}
|
|
dAtA2[j1] = uint8(num)
|
|
j1++
|
|
}
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j1))
|
|
i += copy(dAtA[i:], dAtA2[:j1])
|
|
}
|
|
if len(m.Attrs) > 0 {
|
|
for _, msg := range m.Attrs {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.Keys) > 0 {
|
|
for _, s := range m.Keys {
|
|
dAtA[i] = 0x1a
|
|
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)
|
|
}
|
|
}
|
|
if len(m.Roaring) > 0 {
|
|
dAtA[i] = 0x22
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Roaring)))
|
|
i += copy(dAtA[i:], m.Roaring)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *SignedRow) 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 *SignedRow) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Pos != nil {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Pos.Size()))
|
|
n3, err := m.Pos.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n3
|
|
}
|
|
if m.Neg != nil {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Neg.Size()))
|
|
n4, err := m.Neg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n4
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
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 {
|
|
dAtA6 := make([]byte, len(m.Rows)*10)
|
|
var j5 int
|
|
for _, num := range m.Rows {
|
|
for num >= 1<<7 {
|
|
dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j5++
|
|
}
|
|
dAtA6[j5] = uint8(num)
|
|
j5++
|
|
}
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j5))
|
|
i += copy(dAtA[i:], dAtA6[:j5])
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *Pair) 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 *Pair) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.ID != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.ID))
|
|
}
|
|
if m.Count != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Count))
|
|
}
|
|
if len(m.Key) > 0 {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
|
|
i += copy(dAtA[i:], m.Key)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *PairField) 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 *PairField) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Pair != nil {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Pair.Size()))
|
|
n7, err := m.Pair.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n7
|
|
}
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *PairsField) 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 *PairsField) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Pairs) > 0 {
|
|
for _, msg := range m.Pairs {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *FieldRow) 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 *FieldRow) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if m.RowID != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.RowID))
|
|
}
|
|
if len(m.RowKey) > 0 {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKey)))
|
|
i += copy(dAtA[i:], m.RowKey)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *GroupCount) 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 *GroupCount) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Group) > 0 {
|
|
for _, msg := range m.Group {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.Count != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Count))
|
|
}
|
|
if m.Sum != 0 {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Sum))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ValCount) 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 *ValCount) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Val != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Val))
|
|
}
|
|
if m.Count != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Count))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ColumnAttrSet) 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 *ColumnAttrSet) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.ID != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.ID))
|
|
}
|
|
if len(m.Attrs) > 0 {
|
|
for _, msg := range m.Attrs {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.Key) > 0 {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
|
|
i += copy(dAtA[i:], m.Key)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *Attr) 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 *Attr) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Key) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
|
|
i += copy(dAtA[i:], m.Key)
|
|
}
|
|
if m.Type != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Type))
|
|
}
|
|
if len(m.StringValue) > 0 {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValue)))
|
|
i += copy(dAtA[i:], m.StringValue)
|
|
}
|
|
if m.IntValue != 0 {
|
|
dAtA[i] = 0x20
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.IntValue))
|
|
}
|
|
if m.BoolValue {
|
|
dAtA[i] = 0x28
|
|
i++
|
|
if m.BoolValue {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.FloatValue != 0 {
|
|
dAtA[i] = 0x31
|
|
i++
|
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
|
|
i += 8
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *AttrMap) 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 *AttrMap) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Attrs) > 0 {
|
|
for _, msg := range m.Attrs {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *QueryRequest) 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 *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Query) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Query)))
|
|
i += copy(dAtA[i:], m.Query)
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
dAtA9 := make([]byte, len(m.Shards)*10)
|
|
var j8 int
|
|
for _, num := range m.Shards {
|
|
for num >= 1<<7 {
|
|
dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j8++
|
|
}
|
|
dAtA9[j8] = uint8(num)
|
|
j8++
|
|
}
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j8))
|
|
i += copy(dAtA[i:], dAtA9[:j8])
|
|
}
|
|
if m.ColumnAttrs {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
if m.ColumnAttrs {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.Remote {
|
|
dAtA[i] = 0x28
|
|
i++
|
|
if m.Remote {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.ExcludeRowAttrs {
|
|
dAtA[i] = 0x30
|
|
i++
|
|
if m.ExcludeRowAttrs {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.ExcludeColumns {
|
|
dAtA[i] = 0x38
|
|
i++
|
|
if m.ExcludeColumns {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.EmbeddedData) > 0 {
|
|
for _, msg := range m.EmbeddedData {
|
|
dAtA[i] = 0x42
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *QueryResponse) 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 *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Err) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Err)))
|
|
i += copy(dAtA[i:], m.Err)
|
|
}
|
|
if len(m.Results) > 0 {
|
|
for _, msg := range m.Results {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.ColumnAttrSets) > 0 {
|
|
for _, msg := range m.ColumnAttrSets {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *QueryResult) 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 *QueryResult) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Row != nil {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Row.Size()))
|
|
n10, err := m.Row.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n10
|
|
}
|
|
if m.N != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.N))
|
|
}
|
|
if len(m.Pairs) > 0 {
|
|
for _, msg := range m.Pairs {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.Changed {
|
|
dAtA[i] = 0x20
|
|
i++
|
|
if m.Changed {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.ValCount != nil {
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.ValCount.Size()))
|
|
n11, err := m.ValCount.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n11
|
|
}
|
|
if m.Type != 0 {
|
|
dAtA[i] = 0x30
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Type))
|
|
}
|
|
if len(m.RowIDs) > 0 {
|
|
dAtA13 := make([]byte, len(m.RowIDs)*10)
|
|
var j12 int
|
|
for _, num := range m.RowIDs {
|
|
for num >= 1<<7 {
|
|
dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j12++
|
|
}
|
|
dAtA13[j12] = uint8(num)
|
|
j12++
|
|
}
|
|
dAtA[i] = 0x3a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j12))
|
|
i += copy(dAtA[i:], dAtA13[:j12])
|
|
}
|
|
if len(m.GroupCounts) > 0 {
|
|
for _, msg := range m.GroupCounts {
|
|
dAtA[i] = 0x42
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.RowIdentifiers != nil {
|
|
dAtA[i] = 0x4a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.RowIdentifiers.Size()))
|
|
n14, err := m.RowIdentifiers.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n14
|
|
}
|
|
if m.SignedRow != nil {
|
|
dAtA[i] = 0x52
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.SignedRow.Size()))
|
|
n15, err := m.SignedRow.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n15
|
|
}
|
|
if m.PairsField != nil {
|
|
dAtA[i] = 0x5a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.PairsField.Size()))
|
|
n16, err := m.PairsField.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n16
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ImportRequest) 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 *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Index) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
|
|
i += copy(dAtA[i:], m.Index)
|
|
}
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if m.Shard != 0 {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
|
|
}
|
|
if len(m.RowIDs) > 0 {
|
|
dAtA18 := make([]byte, len(m.RowIDs)*10)
|
|
var j17 int
|
|
for _, num := range m.RowIDs {
|
|
for num >= 1<<7 {
|
|
dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j17++
|
|
}
|
|
dAtA18[j17] = uint8(num)
|
|
j17++
|
|
}
|
|
dAtA[i] = 0x22
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j17))
|
|
i += copy(dAtA[i:], dAtA18[:j17])
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
dAtA20 := make([]byte, len(m.ColumnIDs)*10)
|
|
var j19 int
|
|
for _, num := range m.ColumnIDs {
|
|
for num >= 1<<7 {
|
|
dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j19++
|
|
}
|
|
dAtA20[j19] = uint8(num)
|
|
j19++
|
|
}
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j19))
|
|
i += copy(dAtA[i:], dAtA20[:j19])
|
|
}
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA22 := make([]byte, len(m.Timestamps)*10)
|
|
var j21 int
|
|
for _, num1 := range m.Timestamps {
|
|
num := uint64(num1)
|
|
for num >= 1<<7 {
|
|
dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j21++
|
|
}
|
|
dAtA22[j21] = uint8(num)
|
|
j21++
|
|
}
|
|
dAtA[i] = 0x32
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j21))
|
|
i += copy(dAtA[i:], dAtA22[:j21])
|
|
}
|
|
if len(m.RowKeys) > 0 {
|
|
for _, s := range m.RowKeys {
|
|
dAtA[i] = 0x3a
|
|
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)
|
|
}
|
|
}
|
|
if len(m.ColumnKeys) > 0 {
|
|
for _, s := range m.ColumnKeys {
|
|
dAtA[i] = 0x42
|
|
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)
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ImportValueRequest) 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 *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Index) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
|
|
i += copy(dAtA[i:], m.Index)
|
|
}
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if m.Shard != 0 {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
dAtA24 := make([]byte, len(m.ColumnIDs)*10)
|
|
var j23 int
|
|
for _, num := range m.ColumnIDs {
|
|
for num >= 1<<7 {
|
|
dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j23++
|
|
}
|
|
dAtA24[j23] = uint8(num)
|
|
j23++
|
|
}
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j23))
|
|
i += copy(dAtA[i:], dAtA24[:j23])
|
|
}
|
|
if len(m.Values) > 0 {
|
|
dAtA26 := make([]byte, len(m.Values)*10)
|
|
var j25 int
|
|
for _, num1 := range m.Values {
|
|
num := uint64(num1)
|
|
for num >= 1<<7 {
|
|
dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j25++
|
|
}
|
|
dAtA26[j25] = uint8(num)
|
|
j25++
|
|
}
|
|
dAtA[i] = 0x32
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j25))
|
|
i += copy(dAtA[i:], dAtA26[:j25])
|
|
}
|
|
if len(m.ColumnKeys) > 0 {
|
|
for _, s := range m.ColumnKeys {
|
|
dAtA[i] = 0x3a
|
|
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)
|
|
}
|
|
}
|
|
if len(m.FloatValues) > 0 {
|
|
dAtA[i] = 0x42
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
|
|
for _, num := range m.FloatValues {
|
|
f27 := math.Float64bits(float64(num))
|
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f27))
|
|
i += 8
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TranslateKeysRequest) 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 *TranslateKeysRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Index) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
|
|
i += copy(dAtA[i:], m.Index)
|
|
}
|
|
if len(m.Field) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
|
|
i += copy(dAtA[i:], m.Field)
|
|
}
|
|
if len(m.Keys) > 0 {
|
|
for _, s := range m.Keys {
|
|
dAtA[i] = 0x1a
|
|
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)
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TranslateKeysResponse) 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 *TranslateKeysResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.IDs) > 0 {
|
|
dAtA29 := make([]byte, len(m.IDs)*10)
|
|
var j28 int
|
|
for _, num := range m.IDs {
|
|
for num >= 1<<7 {
|
|
dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j28++
|
|
}
|
|
dAtA29[j28] = uint8(num)
|
|
j28++
|
|
}
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j28))
|
|
i += copy(dAtA[i:], dAtA29[:j28])
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ImportRoaringRequestView) 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 *ImportRoaringRequestView) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Name) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
|
|
i += copy(dAtA[i:], m.Name)
|
|
}
|
|
if len(m.Data) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Data)))
|
|
i += copy(dAtA[i:], m.Data)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ImportRoaringRequest) 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 *ImportRoaringRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Clear {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
if m.Clear {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.Views) > 0 {
|
|
for _, msg := range m.Views {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) 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 *ImportColumnAttrsRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Index) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
|
|
i += copy(dAtA[i:], m.Index)
|
|
}
|
|
if m.Shard != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
|
|
}
|
|
if len(m.AttrKey) > 0 {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrKey)))
|
|
i += copy(dAtA[i:], m.AttrKey)
|
|
}
|
|
if len(m.AttrVals) > 0 {
|
|
for _, s := range m.AttrVals {
|
|
dAtA[i] = 0x22
|
|
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)
|
|
}
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
dAtA31 := make([]byte, len(m.ColumnIDs)*10)
|
|
var j30 int
|
|
for _, num := range m.ColumnIDs {
|
|
for num >= 1<<7 {
|
|
dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j30++
|
|
}
|
|
dAtA31[j30] = uint8(num)
|
|
j30++
|
|
}
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintPublic(dAtA, i, uint64(j30))
|
|
i += copy(dAtA[i:], dAtA31[:j30])
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(dAtA[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeVarintPublic(dAtA []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|
|
func (m *Row) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Columns) > 0 {
|
|
l = 0
|
|
for _, e := range m.Columns {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.Attrs) > 0 {
|
|
for _, e := range m.Attrs {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Keys) > 0 {
|
|
for _, s := range m.Keys {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.Roaring)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SignedRow) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Pos != nil {
|
|
l = m.Pos.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Neg != nil {
|
|
l = m.Neg.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *RowIdentifiers) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
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))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Pair) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ID != 0 {
|
|
n += 1 + sovPublic(uint64(m.ID))
|
|
}
|
|
if m.Count != 0 {
|
|
n += 1 + sovPublic(uint64(m.Count))
|
|
}
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PairField) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Pair != nil {
|
|
l = m.Pair.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PairsField) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Pairs) > 0 {
|
|
for _, e := range m.Pairs {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *FieldRow) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.RowID != 0 {
|
|
n += 1 + sovPublic(uint64(m.RowID))
|
|
}
|
|
l = len(m.RowKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GroupCount) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Group) > 0 {
|
|
for _, e := range m.Group {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.Count != 0 {
|
|
n += 1 + sovPublic(uint64(m.Count))
|
|
}
|
|
if m.Sum != 0 {
|
|
n += 1 + sovPublic(uint64(m.Sum))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ValCount) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Val != 0 {
|
|
n += 1 + sovPublic(uint64(m.Val))
|
|
}
|
|
if m.Count != 0 {
|
|
n += 1 + sovPublic(uint64(m.Count))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ColumnAttrSet) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ID != 0 {
|
|
n += 1 + sovPublic(uint64(m.ID))
|
|
}
|
|
if len(m.Attrs) > 0 {
|
|
for _, e := range m.Attrs {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Attr) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Type != 0 {
|
|
n += 1 + sovPublic(uint64(m.Type))
|
|
}
|
|
l = len(m.StringValue)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.IntValue != 0 {
|
|
n += 1 + sovPublic(uint64(m.IntValue))
|
|
}
|
|
if m.BoolValue {
|
|
n += 2
|
|
}
|
|
if m.FloatValue != 0 {
|
|
n += 9
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *AttrMap) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Attrs) > 0 {
|
|
for _, e := range m.Attrs {
|
|
l = e.Size()
|
|
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
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Query)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if len(m.Shards) > 0 {
|
|
l = 0
|
|
for _, e := range m.Shards {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if m.ColumnAttrs {
|
|
n += 2
|
|
}
|
|
if m.Remote {
|
|
n += 2
|
|
}
|
|
if m.ExcludeRowAttrs {
|
|
n += 2
|
|
}
|
|
if m.ExcludeColumns {
|
|
n += 2
|
|
}
|
|
if len(m.EmbeddedData) > 0 {
|
|
for _, e := range m.EmbeddedData {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Err)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if len(m.Results) > 0 {
|
|
for _, e := range m.Results {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if len(m.ColumnAttrSets) > 0 {
|
|
for _, e := range m.ColumnAttrSets {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryResult) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Row != nil {
|
|
l = m.Row.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.N != 0 {
|
|
n += 1 + sovPublic(uint64(m.N))
|
|
}
|
|
if len(m.Pairs) > 0 {
|
|
for _, e := range m.Pairs {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.Changed {
|
|
n += 2
|
|
}
|
|
if m.ValCount != nil {
|
|
l = m.ValCount.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Type != 0 {
|
|
n += 1 + sovPublic(uint64(m.Type))
|
|
}
|
|
if len(m.RowIDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.RowIDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.GroupCounts) > 0 {
|
|
for _, e := range m.GroupCounts {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.RowIdentifiers != nil {
|
|
l = m.RowIdentifiers.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.SignedRow != nil {
|
|
l = m.SignedRow.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.PairsField != nil {
|
|
l = m.PairsField.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ImportRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Index)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Shard != 0 {
|
|
n += 1 + sovPublic(uint64(m.Shard))
|
|
}
|
|
if len(m.RowIDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.RowIDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.ColumnIDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.Timestamps) > 0 {
|
|
l = 0
|
|
for _, e := range m.Timestamps {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.RowKeys) > 0 {
|
|
for _, s := range m.RowKeys {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if len(m.ColumnKeys) > 0 {
|
|
for _, s := range m.ColumnKeys {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ImportValueRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Index)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Shard != 0 {
|
|
n += 1 + sovPublic(uint64(m.Shard))
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.ColumnIDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.Values) > 0 {
|
|
l = 0
|
|
for _, e := range m.Values {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if len(m.ColumnKeys) > 0 {
|
|
for _, s := range m.ColumnKeys {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if len(m.FloatValues) > 0 {
|
|
n += 1 + sovPublic(uint64(len(m.FloatValues)*8)) + len(m.FloatValues)*8
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TranslateKeysRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Index)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
l = len(m.Field)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if len(m.Keys) > 0 {
|
|
for _, s := range m.Keys {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TranslateKeysResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.IDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.IDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ImportRoaringRequestView) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
l = len(m.Data)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ImportRoaringRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Clear {
|
|
n += 2
|
|
}
|
|
if len(m.Views) > 0 {
|
|
for _, e := range m.Views {
|
|
l = e.Size()
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ImportColumnAttrsRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Index)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if m.Shard != 0 {
|
|
n += 1 + sovPublic(uint64(m.Shard))
|
|
}
|
|
l = len(m.AttrKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
if len(m.AttrVals) > 0 {
|
|
for _, s := range m.AttrVals {
|
|
l = len(s)
|
|
n += 1 + l + sovPublic(uint64(l))
|
|
}
|
|
}
|
|
if len(m.ColumnIDs) > 0 {
|
|
l = 0
|
|
for _, e := range m.ColumnIDs {
|
|
l += sovPublic(uint64(e))
|
|
}
|
|
n += 1 + sovPublic(uint64(l)) + l
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovPublic(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozPublic(x uint64) (n int) {
|
|
return sovPublic(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *Row) 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: Row: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Row: 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.Columns = append(m.Columns, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.Columns) == 0 {
|
|
m.Columns = make([]uint64, 0, elementCount)
|
|
}
|
|
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.Columns = append(m.Columns, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
|
|
}
|
|
m.Attrs = append(m.Attrs, &Attr{})
|
|
if err := m.Attrs[len(m.Attrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
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
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Roaring", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthPublic
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Roaring = append(m.Roaring[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Roaring == nil {
|
|
m.Roaring = []byte{}
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *SignedRow) 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: SignedRow: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SignedRow: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Pos", 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.Pos == nil {
|
|
m.Pos = &Row{}
|
|
}
|
|
if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Neg", 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.Neg == nil {
|
|
m.Neg = &Row{}
|
|
}
|
|
if err := m.Neg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.Rows) == 0 {
|
|
m.Rows = make([]uint64, 0, elementCount)
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Pair) 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: Pair: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Pair: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
|
|
}
|
|
m.ID = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.ID |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
|
|
}
|
|
m.Count = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *PairField) 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: PairField: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: PairField: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Pair", 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.Pair == nil {
|
|
m.Pair = &Pair{}
|
|
}
|
|
if err := m.Pair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *PairsField) 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: PairsField: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: PairsField: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Pairs", 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
|
|
}
|
|
m.Pairs = append(m.Pairs, &Pair{})
|
|
if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *FieldRow) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
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: FieldRow: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: FieldRow: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowID", wireType)
|
|
}
|
|
m.RowID = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.RowID |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowKey", 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.RowKey = 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *GroupCount) 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: GroupCount: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GroupCount: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Group", 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
|
|
}
|
|
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 Count", wireType)
|
|
}
|
|
m.Count = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
|
|
}
|
|
m.Sum = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Sum |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipPublic(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthPublic
|
|
}
|
|
if (iNdEx + skippy) > 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 *ValCount) 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: ValCount: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ValCount: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Val", wireType)
|
|
}
|
|
m.Val = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Val |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
|
|
}
|
|
m.Count = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Count |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipPublic(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthPublic
|
|
}
|
|
if (iNdEx + skippy) > 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 *ColumnAttrSet) 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: ColumnAttrSet: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ColumnAttrSet: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
|
|
}
|
|
m.ID = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.ID |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
|
|
}
|
|
m.Attrs = append(m.Attrs, &Attr{})
|
|
if err := m.Attrs[len(m.Attrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Attr) 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: Attr: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Attr: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StringValue", 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.StringValue = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType)
|
|
}
|
|
m.IntValue = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.IntValue |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.BoolValue = bool(v != 0)
|
|
case 6:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field FloatValue", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
|
|
iNdEx += 8
|
|
m.FloatValue = float64(math.Float64frombits(v))
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *AttrMap) 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: AttrMap: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: AttrMap: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
|
|
}
|
|
m.Attrs = append(m.Attrs, &Attr{})
|
|
if err := m.Attrs[len(m.Attrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
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
|
|
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: QueryRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Query", 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.Query = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
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.Shards = append(m.Shards, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.Shards) == 0 {
|
|
m.Shards = make([]uint64, 0, elementCount)
|
|
}
|
|
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.Shards = append(m.Shards, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnAttrs", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.ColumnAttrs = bool(v != 0)
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Remote = bool(v != 0)
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ExcludeRowAttrs", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.ExcludeRowAttrs = bool(v != 0)
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ExcludeColumns", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.ExcludeColumns = bool(v != 0)
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EmbeddedData", 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
|
|
}
|
|
m.EmbeddedData = append(m.EmbeddedData, &Row{})
|
|
if err := m.EmbeddedData[len(m.EmbeddedData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryResponse) 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: QueryResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Err", 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.Err = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Results", 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
|
|
}
|
|
m.Results = append(m.Results, &QueryResult{})
|
|
if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnAttrSets", 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
|
|
}
|
|
m.ColumnAttrSets = append(m.ColumnAttrSets, &ColumnAttrSet{})
|
|
if err := m.ColumnAttrSets[len(m.ColumnAttrSets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryResult) 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: QueryResult: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryResult: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Row", 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.Row == nil {
|
|
m.Row = &Row{}
|
|
}
|
|
if err := m.Row.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field N", wireType)
|
|
}
|
|
m.N = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.N |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Pairs", 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
|
|
}
|
|
m.Pairs = append(m.Pairs, &Pair{})
|
|
if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Changed", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Changed = bool(v != 0)
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ValCount", 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.ValCount == nil {
|
|
m.ValCount = &ValCount{}
|
|
}
|
|
if err := m.ValCount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (uint32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
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.RowIDs = append(m.RowIDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.RowIDs) == 0 {
|
|
m.RowIDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.RowIDs = append(m.RowIDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowIDs", wireType)
|
|
}
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field GroupCounts", 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
|
|
}
|
|
m.GroupCounts = append(m.GroupCounts, &GroupCount{})
|
|
if err := m.GroupCounts[len(m.GroupCounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
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
|
|
case 10:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field SignedRow", 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.SignedRow == nil {
|
|
m.SignedRow = &SignedRow{}
|
|
}
|
|
if err := m.SignedRow.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 11:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field PairsField", 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.PairsField == nil {
|
|
m.PairsField = &PairsField{}
|
|
}
|
|
if err := m.PairsField.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ImportRequest) 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: ImportRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ImportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
|
|
}
|
|
m.Shard = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Shard |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
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.RowIDs = append(m.RowIDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.RowIDs) == 0 {
|
|
m.RowIDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.RowIDs = append(m.RowIDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowIDs", wireType)
|
|
}
|
|
case 5:
|
|
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.ColumnIDs = append(m.ColumnIDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.ColumnIDs) == 0 {
|
|
m.ColumnIDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.ColumnIDs = append(m.ColumnIDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
|
|
}
|
|
case 6:
|
|
if wireType == 0 {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Timestamps = append(m.Timestamps, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.Timestamps) == 0 {
|
|
m.Timestamps = make([]int64, 0, elementCount)
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowKeys", 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.RowKeys = append(m.RowKeys, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnKeys", 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.ColumnKeys = append(m.ColumnKeys, 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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ImportValueRequest) 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: ImportValueRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ImportValueRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
|
|
}
|
|
m.Shard = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Shard |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
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.ColumnIDs = append(m.ColumnIDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.ColumnIDs) == 0 {
|
|
m.ColumnIDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.ColumnIDs = append(m.ColumnIDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
|
|
}
|
|
case 6:
|
|
if wireType == 0 {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.Values) == 0 {
|
|
m.Values = make([]int64, 0, elementCount)
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnKeys", 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.ColumnKeys = append(m.ColumnKeys, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 8:
|
|
if wireType == 1 {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
|
|
iNdEx += 8
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.FloatValues = append(m.FloatValues, v2)
|
|
} 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
|
|
}
|
|
var elementCount int
|
|
elementCount = packedLen / 8
|
|
if elementCount != 0 && len(m.FloatValues) == 0 {
|
|
m.FloatValues = make([]float64, 0, elementCount)
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
|
|
iNdEx += 8
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.FloatValues = append(m.FloatValues, v2)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field FloatValues", wireType)
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TranslateKeysRequest) 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: TranslateKeysRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TranslateKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field", 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.Field = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TranslateKeysResponse) 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: TranslateKeysResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TranslateKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 3:
|
|
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.IDs = append(m.IDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.IDs) == 0 {
|
|
m.IDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.IDs = append(m.IDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field IDs", wireType)
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ImportRoaringRequestView) 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: ImportRoaringRequestView: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ImportRoaringRequestView: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
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 > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Name = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthPublic
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Data == nil {
|
|
m.Data = []byte{}
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ImportRoaringRequest) 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: ImportRoaringRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ImportRoaringRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Clear", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Clear = bool(v != 0)
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Views", 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
|
|
}
|
|
m.Views = append(m.Views, &ImportRoaringRequestView{})
|
|
if err := m.Views[len(m.Views)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ImportColumnAttrsRequest) 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: ImportColumnAttrsRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ImportColumnAttrsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
|
|
}
|
|
m.Shard = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Shard |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AttrKey", 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.AttrKey = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AttrVals", 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.AttrVals = append(m.AttrVals, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 5:
|
|
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.ColumnIDs = append(m.ColumnIDs, 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
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.ColumnIDs) == 0 {
|
|
m.ColumnIDs = make([]uint64, 0, elementCount)
|
|
}
|
|
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.ColumnIDs = append(m.ColumnIDs, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
|
|
}
|
|
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
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipPublic(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx += length
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthPublic
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowPublic
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipPublic(dAtA[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthPublic = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowPublic = fmt.Errorf("proto: integer overflow")
|
|
)
|
|
|
|
func init() { proto.RegisterFile("public.proto", fileDescriptor_public_48374b395a722341) }
|
|
|
|
var fileDescriptor_public_48374b395a722341 = []byte{
|
|
// 1065 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdb, 0x6e, 0x1c, 0x45,
|
|
0x13, 0xfe, 0x7b, 0x67, 0xd6, 0xbb, 0x5b, 0x6b, 0xfb, 0x8f, 0x9a, 0x4d, 0x18, 0xa1, 0xc8, 0xac,
|
|
0x5a, 0x11, 0x1a, 0x6e, 0x1c, 0xc5, 0x20, 0x94, 0x2b, 0x0e, 0x8e, 0x1d, 0x58, 0x45, 0x59, 0x85,
|
|
0xb2, 0xb5, 0xdc, 0x21, 0x8d, 0xb3, 0x1d, 0x67, 0xa4, 0xd9, 0x99, 0x65, 0x0e, 0x4c, 0xfc, 0x1c,
|
|
0xdc, 0x20, 0x9e, 0x80, 0x77, 0xe0, 0x05, 0xb8, 0x42, 0x3c, 0x02, 0x98, 0xc7, 0xe0, 0x06, 0x55,
|
|
0xf5, 0xf4, 0xf6, 0xec, 0xfa, 0x00, 0x42, 0xdc, 0xf5, 0x57, 0xa7, 0xa9, 0xaa, 0xae, 0xfa, 0x7a,
|
|
0x60, 0x7b, 0x59, 0x9d, 0x25, 0xf1, 0xcb, 0xfd, 0x65, 0x9e, 0x95, 0x99, 0xec, 0xc7, 0x69, 0xa9,
|
|
0xf3, 0x34, 0x4a, 0x54, 0x01, 0x1e, 0x66, 0xb5, 0x0c, 0xa0, 0xf7, 0x24, 0x4b, 0xaa, 0x45, 0x5a,
|
|
0x04, 0x62, 0xec, 0x85, 0x3e, 0x5a, 0x28, 0x1f, 0x40, 0xf7, 0xb3, 0xb2, 0xcc, 0x8b, 0xa0, 0x33,
|
|
0xf6, 0xc2, 0xe1, 0xc1, 0xee, 0xbe, 0x75, 0xdd, 0x27, 0x31, 0x1a, 0xa5, 0x94, 0xe0, 0x3f, 0xd3,
|
|
0x17, 0x45, 0xe0, 0x8d, 0xbd, 0x70, 0x80, 0x7c, 0xa6, 0x98, 0x98, 0x45, 0x79, 0x9c, 0x9e, 0x07,
|
|
0xfe, 0x58, 0x84, 0xdb, 0x68, 0xa1, 0x7a, 0x0e, 0x83, 0x93, 0xf8, 0x3c, 0xd5, 0x73, 0xfa, 0xf4,
|
|
0xbb, 0xe0, 0xbd, 0xc8, 0xe8, 0xb3, 0x22, 0x1c, 0x1e, 0xec, 0xb8, 0xf0, 0x98, 0xd5, 0x48, 0x1a,
|
|
0x32, 0x98, 0xea, 0xf3, 0xa0, 0x73, 0xad, 0xc1, 0x54, 0x9f, 0xab, 0xc7, 0xb0, 0x8b, 0x59, 0x3d,
|
|
0x99, 0xeb, 0xb4, 0x8c, 0x5f, 0xc5, 0xda, 0xa4, 0x83, 0x59, 0x6d, 0x6b, 0xe1, 0xf3, 0x2a, 0xc5,
|
|
0x8e, 0x4b, 0x51, 0x7d, 0x0c, 0xfe, 0x8b, 0x28, 0xce, 0xe5, 0x2e, 0x74, 0x26, 0x47, 0x9c, 0x82,
|
|
0x8f, 0x9d, 0xc9, 0x91, 0x1c, 0x41, 0xf7, 0x49, 0x56, 0xa5, 0x25, 0x7f, 0xd4, 0x47, 0x03, 0xe4,
|
|
0x1d, 0xf0, 0x9e, 0xe9, 0x8b, 0xc0, 0x1b, 0x8b, 0x70, 0x80, 0x74, 0x54, 0xc7, 0x30, 0x20, 0xff,
|
|
0xa7, 0xb1, 0x4e, 0xe6, 0x52, 0x99, 0x60, 0x4d, 0x25, 0xad, 0x46, 0x91, 0x14, 0xcd, 0x87, 0x46,
|
|
0xd0, 0x65, 0x63, 0x0e, 0x3c, 0x40, 0x03, 0xd4, 0x17, 0x00, 0xa4, 0x2d, 0x4c, 0x9c, 0x07, 0xd0,
|
|
0x65, 0xc4, 0xd9, 0x5f, 0x0d, 0x64, 0x94, 0x37, 0x44, 0x9a, 0x42, 0x9f, 0x0f, 0xd4, 0xd8, 0x95,
|
|
0x85, 0x68, 0x59, 0x90, 0x94, 0x9a, 0x75, 0x64, 0x4b, 0x63, 0x20, 0xef, 0xc1, 0x16, 0x66, 0xb5,
|
|
0xab, 0xae, 0x41, 0xea, 0x6b, 0x80, 0xcf, 0xf3, 0xac, 0x5a, 0x9a, 0x06, 0x84, 0xd0, 0x65, 0xd4,
|
|
0x64, 0x26, 0x5d, 0x66, 0xf6, 0xa3, 0x68, 0x0c, 0x6e, 0x6e, 0xe0, 0x49, 0xb5, 0xe0, 0x4f, 0x78,
|
|
0x48, 0x47, 0x75, 0x00, 0xfd, 0x59, 0x94, 0xac, 0xb4, 0xb3, 0x28, 0xe1, 0x6c, 0x3d, 0xa4, 0xe3,
|
|
0x7a, 0x14, 0xaf, 0x89, 0xa2, 0xbe, 0x82, 0x1d, 0x33, 0x9c, 0x34, 0x7a, 0x27, 0xba, 0xbc, 0x72,
|
|
0x7b, 0xff, 0x6c, 0x64, 0xaf, 0xde, 0xe6, 0x8f, 0x02, 0x7c, 0xd2, 0x59, 0x95, 0x58, 0xa9, 0x68,
|
|
0x78, 0x4e, 0x2f, 0x96, 0xba, 0x29, 0x87, 0xcf, 0x72, 0x0c, 0xc3, 0x93, 0x92, 0xe6, 0x79, 0x16,
|
|
0x25, 0x95, 0x6e, 0x02, 0xb5, 0x45, 0xf2, 0x1d, 0xe8, 0x4f, 0xd2, 0xd2, 0xa8, 0x7d, 0x2e, 0x61,
|
|
0x85, 0xe5, 0x7d, 0x18, 0x1c, 0x66, 0x59, 0x62, 0x94, 0xdd, 0xb1, 0x08, 0xfb, 0xe8, 0x04, 0x72,
|
|
0x0f, 0xe0, 0x69, 0x92, 0x45, 0x8d, 0xef, 0xd6, 0x58, 0x84, 0x02, 0x5b, 0x12, 0xf5, 0x10, 0x7a,
|
|
0x94, 0xe9, 0xf3, 0x68, 0xe9, 0xaa, 0x15, 0xb7, 0x54, 0xab, 0xfe, 0x14, 0xb0, 0xfd, 0x65, 0xa5,
|
|
0xf3, 0x0b, 0xd4, 0xdf, 0x54, 0xba, 0x28, 0xa9, 0xb7, 0x8c, 0xed, 0x74, 0x30, 0xa0, 0x39, 0x38,
|
|
0x79, 0x1d, 0xe5, 0x73, 0xd3, 0x3b, 0x1f, 0x1b, 0x44, 0xb5, 0xba, 0x9e, 0x17, 0x5c, 0x6b, 0x1f,
|
|
0xdb, 0x22, 0x9e, 0x20, 0xbd, 0xc8, 0x4a, 0x5b, 0x4c, 0x83, 0x64, 0x08, 0xff, 0x3f, 0x7e, 0xf3,
|
|
0x32, 0xa9, 0xe6, 0x1a, 0xb3, 0xda, 0x78, 0x6f, 0xb1, 0xc1, 0xa6, 0x58, 0xbe, 0x07, 0xbb, 0x8d,
|
|
0xc8, 0x52, 0x51, 0x8f, 0x0d, 0x37, 0xa4, 0xf2, 0x11, 0x6c, 0x1f, 0x2f, 0xce, 0xf4, 0x7c, 0xae,
|
|
0xe7, 0x47, 0x51, 0x19, 0x05, 0x7d, 0xae, 0x7b, 0x83, 0x18, 0xd6, 0x4c, 0xd4, 0x77, 0x02, 0x76,
|
|
0x9a, 0xea, 0x8b, 0x65, 0x96, 0x16, 0x9a, 0xae, 0xf8, 0x38, 0xcf, 0xed, 0x15, 0x1f, 0xe7, 0xb9,
|
|
0x7c, 0x08, 0x3d, 0xd4, 0x45, 0x95, 0x94, 0x76, 0x6e, 0xee, 0xba, 0x88, 0xd6, 0xb7, 0x4a, 0x4a,
|
|
0xb4, 0x56, 0xf2, 0x13, 0xd8, 0x5d, 0x9b, 0x43, 0xc3, 0x7e, 0xc3, 0x83, 0xb7, 0x9d, 0xdf, 0x9a,
|
|
0x1e, 0x37, 0xcc, 0xd5, 0x4f, 0x1e, 0x0c, 0x5b, 0x91, 0x89, 0xe8, 0x30, 0xab, 0x6f, 0x60, 0x42,
|
|
0xda, 0xe8, 0x6d, 0x10, 0xd3, 0x66, 0x04, 0xc5, 0xd4, 0xf1, 0x84, 0x77, 0x1b, 0x4f, 0x10, 0xb3,
|
|
0xbf, 0x8e, 0xd2, 0x73, 0x3d, 0xe7, 0x11, 0xec, 0xa3, 0x85, 0x72, 0xdf, 0xed, 0x1e, 0xdf, 0xd9,
|
|
0xda, 0x42, 0x5b, 0x0d, 0xba, 0xfd, 0xb4, 0x3b, 0x40, 0xd7, 0xb7, 0xd3, 0xec, 0x80, 0xe1, 0x8d,
|
|
0xc9, 0x11, 0xdd, 0x15, 0xcf, 0x8b, 0x41, 0xf2, 0x23, 0x18, 0x3a, 0xde, 0x28, 0x9a, 0x2b, 0x1a,
|
|
0xb9, 0xf0, 0x4e, 0x89, 0x6d, 0x43, 0xf9, 0xe9, 0x26, 0x95, 0x07, 0x03, 0xce, 0x2c, 0x58, 0xeb,
|
|
0x46, 0x4b, 0x8f, 0x9b, 0xd4, 0xff, 0xa8, 0xf5, 0xb6, 0x04, 0xc0, 0xce, 0x6f, 0x39, 0xe7, 0x95,
|
|
0x0a, 0x5b, 0x2f, 0xd0, 0x87, 0x6d, 0xfa, 0x0d, 0x86, 0xec, 0x33, 0x5a, 0xef, 0xa6, 0xd1, 0x61,
|
|
0xcb, 0x4e, 0xfd, 0x2e, 0x60, 0x67, 0xb2, 0x58, 0x66, 0x79, 0xd9, 0x5a, 0xa9, 0x49, 0x3a, 0xd7,
|
|
0x6f, 0xec, 0x4a, 0x31, 0xb8, 0x9e, 0xa8, 0x49, 0xca, 0xab, 0xc5, 0xab, 0xe4, 0xa3, 0x01, 0xad,
|
|
0x76, 0xfa, 0x6b, 0xed, 0xbc, 0x0f, 0x03, 0x33, 0x3b, 0xa4, 0xea, 0xb2, 0xca, 0x09, 0x88, 0x2c,
|
|
0x4e, 0xe3, 0x85, 0x2e, 0xca, 0x68, 0xb1, 0xa4, 0xed, 0xf2, 0x42, 0x0f, 0x5b, 0x12, 0xf3, 0x10,
|
|
0xd7, 0xfc, 0xf8, 0xf5, 0xf8, 0xf1, 0xb3, 0x90, 0x3c, 0x4d, 0x18, 0x56, 0xf6, 0x59, 0xd9, 0x92,
|
|
0xa8, 0x5f, 0x04, 0x48, 0x53, 0x23, 0xd3, 0xce, 0x7f, 0x57, 0xe8, 0xed, 0x05, 0xdd, 0x83, 0x2d,
|
|
0xfe, 0x9e, 0x2d, 0xa6, 0x41, 0x1b, 0xe9, 0xf6, 0x36, 0xd3, 0x25, 0x96, 0x72, 0x1c, 0x69, 0xea,
|
|
0x11, 0xd8, 0x16, 0xa9, 0x19, 0x8c, 0x4e, 0xf3, 0x28, 0x2d, 0x92, 0xa8, 0xd4, 0xe4, 0xf2, 0x6f,
|
|
0x2a, 0xba, 0xe6, 0x5f, 0x47, 0xbd, 0x0f, 0x77, 0x37, 0xe2, 0x3a, 0x9e, 0xa1, 0x12, 0x3d, 0x2e,
|
|
0x91, 0x8e, 0xea, 0x10, 0x82, 0x66, 0x6c, 0xcc, 0xdf, 0x50, 0x93, 0xc2, 0x2c, 0xd6, 0x35, 0x85,
|
|
0x9e, 0x46, 0x0b, 0xdd, 0x64, 0xc1, 0x67, 0x92, 0x31, 0xcd, 0x75, 0xf8, 0x1f, 0x8a, 0xcf, 0xea,
|
|
0x15, 0x8c, 0xae, 0x8b, 0xc1, 0x0f, 0x66, 0xa2, 0x23, 0xc3, 0x6b, 0x7d, 0x34, 0x40, 0x3e, 0x86,
|
|
0xee, 0xb7, 0xb1, 0xae, 0x2d, 0xaf, 0x29, 0x37, 0xda, 0x37, 0x25, 0x82, 0xc6, 0x41, 0xfd, 0x20,
|
|
0x6c, 0xb2, 0x2d, 0xaa, 0xff, 0xdb, 0x9e, 0x99, 0xfb, 0x6e, 0xde, 0x6c, 0x73, 0xdf, 0x81, 0x79,
|
|
0xaf, 0xdc, 0x83, 0x6b, 0x21, 0xbd, 0x91, 0x74, 0x9c, 0x45, 0x89, 0x19, 0xfa, 0x01, 0xae, 0xf0,
|
|
0xed, 0x53, 0x72, 0x78, 0xe7, 0xe7, 0xcb, 0x3d, 0xf1, 0xeb, 0xe5, 0x9e, 0xf8, 0xed, 0x72, 0x4f,
|
|
0x7c, 0xff, 0xc7, 0xde, 0xff, 0xce, 0xb6, 0xf8, 0xef, 0xf6, 0x83, 0xbf, 0x02, 0x00, 0x00, 0xff,
|
|
0xff, 0xdd, 0x9e, 0xfe, 0xf7, 0xed, 0x0a, 0x00, 0x00,
|
|
}
|