scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-09-07 17:15:56 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

change AttrBlock handler calls to support protobuf instead of json

Browse source
This commit is contained in:
Travis Turner 2018-01-09 14:30:05 -06:00
parent 504fc0105d
commit 298d8ea866
No known key found for this signature in database
GPG key ID: 7F08008DFD9314C9
8 changed files with 903 additions and 165 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
attr.go
View file

@ -348,6 +348,22 @@ func txUpdateAttrs(tx *bolt.Tx, id uint64, m map[string]interface{}) (map[string
return attr, nil
}
func encodeAttrsMap(m map[uint64]map[string]interface{}) map[uint64]*internal.AttrMap {
r := make(map[uint64]*internal.AttrMap, len(m))
for k, v := range m {
r[k] = &internal.AttrMap{Attrs: encodeAttrs(v)}
}
return r
}
func DecodeAttrsMap(m map[uint64]*internal.AttrMap) map[uint64]map[string]interface{} {
r := make(map[uint64]map[string]interface{}, len(m))
for k, v := range m {
r[k] = decodeAttrs(v.Attrs)
}
return r
}
func encodeAttrs(m map[string]interface{}) []*internal.Attr {
keys := make([]string, 0, len(m))
for k := range m {
@ -438,6 +454,38 @@ type AttrBlock struct {
Checksum []byte `json:"checksum"`
}
// EncodeAttrBlocks converts a into its internal representation.
func EncodeAttrBlocks(a []AttrBlock) []*internal.AttrBlock {
other := make([]*internal.AttrBlock, len(a))
for i := range a {
other[i] = encodeAttrBlock(&a[i])
}
return other
}
// encodeAttrBlock converts b into its internal representation.
func encodeAttrBlock(b *AttrBlock) *internal.AttrBlock {
return &internal.AttrBlock{
ID: b.ID,
Checksum: b.Checksum,
}
}
func decodeAttrBlocks(a []*internal.AttrBlock) []AttrBlock {
other := make([]AttrBlock, len(a))
for i := range a {
other[i] = decodeAttrBlock(a[i])
}
return other
}
func decodeAttrBlock(b *internal.AttrBlock) AttrBlock {
return AttrBlock{
ID: b.ID,
Checksum: b.Checksum,
}
}
// AttrBlocks represents a list of blocks.
type AttrBlocks []AttrBlock

54
client.go
View file

@ -966,10 +966,12 @@ func (c *InternalHTTPClient) BlockData(ctx context.Context, index, frame, view s
func (c *InternalHTTPClient) ColumnAttrDiff(ctx context.Context, index string, blks []AttrBlock) (map[uint64]map[string]interface{}, error) {
u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/attr/diff", index))
// Encode request.
buf, err := json.Marshal(postIndexAttrDiffRequest{Blocks: blks})
// Encode request object.
buf, err := proto.Marshal(&internal.AttrBlockRequest{
Blocks: EncodeAttrBlocks(blks),
})
if err != nil {
return nil, err
return nil, fmt.Errorf("marshal column attr block request: %s", err)
}
// Build request.
@ -977,7 +979,9 @@ func (c *InternalHTTPClient) ColumnAttrDiff(ctx context.Context, index string, b
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Content-Length", strconv.Itoa(len(buf)))
req.Header.Set("Content-Type", "application/x-protobuf")
req.Header.Set("Accept", "application/x-protobuf")
req.Header.Set("User-Agent", "pilosa/"+Version)
// Execute request.
@ -994,22 +998,31 @@ func (c *InternalHTTPClient) ColumnAttrDiff(ctx context.Context, index string, b
return nil, fmt.Errorf("unexpected status: code=%d", resp.StatusCode)
}
// Decode response object.
var rsp postIndexAttrDiffResponse
if err := json.NewDecoder(resp.Body).Decode(&rsp); err != nil {
// Read body.
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
return rsp.Attrs, nil
// Decode response object.
abresp := &internal.AttrBlockResponse{}
if err := proto.Unmarshal(body, abresp); err != nil {
return nil, fmt.Errorf("unmarshal attribute block response: %s", err)
}
return DecodeAttrsMap(abresp.Attrs), nil
}
// RowAttrDiff returns data from differing blocks on a remote host.
func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame string, blks []AttrBlock) (map[uint64]map[string]interface{}, error) {
u := uriPathToURL(c.defaultURI, fmt.Sprintf("/index/%s/frame/%s/attr/diff", index, frame))
// Encode request.
buf, err := json.Marshal(postFrameAttrDiffRequest{Blocks: blks})
// Encode request object.
buf, err := proto.Marshal(&internal.AttrBlockRequest{
Blocks: EncodeAttrBlocks(blks),
})
if err != nil {
return nil, err
return nil, fmt.Errorf("marshal row attr block request: %s", err)
}
// Build request.
@ -1017,7 +1030,9 @@ func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame strin
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Content-Length", strconv.Itoa(len(buf)))
req.Header.Set("Content-Type", "application/x-protobuf")
req.Header.Set("Accept", "application/x-protobuf")
req.Header.Set("User-Agent", "pilosa/"+Version)
// Execute request.
@ -1036,12 +1051,19 @@ func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame strin
return nil, fmt.Errorf("unexpected status: code=%d", resp.StatusCode)
}
// Decode response object.
var rsp postFrameAttrDiffResponse
if err := json.NewDecoder(resp.Body).Decode(&rsp); err != nil {
// Read body.
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
return rsp.Attrs, nil
// Decode response object.
abresp := &internal.AttrBlockResponse{}
if err := proto.Unmarshal(body, abresp); err != nil {
return nil, fmt.Errorf("unmarshal attribute block response: %s", err)
}
return DecodeAttrsMap(abresp.Attrs), nil
}
func (c *InternalHTTPClient) clientURI(ctx context.Context) *URI {

94
handler.go
View file

@ -538,11 +538,27 @@ type patchIndexTimeQuantumResponse struct{}
// handlePostIndexAttrDiff handles POST /index/attr/diff requests.
func (h *Handler) handlePostIndexAttrDiff(w http.ResponseWriter, r *http.Request) {
// Verify that request is only communicating over protobufs.
if r.Header.Get("Content-Type") != "application/x-protobuf" {
http.Error(w, "Unsupported media type", http.StatusUnsupportedMediaType)
return
} else if r.Header.Get("Accept") != "application/x-protobuf" {
http.Error(w, "Not acceptable", http.StatusNotAcceptable)
return
}
indexName := mux.Vars(r)["index"]
// Decode request.
var req postIndexAttrDiffRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
// Read entire body.
body, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Marshal into request object.
var req internal.AttrBlockRequest
if err := proto.Unmarshal(body, &req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@ -563,7 +579,7 @@ func (h *Handler) handlePostIndexAttrDiff(w http.ResponseWriter, r *http.Request
// Read all attributes from all mismatched blocks.
attrs := make(map[uint64]map[string]interface{})
for _, blockID := range AttrBlocks(blks).Diff(req.Blocks) {
for _, blockID := range AttrBlocks(blks).Diff(decodeAttrBlocks(req.Blocks)) {
// Retrieve block data.
m, err := index.ColumnAttrStore().BlockData(blockID)
if err != nil {
@ -577,20 +593,17 @@ func (h *Handler) handlePostIndexAttrDiff(w http.ResponseWriter, r *http.Request
}
}
// Encode response.
if err := json.NewEncoder(w).Encode(postIndexAttrDiffResponse{
Attrs: attrs,
}); err != nil {
h.logger().Printf("response encoding error: %s", err)
// Marshal response object.
buf, err := proto.Marshal(&internal.AttrBlockResponse{
Attrs: encodeAttrsMap(attrs),
})
// Write response.
if err != nil {
h.logger().Printf("row attr response encoding error: %s", err)
w.WriteHeader(http.StatusInternalServerError)
}
}
type postIndexAttrDiffRequest struct {
Blocks []AttrBlock `json:"blocks"`
}
type postIndexAttrDiffResponse struct {
Attrs map[uint64]map[string]interface{} `json:"attrs"`
w.Write(buf)
}
// handlePostFrame handles POST /frame request.
@ -956,12 +969,28 @@ type getFrameViewsResponse struct {
// handlePostFrameAttrDiff handles POST /frame/attr/diff requests.
func (h *Handler) handlePostFrameAttrDiff(w http.ResponseWriter, r *http.Request) {
// Verify that request is only communicating over protobufs.
if r.Header.Get("Content-Type") != "application/x-protobuf" {
http.Error(w, "Unsupported media type", http.StatusUnsupportedMediaType)
return
} else if r.Header.Get("Accept") != "application/x-protobuf" {
http.Error(w, "Not acceptable", http.StatusNotAcceptable)
return
}
indexName := mux.Vars(r)["index"]
frameName := mux.Vars(r)["frame"]
// Decode request.
var req postFrameAttrDiffRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
// Read entire body.
body, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Marshal into request object.
var req internal.AttrBlockRequest
if err := proto.Unmarshal(body, &req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@ -982,7 +1011,7 @@ func (h *Handler) handlePostFrameAttrDiff(w http.ResponseWriter, r *http.Request
// Read all attributes from all mismatched blocks.
attrs := make(map[uint64]map[string]interface{})
for _, blockID := range AttrBlocks(blks).Diff(req.Blocks) {
for _, blockID := range AttrBlocks(blks).Diff(decodeAttrBlocks(req.Blocks)) {
// Retrieve block data.
m, err := f.RowAttrStore().BlockData(blockID)
if err != nil {
@ -996,20 +1025,17 @@ func (h *Handler) handlePostFrameAttrDiff(w http.ResponseWriter, r *http.Request
}
}
// Encode response.
if err := json.NewEncoder(w).Encode(postFrameAttrDiffResponse{
Attrs: attrs,
}); err != nil {
h.logger().Printf("response encoding error: %s", err)
// Marshal response object.
buf, err := proto.Marshal(&internal.AttrBlockResponse{
Attrs: encodeAttrsMap(attrs),
})
// Write response.
if err != nil {
h.logger().Printf("row attr response encoding error: %s", err)
w.WriteHeader(http.StatusInternalServerError)
}
}
type postFrameAttrDiffRequest struct {
Blocks []AttrBlock `json:"blocks"`
}
type postFrameAttrDiffResponse struct {
Attrs map[uint64]map[string]interface{} `json:"attrs"`
w.Write(buf)
}
// readColumnAttrSets returns a list of column attribute objects by id.

91
handler_test.go
View file

@ -24,6 +24,7 @@ import (
"net/http"
"net/http/httptest"
"reflect"
"strconv"
"strings"
"testing"
@ -793,20 +794,53 @@ func TestHandler_Index_AttrStore_Diff(t *testing.T) {
blks = blks[1:]
blks[1].Checksum = []byte("MISMATCHED_CHECKSUM")
// Encode request object.
buf, err := proto.Marshal(&internal.AttrBlockRequest{
Blocks: pilosa.EncodeAttrBlocks(blks),
})
if err != nil {
t.Fatal(err)
}
// Send block checksums to determine diff.
resp, err := http.Post(
client := &http.Client{}
req, err := http.NewRequest(
"POST",
s.URL+"/index/i/attr/diff",
"application/json",
strings.NewReader(`{"blocks":`+string(test.MustMarshalJSON(blks))+`}`),
bytes.NewReader(buf),
)
if err != nil {
t.Fatal(err)
}
req.Header.Set("Content-Length", strconv.Itoa(len(buf)))
req.Header.Set("Content-Type", "application/x-protobuf")
req.Header.Set("Accept", "application/x-protobuf")
resp, err := client.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
// Read and validate body.
if body := string(test.MustReadAll(resp.Body)); body != `{"attrs":{"1":{"bar":2,"foo":1},"200":{"snowman":"☃"}}}`+"\n" {
t.Fatalf("unexpected body: %s", body)
// Read body.
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
// Decode response object.
abresp := &internal.AttrBlockResponse{}
if err := proto.Unmarshal(body, abresp); err != nil {
t.Fatal(err)
}
rec := pilosa.DecodeAttrsMap(abresp.Attrs)
exp := make(map[uint64]map[string]interface{})
exp[1] = map[string]interface{}{"bar": int64(2), "foo": int64(1)}
exp[200] = map[string]interface{}{"snowman": "☃"}
if !reflect.DeepEqual(rec, exp) {
t.Fatalf("\nexpected: %s\n\ngot: %s\n", exp, rec)
}
}
@ -843,20 +877,53 @@ func TestHandler_Frame_AttrStore_Diff(t *testing.T) {
blks = blks[1:]
blks[1].Checksum = []byte("MISMATCHED_CHECKSUM")
// Encode request object.
buf, err := proto.Marshal(&internal.AttrBlockRequest{
Blocks: pilosa.EncodeAttrBlocks(blks),
})
if err != nil {
t.Fatal(err)
}
// Send block checksums to determine diff.
resp, err := http.Post(
client := &http.Client{}
req, err := http.NewRequest(
"POST",
s.URL+"/index/i/frame/meta/attr/diff",
"application/json",
strings.NewReader(`{"blocks":`+string(test.MustMarshalJSON(blks))+`}`),
bytes.NewReader(buf),
)
if err != nil {
t.Fatal(err)
}
req.Header.Set("Content-Length", strconv.Itoa(len(buf)))
req.Header.Set("Content-Type", "application/x-protobuf")
req.Header.Set("Accept", "application/x-protobuf")
resp, err := client.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
// Read and validate body.
if body := string(test.MustReadAll(resp.Body)); body != `{"attrs":{"1":{"bar":2,"foo":1},"200":{"snowman":"☃"}}}`+"\n" {
t.Fatalf("unexpected body: %s", body)
// Read body.
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
// Decode response object.
abresp := &internal.AttrBlockResponse{}
if err := proto.Unmarshal(body, abresp); err != nil {
t.Fatal(err)
}
rec := pilosa.DecodeAttrsMap(abresp.Attrs)
exp := make(map[uint64]map[string]interface{})
exp[1] = map[string]interface{}{"bar": int64(2), "foo": int64(1)}
exp[200] = map[string]interface{}{"snowman": "☃"}
if !reflect.DeepEqual(rec, exp) {
t.Fatalf("\nexpected: %s\n\ngot: %s\n", exp, rec)
}
}

435
internal/private.pb.go
View file

@ -32,6 +32,8 @@
FrameSchema
Field
DeleteViewMessage
AttrBlock
AttrBlockRequest
*/
package internal
@ -768,6 +770,47 @@ func (m *DeleteViewMessage) GetView() string {
return ""
}
// AttrBlock represents a checksummed block of the attribute store.
type AttrBlock struct {
ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
Checksum []byte `protobuf:"bytes,2,opt,name=Checksum,proto3" json:"Checksum,omitempty"`
}
func (m *AttrBlock) Reset() { *m = AttrBlock{} }
func (m *AttrBlock) String() string { return proto.CompactTextString(m) }
func (*AttrBlock) ProtoMessage() {}
func (*AttrBlock) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{24} }
func (m *AttrBlock) GetID() uint64 {
if m != nil {
return m.ID
}
return 0
}
func (m *AttrBlock) GetChecksum() []byte {
if m != nil {
return m.Checksum
}
return nil
}
type AttrBlockRequest struct {
Blocks []*AttrBlock `protobuf:"bytes,1,rep,name=Blocks" json:"Blocks,omitempty"`
}
func (m *AttrBlockRequest) Reset() { *m = AttrBlockRequest{} }
func (m *AttrBlockRequest) String() string { return proto.CompactTextString(m) }
func (*AttrBlockRequest) ProtoMessage() {}
func (*AttrBlockRequest) Descriptor() ([]byte, []int) { return fileDescriptorPrivate, []int{25} }
func (m *AttrBlockRequest) GetBlocks() []*AttrBlock {
if m != nil {
return m.Blocks
}
return nil
}
func init() {
proto.RegisterType((*IndexMeta)(nil), "internal.IndexMeta")
proto.RegisterType((*FrameMeta)(nil), "internal.FrameMeta")
@ -793,6 +836,8 @@ func init() {
proto.RegisterType((*FrameSchema)(nil), "internal.FrameSchema")
proto.RegisterType((*Field)(nil), "internal.Field")
proto.RegisterType((*DeleteViewMessage)(nil), "internal.DeleteViewMessage")
proto.RegisterType((*AttrBlock)(nil), "internal.AttrBlock")
proto.RegisterType((*AttrBlockRequest)(nil), "internal.AttrBlockRequest")
}
func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
size := m.Size()
@ -1762,6 +1807,65 @@ func (m *DeleteViewMessage) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *AttrBlock) 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 *AttrBlock) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.ID != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPrivate(dAtA, i, uint64(m.ID))
}
if len(m.Checksum) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintPrivate(dAtA, i, uint64(len(m.Checksum)))
i += copy(dAtA[i:], m.Checksum)
}
return i, nil
}
func (m *AttrBlockRequest) 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 *AttrBlockRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Blocks) > 0 {
for _, msg := range m.Blocks {
dAtA[i] = 0xa
i++
i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func encodeVarintPrivate(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
@ -2201,6 +2305,31 @@ func (m *DeleteViewMessage) Size() (n int) {
return n
}
func (m *AttrBlock) Size() (n int) {
var l int
_ = l
if m.ID != 0 {
n += 1 + sovPrivate(uint64(m.ID))
}
l = len(m.Checksum)
if l > 0 {
n += 1 + l + sovPrivate(uint64(l))
}
return n
}
func (m *AttrBlockRequest) Size() (n int) {
var l int
_ = l
if len(m.Blocks) > 0 {
for _, e := range m.Blocks {
l = e.Size()
n += 1 + l + sovPrivate(uint64(l))
}
}
return n
}
func sovPrivate(x uint64) (n int) {
for {
n++
@ -5509,6 +5638,187 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *AttrBlock) 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 ErrIntOverflowPrivate
}
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: AttrBlock: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AttrBlock: 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 ErrIntOverflowPrivate
}
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 Checksum", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPrivate
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthPrivate
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Checksum = append(m.Checksum[:0], dAtA[iNdEx:postIndex]...)
if m.Checksum == nil {
m.Checksum = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPrivate(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AttrBlockRequest) 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 ErrIntOverflowPrivate
}
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: AttrBlockRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AttrBlockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPrivate
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthPrivate
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Blocks = append(m.Blocks, &AttrBlock{})
if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPrivate(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthPrivate
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipPrivate(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
@ -5617,65 +5927,68 @@ var (
func init() { proto.RegisterFile("private.proto", fileDescriptorPrivate) }
var fileDescriptorPrivate = []byte{
// 948 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xc1, 0x6e, 0x23, 0x45,
0x10, 0x65, 0x3c, 0x63, 0xaf, 0x5d, 0x26, 0x1b, 0xa7, 0x09, 0x2b, 0x6f, 0x14, 0x19, 0xab, 0x0f,
0x6c, 0x88, 0x44, 0x0e, 0x41, 0x5a, 0x01, 0xcb, 0x01, 0x36, 0xce, 0x2a, 0x16, 0x78, 0x81, 0xf6,
0x6a, 0xb9, 0x21, 0x75, 0x9c, 0x62, 0x77, 0x94, 0xf1, 0x8c, 0x99, 0x69, 0x27, 0x31, 0x07, 0x8e,
0x7c, 0x03, 0x12, 0x47, 0x7e, 0x86, 0x23, 0x9f, 0x80, 0xc2, 0x85, 0x3f, 0x40, 0xe2, 0x84, 0xba,
0xba, 0x7b, 0x66, 0x6c, 0xc7, 0x8e, 0xb2, 0xb7, 0xae, 0x57, 0xd5, 0x55, 0xaf, 0xab, 0xab, 0xaa,
0x1b, 0x36, 0x26, 0x69, 0x78, 0x21, 0x15, 0x1e, 0x4c, 0xd2, 0x44, 0x25, 0xac, 0x1e, 0xc6, 0x0a,
0xd3, 0x58, 0x46, 0xfc, 0x6b, 0x68, 0xf4, 0xe3, 0x33, 0xbc, 0x1a, 0xa0, 0x92, 0xac, 0x0b, 0xcd,
0xa3, 0x24, 0x9a, 0x8e, 0xe3, 0xaf, 0xe4, 0x29, 0x46, 0x6d, 0xaf, 0xeb, 0xed, 0x35, 0x44, 0x19,
0xd2, 0x16, 0x2f, 0xc2, 0x31, 0x7e, 0x3b, 0x95, 0xb1, 0x9a, 0x8e, 0xdb, 0x15, 0x63, 0x51, 0x82,
0xf8, 0x7f, 0x1e, 0x34, 0x9e, 0xa5, 0x72, 0x8c, 0xe4, 0x71, 0x07, 0xea, 0x22, 0xb9, 0x2c, 0xbb,
0xcb, 0x65, 0xf6, 0x3e, 0xdc, 0xef, 0xc7, 0x17, 0x98, 0x66, 0x78, 0x1c, 0xcb, 0xd3, 0x08, 0xcf,
0xc8, 0x5d, 0x5d, 0x2c, 0xa0, 0x6c, 0x17, 0x1a, 0x47, 0x72, 0xf4, 0x1a, 0x5f, 0xcc, 0x26, 0xd8,
0xf6, 0xc9, 0x49, 0x01, 0xe4, 0xda, 0x61, 0xf8, 0x13, 0xb6, 0x83, 0xae, 0xb7, 0xb7, 0x21, 0x0a,
0x60, 0x91, 0x6f, 0x75, 0x89, 0x2f, 0xe3, 0xf0, 0xb6, 0x90, 0xf1, 0xab, 0x9c, 0x43, 0x8d, 0x38,
0xcc, 0x61, 0xec, 0x11, 0xd4, 0x9e, 0x85, 0x18, 0x9d, 0x65, 0xed, 0x7b, 0x5d, 0x7f, 0xaf, 0x79,
0xb8, 0x79, 0xe0, 0xf2, 0x77, 0x40, 0xb8, 0xb0, 0x6a, 0xce, 0xe1, 0x7e, 0x7f, 0x3c, 0x49, 0x52,
0x25, 0x30, 0x9b, 0x24, 0x71, 0x86, 0xac, 0x05, 0xfe, 0x71, 0x9a, 0xda, 0xb3, 0xeb, 0x25, 0xff,
0x19, 0x5a, 0x4f, 0xa3, 0x64, 0x74, 0xde, 0x93, 0x4a, 0x0a, 0xfc, 0x71, 0x8a, 0x99, 0x62, 0xdb,
0x50, 0xa5, 0x5b, 0xb0, 0x76, 0x46, 0xd0, 0x28, 0x65, 0xd2, 0xa6, 0xd9, 0x08, 0x1a, 0xa5, 0xfd,
0x94, 0x8a, 0x40, 0x18, 0x41, 0xa3, 0xc3, 0x28, 0x1c, 0x99, 0x14, 0x04, 0xc2, 0x08, 0x8c, 0x41,
0xf0, 0x32, 0xc4, 0x4b, 0x7b, 0x6e, 0x5a, 0xf3, 0x3e, 0x6c, 0x95, 0xe2, 0x5b, 0x9a, 0x0f, 0xa0,
0x26, 0x92, 0xcb, 0x7e, 0x2f, 0x6b, 0x7b, 0x5d, 0x7f, 0x2f, 0x10, 0x56, 0xa2, 0xec, 0xd2, 0xf5,
0x6b, 0x55, 0x85, 0x54, 0x05, 0xc0, 0x1f, 0x42, 0x95, 0x52, 0xad, 0x4f, 0x59, 0xec, 0xd5, 0x4b,
0xfe, 0x9b, 0x07, 0x5b, 0x03, 0x79, 0x45, 0x34, 0xb2, 0x3c, 0xcc, 0x09, 0x34, 0x72, 0x90, 0xac,
0x9b, 0x87, 0xfb, 0x45, 0x2e, 0x97, 0xec, 0x0b, 0xe4, 0x38, 0x56, 0xe9, 0x4c, 0x14, 0x9b, 0x77,
0x3e, 0x83, 0xfb, 0xf3, 0x4a, 0xcd, 0xe1, 0x1c, 0x67, 0x2e, 0xd3, 0xe7, 0x38, 0xd3, 0x39, 0xb9,
0x90, 0xd1, 0xd4, 0xe4, 0x2f, 0x10, 0x46, 0xf8, 0xb4, 0xf2, 0xb1, 0xc7, 0xbf, 0x07, 0x76, 0x94,
0xa2, 0x54, 0x48, 0x0e, 0x06, 0x98, 0x65, 0xf2, 0x15, 0xae, 0xbe, 0x05, 0x93, 0xd9, 0x4a, 0x39,
0xb3, 0xbb, 0xd0, 0xe8, 0x67, 0xb6, 0x50, 0xe9, 0x26, 0xea, 0xa2, 0x00, 0xf8, 0x3e, 0xb0, 0x1e,
0x46, 0xa8, 0xd0, 0xf6, 0xd6, 0x1a, 0xff, 0x7c, 0xe8, 0xb8, 0xdc, 0x6e, 0xcb, 0x1e, 0x41, 0xa0,
0xdb, 0x8a, 0xa8, 0x34, 0x0f, 0xdf, 0x29, 0x52, 0x97, 0xf7, 0xb0, 0x20, 0x03, 0x1e, 0x3a, 0xa7,
0xb6, 0x15, 0x6f, 0x39, 0xe0, 0x0d, 0x65, 0xe6, 0x42, 0xf9, 0x8b, 0xa1, 0xf2, 0xe6, 0xb6, 0xa1,
0x3e, 0x77, 0x67, 0x7d, 0xd3, 0x50, 0xbc, 0x67, 0x51, 0x5d, 0xae, 0xcf, 0xb5, 0xd6, 0xec, 0xa1,
0xf5, 0xea, 0x23, 0x2f, 0xf2, 0xf8, 0xc7, 0xb3, 0x21, 0xef, 0xe6, 0x66, 0x21, 0x73, 0x7a, 0x62,
0xb9, 0xc2, 0xb2, 0x1d, 0x96, 0xcb, 0x34, 0x07, 0x74, 0xd4, 0xac, 0x1d, 0x2c, 0xcd, 0x01, 0x8d,
0x0b, 0xab, 0xd6, 0xed, 0x64, 0x8b, 0xbc, 0x6a, 0xda, 0xc9, 0x48, 0xec, 0x18, 0x5a, 0xfd, 0x78,
0x32, 0x55, 0x3d, 0xfc, 0x21, 0x8c, 0x43, 0x15, 0x26, 0x71, 0xd6, 0xae, 0x91, 0xab, 0x87, 0x65,
0x46, 0x73, 0x16, 0x62, 0x69, 0x0b, 0xff, 0xc5, 0x83, 0xcd, 0x05, 0x70, 0xc5, 0xa1, 0x1d, 0xdf,
0xca, 0x7a, 0xbe, 0x8f, 0xf3, 0x01, 0xe7, 0x93, 0x61, 0x67, 0x25, 0x9b, 0xf9, 0x79, 0xf7, 0xbb,
0x07, 0xdb, 0x37, 0x19, 0xdc, 0xc8, 0xa6, 0x03, 0xf0, 0x4d, 0x1a, 0x8e, 0x65, 0x3a, 0xfb, 0x12,
0x67, 0x76, 0xd6, 0x97, 0x10, 0xf6, 0x1d, 0x3c, 0x58, 0xf0, 0xf5, 0xc5, 0xc8, 0xa4, 0xc8, 0x90,
0x7a, 0x6f, 0x25, 0x29, 0x63, 0x27, 0x56, 0x6c, 0xe7, 0xff, 0x7a, 0xf0, 0xee, 0x8d, 0xaa, 0xa2,
0x1e, 0xbd, 0x72, 0xe9, 0xef, 0x43, 0xeb, 0xa5, 0x1e, 0x15, 0x3d, 0xcc, 0x54, 0x18, 0x4b, 0x6d,
0x69, 0x0b, 0x76, 0x09, 0x67, 0x7d, 0xa8, 0x13, 0x36, 0x90, 0x13, 0x4b, 0xf3, 0xc3, 0x5b, 0x68,
0x1e, 0x38, 0x7b, 0x33, 0xd3, 0xf2, 0xed, 0x9a, 0x0c, 0x4d, 0x5d, 0x37, 0xc2, 0x49, 0xd8, 0x79,
0x02, 0x1b, 0x73, 0x1b, 0xee, 0x34, 0xe7, 0x12, 0xd8, 0x75, 0xb3, 0x65, 0x8e, 0xc9, 0xfa, 0x2e,
0xfd, 0x04, 0xa0, 0x30, 0xb5, 0x03, 0x60, 0x4d, 0x7d, 0x96, 0x8c, 0xf9, 0x09, 0xec, 0xba, 0xc1,
0x77, 0x87, 0x80, 0xae, 0x5a, 0x2a, 0x45, 0xb5, 0xf0, 0x19, 0xc0, 0xf3, 0xe4, 0x0c, 0x87, 0x4a,
0xaa, 0x69, 0xa6, 0x2d, 0x4e, 0x92, 0x4c, 0xb9, 0x7a, 0xd2, 0x6b, 0x1a, 0xcc, 0x4a, 0xaa, 0x7c,
0x98, 0x90, 0xc0, 0x3e, 0x80, 0x7b, 0xe4, 0x14, 0x5d, 0xd9, 0x6c, 0x2e, 0xf4, 0xba, 0x70, 0x7a,
0xea, 0xd2, 0xd1, 0x6b, 0x1c, 0x9b, 0x47, 0xb3, 0x21, 0xac, 0xc4, 0x9f, 0xc0, 0xc6, 0x51, 0x34,
0xcd, 0x14, 0xa6, 0x36, 0xfa, 0x3e, 0x54, 0x35, 0x17, 0xf7, 0x64, 0x6d, 0x17, 0x1e, 0x0b, 0x8a,
0xc2, 0x98, 0xf0, 0xc7, 0xd0, 0xa4, 0x2a, 0x22, 0x5f, 0xb2, 0xf4, 0x75, 0xf0, 0xd6, 0x7f, 0x1d,
0x86, 0x50, 0x5d, 0xdd, 0x3a, 0x0c, 0x02, 0xfa, 0xfd, 0xd8, 0x04, 0xd1, 0xc7, 0xa7, 0x05, 0xfe,
0x20, 0x34, 0xd7, 0xe3, 0x0b, 0xbd, 0x24, 0x44, 0x5e, 0xd1, 0x61, 0x34, 0x22, 0xf5, 0xdb, 0xb2,
0x65, 0xae, 0x43, 0xbf, 0xfc, 0x6f, 0xf2, 0x0a, 0xb8, 0x0f, 0x84, 0x5f, 0x7c, 0x20, 0x9e, 0xb6,
0xfe, 0xb8, 0xee, 0x78, 0x7f, 0x5e, 0x77, 0xbc, 0xbf, 0xae, 0x3b, 0xde, 0xaf, 0x7f, 0x77, 0xde,
0x3a, 0xad, 0xd1, 0xaf, 0xf2, 0xa3, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x47, 0xdd, 0xdd, 0x8e,
0x66, 0x0a, 0x00, 0x00,
// 999 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x6e, 0x23, 0x45,
0x10, 0x66, 0xec, 0xb1, 0xd7, 0x2e, 0x6f, 0x12, 0x67, 0x08, 0x2b, 0x6f, 0x14, 0x19, 0xab, 0x0f,
0x6c, 0x08, 0x22, 0x87, 0x20, 0x2d, 0x3f, 0x8b, 0x04, 0xbb, 0x76, 0x56, 0x19, 0x81, 0x17, 0x68,
0xaf, 0x96, 0x1b, 0x52, 0xc7, 0x29, 0x36, 0xa3, 0x8c, 0x67, 0xcc, 0x4c, 0x3b, 0x89, 0x39, 0x70,
0xe4, 0x19, 0x90, 0x38, 0xf2, 0x32, 0x1c, 0x79, 0x04, 0x14, 0x2e, 0xbc, 0x01, 0x12, 0xa7, 0x55,
0x57, 0x77, 0xcf, 0x8c, 0xed, 0xd8, 0x51, 0x72, 0xeb, 0xfa, 0xba, 0xba, 0xea, 0xeb, 0xea, 0xaa,
0xea, 0x82, 0xb5, 0x71, 0x12, 0x9c, 0x0b, 0x89, 0xfb, 0xe3, 0x24, 0x96, 0xb1, 0x57, 0x0b, 0x22,
0x89, 0x49, 0x24, 0x42, 0xf6, 0x0d, 0xd4, 0xfd, 0xe8, 0x04, 0x2f, 0xfb, 0x28, 0x85, 0xd7, 0x81,
0x46, 0x37, 0x0e, 0x27, 0xa3, 0xe8, 0x6b, 0x71, 0x8c, 0x61, 0xcb, 0xe9, 0x38, 0xbb, 0x75, 0x5e,
0x84, 0x94, 0xc6, 0xcb, 0x60, 0x84, 0xdf, 0x4d, 0x44, 0x24, 0x27, 0xa3, 0x56, 0x49, 0x6b, 0x14,
0x20, 0xf6, 0xbf, 0x03, 0xf5, 0xe7, 0x89, 0x18, 0x21, 0x59, 0xdc, 0x86, 0x1a, 0x8f, 0x2f, 0x8a,
0xe6, 0x32, 0xd9, 0x7b, 0x0f, 0xd6, 0xfd, 0xe8, 0x1c, 0x93, 0x14, 0x0f, 0x23, 0x71, 0x1c, 0xe2,
0x09, 0x99, 0xab, 0xf1, 0x39, 0xd4, 0xdb, 0x81, 0x7a, 0x57, 0x0c, 0x4f, 0xf1, 0xe5, 0x74, 0x8c,
0xad, 0x32, 0x19, 0xc9, 0x81, 0x6c, 0x77, 0x10, 0xfc, 0x8c, 0x2d, 0xb7, 0xe3, 0xec, 0xae, 0xf1,
0x1c, 0x98, 0xe7, 0x5b, 0x59, 0xe0, 0xeb, 0x31, 0xb8, 0xcf, 0x45, 0xf4, 0x3a, 0xe3, 0x50, 0x25,
0x0e, 0x33, 0x98, 0xf7, 0x08, 0xaa, 0xcf, 0x03, 0x0c, 0x4f, 0xd2, 0xd6, 0xbd, 0x4e, 0x79, 0xb7,
0x71, 0xb0, 0xb1, 0x6f, 0xe3, 0xb7, 0x4f, 0x38, 0x37, 0xdb, 0x8c, 0xc1, 0xba, 0x3f, 0x1a, 0xc7,
0x89, 0xe4, 0x98, 0x8e, 0xe3, 0x28, 0x45, 0xaf, 0x09, 0xe5, 0xc3, 0x24, 0x31, 0x77, 0x57, 0x4b,
0xf6, 0x0b, 0x34, 0x9f, 0x85, 0xf1, 0xf0, 0xac, 0x27, 0xa4, 0xe0, 0xf8, 0xd3, 0x04, 0x53, 0xe9,
0x6d, 0x41, 0x85, 0x5e, 0xc1, 0xe8, 0x69, 0x41, 0xa1, 0x14, 0x49, 0x13, 0x66, 0x2d, 0x28, 0x94,
0xce, 0x53, 0x28, 0x5c, 0xae, 0x05, 0x85, 0x0e, 0xc2, 0x60, 0xa8, 0x43, 0xe0, 0x72, 0x2d, 0x78,
0x1e, 0xb8, 0xaf, 0x02, 0xbc, 0x30, 0xf7, 0xa6, 0x35, 0xf3, 0x61, 0xb3, 0xe0, 0xdf, 0xd0, 0x7c,
0x00, 0x55, 0x1e, 0x5f, 0xf8, 0xbd, 0xb4, 0xe5, 0x74, 0xca, 0xbb, 0x2e, 0x37, 0x12, 0x45, 0x97,
0x9e, 0x5f, 0x6d, 0x95, 0x68, 0x2b, 0x07, 0xd8, 0x43, 0xa8, 0x50, 0xa8, 0xd5, 0x2d, 0xf3, 0xb3,
0x6a, 0xc9, 0x7e, 0x77, 0x60, 0xb3, 0x2f, 0x2e, 0x89, 0x46, 0x9a, 0xb9, 0x39, 0x82, 0x7a, 0x06,
0x92, 0x76, 0xe3, 0x60, 0x2f, 0x8f, 0xe5, 0x82, 0x7e, 0x8e, 0x1c, 0x46, 0x32, 0x99, 0xf2, 0xfc,
0xf0, 0xf6, 0xe7, 0xb0, 0x3e, 0xbb, 0xa9, 0x38, 0x9c, 0xe1, 0xd4, 0x46, 0xfa, 0x0c, 0xa7, 0x2a,
0x26, 0xe7, 0x22, 0x9c, 0xe8, 0xf8, 0xb9, 0x5c, 0x0b, 0x9f, 0x95, 0x3e, 0x71, 0xd8, 0x0f, 0xe0,
0x75, 0x13, 0x14, 0x12, 0xc9, 0x40, 0x1f, 0xd3, 0x54, 0xbc, 0xc6, 0xe5, 0xaf, 0xa0, 0x23, 0x5b,
0x2a, 0x46, 0x76, 0x07, 0xea, 0x7e, 0x6a, 0x12, 0x95, 0x5e, 0xa2, 0xc6, 0x73, 0x80, 0xed, 0x81,
0xd7, 0xc3, 0x10, 0x25, 0x9a, 0xda, 0x5a, 0x61, 0x9f, 0x0d, 0x2c, 0x97, 0x9b, 0x75, 0xbd, 0x47,
0xe0, 0xaa, 0xb2, 0x22, 0x2a, 0x8d, 0x83, 0xb7, 0xf3, 0xd0, 0x65, 0x35, 0xcc, 0x49, 0x81, 0x05,
0xd6, 0xa8, 0x29, 0xc5, 0x1b, 0x2e, 0x78, 0x4d, 0x9a, 0x59, 0x57, 0xe5, 0x79, 0x57, 0x59, 0x71,
0x1b, 0x57, 0x5f, 0xda, 0xbb, 0xde, 0xd5, 0x15, 0xeb, 0x19, 0x54, 0xa5, 0xeb, 0x0b, 0xb5, 0xab,
0xcf, 0xd0, 0x7a, 0xf9, 0x95, 0xe7, 0x79, 0xfc, 0xeb, 0x18, 0x97, 0xb7, 0x33, 0x33, 0x17, 0x39,
0xd5, 0xb1, 0x6c, 0x62, 0x99, 0x0a, 0xcb, 0x64, 0xea, 0x03, 0xca, 0x6b, 0xda, 0x72, 0x17, 0xfa,
0x80, 0xc2, 0xb9, 0xd9, 0x56, 0xe5, 0x64, 0x92, 0xbc, 0xa2, 0xcb, 0x49, 0x4b, 0xde, 0x21, 0x34,
0xfd, 0x68, 0x3c, 0x91, 0x3d, 0xfc, 0x31, 0x88, 0x02, 0x19, 0xc4, 0x51, 0xda, 0xaa, 0x92, 0xa9,
0x87, 0x45, 0x46, 0x33, 0x1a, 0x7c, 0xe1, 0x08, 0xfb, 0xd5, 0x81, 0x8d, 0x39, 0x70, 0xc9, 0xa5,
0x2d, 0xdf, 0xd2, 0x6a, 0xbe, 0x8f, 0xb3, 0x06, 0x57, 0x26, 0xc5, 0xf6, 0x52, 0x36, 0xb3, 0xfd,
0xee, 0x0f, 0x07, 0xb6, 0xae, 0x53, 0xb8, 0x96, 0x4d, 0x1b, 0xe0, 0xdb, 0x24, 0x18, 0x89, 0x64,
0xfa, 0x15, 0x4e, 0x4d, 0xaf, 0x2f, 0x20, 0xde, 0xf7, 0xf0, 0x60, 0xce, 0xd6, 0xd3, 0xa1, 0x0e,
0x91, 0x26, 0xf5, 0xee, 0x52, 0x52, 0x5a, 0x8f, 0x2f, 0x39, 0xce, 0xfe, 0x73, 0xe0, 0x9d, 0x6b,
0xb7, 0xf2, 0x7c, 0x74, 0x8a, 0xa9, 0xbf, 0x07, 0xcd, 0x57, 0xaa, 0x55, 0xf4, 0x30, 0x95, 0x41,
0x24, 0x94, 0xa6, 0x49, 0xd8, 0x05, 0xdc, 0xf3, 0xa1, 0x46, 0x58, 0x5f, 0x8c, 0x0d, 0xcd, 0x0f,
0x6f, 0xa0, 0xb9, 0x6f, 0xf5, 0x75, 0x4f, 0xcb, 0x8e, 0x2b, 0x32, 0xd4, 0x75, 0x6d, 0x0b, 0x27,
0x61, 0xfb, 0x09, 0xac, 0xcd, 0x1c, 0xb8, 0x55, 0x9f, 0x8b, 0x61, 0xc7, 0xf6, 0x96, 0x19, 0x26,
0xab, 0xab, 0xf4, 0x53, 0x80, 0x5c, 0xd5, 0x34, 0x80, 0x15, 0xf9, 0x59, 0x50, 0x66, 0x47, 0xb0,
0x63, 0x1b, 0xdf, 0x2d, 0x1c, 0xda, 0x6c, 0x29, 0xe5, 0xd9, 0xc2, 0xa6, 0x00, 0x2f, 0xe2, 0x13,
0x1c, 0x48, 0x21, 0x27, 0xa9, 0xd2, 0x38, 0x8a, 0x53, 0x69, 0xf3, 0x49, 0xad, 0xa9, 0x31, 0x4b,
0x21, 0xb3, 0x66, 0x42, 0x82, 0xf7, 0x3e, 0xdc, 0x23, 0xa3, 0x68, 0xd3, 0x66, 0x63, 0xae, 0xd6,
0xb9, 0xdd, 0xa7, 0x2a, 0x1d, 0x9e, 0xe2, 0x48, 0x7f, 0x9a, 0x75, 0x6e, 0x24, 0xf6, 0x04, 0xd6,
0xba, 0xe1, 0x24, 0x95, 0x98, 0x18, 0xef, 0x7b, 0x50, 0x51, 0x5c, 0xec, 0x97, 0xb5, 0x95, 0x5b,
0xcc, 0x29, 0x72, 0xad, 0xc2, 0x1e, 0x43, 0x83, 0xb2, 0x88, 0x6c, 0x89, 0xc2, 0xe8, 0xe0, 0xac,
0x1e, 0x1d, 0x06, 0x50, 0x59, 0x5e, 0x3a, 0x1e, 0xb8, 0x34, 0xfd, 0x98, 0x00, 0xd1, 0xe0, 0xd3,
0x84, 0x72, 0x3f, 0xd0, 0xcf, 0x53, 0xe6, 0x6a, 0x49, 0x88, 0xb8, 0xa4, 0xcb, 0x28, 0x44, 0xa8,
0xbf, 0x65, 0x53, 0x3f, 0x87, 0xfa, 0xf9, 0xef, 0xf2, 0x0b, 0xd8, 0x01, 0xa2, 0x5c, 0x18, 0x20,
0x3e, 0x86, 0xfa, 0x53, 0x29, 0x13, 0x3d, 0x77, 0xac, 0x43, 0xc9, 0xef, 0x91, 0x25, 0x97, 0x97,
0xfc, 0x9e, 0x6a, 0x9f, 0xdd, 0x53, 0x1c, 0x9e, 0xa5, 0x66, 0x3a, 0xbc, 0xcf, 0x33, 0x99, 0x7d,
0x01, 0xcd, 0xec, 0xa0, 0x9d, 0x7c, 0x3e, 0x80, 0x2a, 0xc9, 0x36, 0x3e, 0x85, 0xce, 0x9c, 0xeb,
0x1a, 0x95, 0x67, 0xcd, 0x3f, 0xaf, 0xda, 0xce, 0x5f, 0x57, 0x6d, 0xe7, 0xef, 0xab, 0xb6, 0xf3,
0xdb, 0x3f, 0xed, 0xb7, 0x8e, 0xab, 0x34, 0xcf, 0x7e, 0xf4, 0x26, 0x00, 0x00, 0xff, 0xff, 0x13,
0x56, 0xc4, 0x2f, 0xe0, 0x0a, 0x00, 0x00,
}

10
internal/private.proto
View file

@ -139,3 +139,13 @@ message DeleteViewMessage {
string Frame = 2;
string View = 3;
}
// AttrBlock represents a checksummed block of the attribute store.
message AttrBlock {
uint64 ID = 1;
bytes Checksum = 2;
}
message AttrBlockRequest {
repeated AttrBlock Blocks = 1;
}

332
internal/public.pb.go
View file

@ -20,6 +20,7 @@
QueryResult
ImportRequest
ImportValueRequest
AttrBlockResponse
*/
package internal
@ -490,6 +491,22 @@ func (m *ImportValueRequest) GetValues() []int64 {
return nil
}
type AttrBlockResponse struct {
Attrs map[uint64]*AttrMap `protobuf:"bytes,1,rep,name=Attrs" json:"Attrs,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}
func (m *AttrBlockResponse) Reset() { *m = AttrBlockResponse{} }
func (m *AttrBlockResponse) String() string { return proto.CompactTextString(m) }
func (*AttrBlockResponse) ProtoMessage() {}
func (*AttrBlockResponse) Descriptor() ([]byte, []int) { return fileDescriptorPublic, []int{12} }
func (m *AttrBlockResponse) GetAttrs() map[uint64]*AttrMap {
if m != nil {
return m.Attrs
}
return nil
}
func init() {
proto.RegisterType((*Bitmap)(nil), "internal.Bitmap")
proto.RegisterType((*Pair)(nil), "internal.Pair")
@ -503,6 +520,7 @@ func init() {
proto.RegisterType((*QueryResult)(nil), "internal.QueryResult")
proto.RegisterType((*ImportRequest)(nil), "internal.ImportRequest")
proto.RegisterType((*ImportValueRequest)(nil), "internal.ImportValueRequest")
proto.RegisterType((*AttrBlockResponse)(nil), "internal.AttrBlockResponse")
}
func (m *Bitmap) Marshal() (dAtA []byte, err error) {
size := m.Size()
@ -1118,6 +1136,51 @@ func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *AttrBlockResponse) 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 *AttrBlockResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Attrs) > 0 {
for k, _ := range m.Attrs {
dAtA[i] = 0xa
i++
v := m.Attrs[k]
msgSize := 0
if v != nil {
msgSize = v.Size()
msgSize += 1 + sovPublic(uint64(msgSize))
}
mapSize := 1 + sovPublic(uint64(k)) + msgSize
i = encodeVarintPublic(dAtA, i, uint64(mapSize))
dAtA[i] = 0x8
i++
i = encodeVarintPublic(dAtA, i, uint64(k))
if v != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPublic(dAtA, i, uint64(v.Size()))
n17, err := v.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n17
}
}
}
return i, nil
}
func encodeVarintPublic(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
@ -1388,6 +1451,25 @@ func (m *ImportValueRequest) Size() (n int) {
return n
}
func (m *AttrBlockResponse) Size() (n int) {
var l int
_ = l
if len(m.Attrs) > 0 {
for k, v := range m.Attrs {
_ = k
_ = v
l = 0
if v != nil {
l = v.Size()
l += 1 + sovPublic(uint64(l))
}
mapEntrySize := 1 + sovPublic(uint64(k)) + l
n += mapEntrySize + 1 + sovPublic(uint64(mapEntrySize))
}
}
return n
}
func sovPublic(x uint64) (n int) {
for {
n++
@ -3326,6 +3408,168 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *AttrBlockResponse) 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: AttrBlockResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AttrBlockResponse: 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
}
if m.Attrs == nil {
m.Attrs = make(map[uint64]*AttrMap)
}
var mapkey uint64
var mapvalue *AttrMap
for iNdEx < postIndex {
entryPreIndex := 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)
if fieldNum == 1 {
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
mapkey |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
} else if fieldNum == 2 {
var mapmsglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPublic
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
mapmsglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if mapmsglen < 0 {
return ErrInvalidLengthPublic
}
postmsgIndex := iNdEx + mapmsglen
if mapmsglen < 0 {
return ErrInvalidLengthPublic
}
if postmsgIndex > l {
return io.ErrUnexpectedEOF
}
mapvalue = &AttrMap{}
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
return err
}
iNdEx = postmsgIndex
} else {
iNdEx = entryPreIndex
skippy, err := skipPublic(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.Attrs[mapkey] = mapvalue
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPublic(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthPublic
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipPublic(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
@ -3434,46 +3678,50 @@ var (
func init() { proto.RegisterFile("public.proto", fileDescriptorPublic) }
var fileDescriptorPublic = []byte{
// 651 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcb, 0x6e, 0xd3, 0x40,
0x14, 0x65, 0x62, 0xe7, 0x75, 0x93, 0x56, 0xd5, 0x08, 0x8a, 0x85, 0x50, 0x14, 0x59, 0x2c, 0xbc,
0x4a, 0xa5, 0xf0, 0x01, 0x08, 0xb7, 0xa9, 0x64, 0x21, 0x2a, 0x98, 0x14, 0xf6, 0x6e, 0x3b, 0x2a,
0x96, 0xfc, 0x62, 0x3c, 0x16, 0xed, 0x77, 0xb0, 0x61, 0xcd, 0x06, 0x7e, 0x80, 0x1d, 0x1f, 0xc0,
0x92, 0x4f, 0x40, 0xe1, 0x47, 0xd0, 0xbd, 0xe3, 0x89, 0x1d, 0x16, 0xc0, 0x82, 0xdd, 0x9c, 0x73,
0x1f, 0xbe, 0x8f, 0x73, 0x0d, 0xd3, 0xb2, 0xbe, 0x48, 0x93, 0xcb, 0x45, 0xa9, 0x0a, 0x5d, 0xf0,
0x51, 0x92, 0x6b, 0xa9, 0xf2, 0x38, 0xf5, 0x43, 0x18, 0x84, 0x89, 0xce, 0xe2, 0x92, 0x73, 0x70,
0xc3, 0x44, 0x57, 0x1e, 0x9b, 0x3b, 0x81, 0x2b, 0xe8, 0xcd, 0x1f, 0x41, 0xff, 0xa9, 0xd6, 0xaa,
0xf2, 0x7a, 0x73, 0x27, 0x98, 0x2c, 0xf7, 0x17, 0x36, 0x6e, 0x81, 0xb4, 0x30, 0x46, 0x7f, 0x01,
0xee, 0x8b, 0x38, 0x51, 0xfc, 0x00, 0x9c, 0x67, 0xf2, 0xd6, 0x63, 0x73, 0x16, 0xb8, 0x02, 0x9f,
0xfc, 0x2e, 0xf4, 0x8f, 0x8b, 0x3a, 0xd7, 0x5e, 0x8f, 0x38, 0x03, 0xfc, 0x25, 0x8c, 0xd6, 0x75,
0x46, 0x6f, 0x8c, 0x59, 0xd7, 0x19, 0xc5, 0x38, 0x02, 0x9f, 0xbb, 0x31, 0x8e, 0x8d, 0x79, 0x05,
0x4e, 0x98, 0x68, 0x34, 0x8a, 0xe2, 0x5d, 0x74, 0xd2, 0x7c, 0xc4, 0x00, 0xfe, 0x00, 0x46, 0xc7,
0x45, 0x5a, 0x67, 0x79, 0x74, 0xd2, 0x7c, 0x69, 0x8b, 0xf9, 0x43, 0x18, 0x9f, 0x27, 0x99, 0xac,
0x74, 0x9c, 0x95, 0x9e, 0x43, 0x29, 0x5b, 0xc2, 0x5f, 0xc1, 0x9e, 0xf1, 0xc4, 0x4e, 0xd6, 0x52,
0xf3, 0x7d, 0xe8, 0x6d, 0xb3, 0xf7, 0xa2, 0x93, 0x7f, 0x9c, 0xc0, 0x67, 0x06, 0x2e, 0xbe, 0xba,
0x23, 0x18, 0x9b, 0x11, 0x70, 0x70, 0xcf, 0x6f, 0x4b, 0xd9, 0xd4, 0x45, 0x6f, 0x3e, 0x87, 0xc9,
0x5a, 0xab, 0x24, 0xbf, 0x7e, 0x1d, 0xa7, 0xb5, 0xa4, 0xaa, 0xc6, 0xa2, 0x4b, 0x61, 0x47, 0x51,
0xae, 0x8d, 0xd9, 0xa5, 0xa2, 0xb7, 0x18, 0x3b, 0x0a, 0x8b, 0x22, 0x35, 0xc6, 0xfe, 0x9c, 0x05,
0x23, 0xd1, 0x12, 0x7c, 0x06, 0x70, 0x9a, 0x16, 0x71, 0x13, 0x3b, 0x98, 0xb3, 0x80, 0x89, 0x0e,
0xe3, 0x1f, 0xc1, 0x10, 0x2b, 0x7d, 0x1e, 0x97, 0x6d, 0x6f, 0xec, 0x4f, 0xbd, 0x7d, 0x65, 0x30,
0x7d, 0x59, 0x4b, 0x75, 0x2b, 0xe4, 0xdb, 0x5a, 0x56, 0xb4, 0x03, 0xc2, 0x4d, 0x97, 0x06, 0xf0,
0x43, 0x18, 0xac, 0xd3, 0xe4, 0x52, 0x9a, 0x49, 0xb9, 0xa2, 0x41, 0xd8, 0x6b, 0x3b, 0xe1, 0x8a,
0x7a, 0x1d, 0x89, 0x2e, 0x85, 0x91, 0x42, 0x66, 0x85, 0xb6, 0xcd, 0x34, 0x88, 0xfb, 0x30, 0x5d,
0xdd, 0x5c, 0xa6, 0xf5, 0x95, 0x34, 0xa1, 0x03, 0xb2, 0xee, 0x70, 0x98, 0xbd, 0xc1, 0xa4, 0xdd,
0xa1, 0xc9, 0xde, 0xa1, 0xfc, 0xf7, 0x0c, 0xf6, 0x9a, 0xf2, 0xab, 0xb2, 0xc8, 0x2b, 0x89, 0x3b,
0x5a, 0x29, 0x65, 0x77, 0xb4, 0x52, 0x8a, 0x1f, 0xc1, 0x50, 0xc8, 0xaa, 0x4e, 0xb5, 0x5d, 0xf3,
0xbd, 0x76, 0x14, 0x36, 0xb6, 0x4e, 0xb5, 0xb0, 0x5e, 0xfc, 0x09, 0xec, 0xef, 0xc8, 0x06, 0xfb,
0xc2, 0xb8, 0xfb, 0x6d, 0xdc, 0x8e, 0x5d, 0xfc, 0xe6, 0xee, 0x7f, 0x61, 0x30, 0xe9, 0x64, 0xe6,
0x81, 0x3d, 0x43, 0x2a, 0x6b, 0xb2, 0x3c, 0x68, 0x13, 0x19, 0x5e, 0xd8, 0x33, 0x9d, 0x02, 0x3b,
0x6b, 0xc4, 0xc4, 0xce, 0x70, 0x85, 0x78, 0x7a, 0xf6, 0xfb, 0x9d, 0x15, 0x22, 0x2d, 0x8c, 0x91,
0x7b, 0x30, 0x3c, 0x7e, 0x13, 0xe7, 0xd7, 0xf2, 0x8a, 0xc4, 0x34, 0x12, 0x16, 0xf2, 0x45, 0x7b,
0x8a, 0x34, 0xfd, 0xc9, 0x92, 0xb7, 0x29, 0xac, 0x45, 0x6c, 0x7d, 0xfc, 0x4f, 0x0c, 0xf6, 0xa2,
0xac, 0x2c, 0x94, 0xee, 0xa8, 0x21, 0xca, 0xaf, 0xe4, 0x8d, 0x55, 0x03, 0x01, 0x64, 0x4f, 0x55,
0x9c, 0x19, 0xd9, 0x8f, 0x85, 0x01, 0xc8, 0x92, 0x2a, 0x48, 0x05, 0xae, 0x30, 0x80, 0xf6, 0x8f,
0x67, 0x5c, 0x79, 0xae, 0x51, 0x8e, 0x41, 0xa8, 0x73, 0x7b, 0xc5, 0x95, 0xd7, 0x27, 0x53, 0x4b,
0xa0, 0xce, 0xb7, 0x67, 0x8c, 0xda, 0x70, 0x02, 0x47, 0x74, 0x18, 0xff, 0x23, 0x03, 0x6e, 0x2a,
0x25, 0xdd, 0xff, 0xbf, 0x72, 0xd1, 0x37, 0x91, 0xa9, 0x19, 0x25, 0xfa, 0x22, 0xf8, 0x4b, 0xb1,
0x87, 0x30, 0xa0, 0x2a, 0x6c, 0xa1, 0x0d, 0x0a, 0x0f, 0xbe, 0x6d, 0x66, 0xec, 0xfb, 0x66, 0xc6,
0x7e, 0x6c, 0x66, 0xec, 0xc3, 0xcf, 0xd9, 0x9d, 0x8b, 0x01, 0xfd, 0xa0, 0x1f, 0xff, 0x0a, 0x00,
0x00, 0xff, 0xff, 0x4d, 0x1e, 0xdf, 0xba, 0xb0, 0x05, 0x00, 0x00,
// 720 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcb, 0x6e, 0xd3, 0x40,
0x14, 0x65, 0x62, 0xe7, 0x75, 0x93, 0x56, 0xed, 0x08, 0x8a, 0x55, 0xa1, 0x28, 0xb2, 0x10, 0x64,
0x95, 0x4a, 0x61, 0x83, 0x10, 0x12, 0x22, 0x6d, 0x2a, 0x45, 0x55, 0x2b, 0x98, 0x14, 0xf6, 0x6e,
0x3a, 0x2a, 0x56, 0xfd, 0xc2, 0x1e, 0x43, 0xf3, 0x1d, 0x6c, 0x58, 0xb1, 0x60, 0x03, 0x3f, 0xc0,
0x8e, 0x0f, 0x60, 0xc9, 0x27, 0xa0, 0xf2, 0x23, 0xe8, 0xde, 0xf1, 0xc4, 0x36, 0x0b, 0x60, 0xc1,
0x6e, 0xce, 0xb9, 0x0f, 0xdf, 0xc7, 0xb9, 0x09, 0xf4, 0x93, 0xfc, 0x2c, 0xf0, 0x97, 0xe3, 0x24,
0x8d, 0x55, 0xcc, 0x3b, 0x7e, 0xa4, 0x64, 0x1a, 0x79, 0x81, 0x3b, 0x85, 0xd6, 0xd4, 0x57, 0xa1,
0x97, 0x70, 0x0e, 0xf6, 0xd4, 0x57, 0x99, 0xc3, 0x86, 0xd6, 0xc8, 0x16, 0xf4, 0xe6, 0x77, 0xa1,
0xf9, 0x54, 0xa9, 0x34, 0x73, 0x1a, 0x43, 0x6b, 0xd4, 0x9b, 0x6c, 0x8e, 0x4d, 0xdc, 0x18, 0x69,
0xa1, 0x8d, 0xee, 0x18, 0xec, 0x67, 0x9e, 0x9f, 0xf2, 0x2d, 0xb0, 0x8e, 0xe4, 0xca, 0x61, 0x43,
0x36, 0xb2, 0x05, 0x3e, 0xf9, 0x4d, 0x68, 0xee, 0xc7, 0x79, 0xa4, 0x9c, 0x06, 0x71, 0x1a, 0xb8,
0x13, 0xe8, 0x2c, 0xf2, 0x90, 0xde, 0x18, 0xb3, 0xc8, 0x43, 0x8a, 0xb1, 0x04, 0x3e, 0xeb, 0x31,
0x96, 0x89, 0x79, 0x01, 0xd6, 0xd4, 0x57, 0x68, 0x14, 0xf1, 0xdb, 0xf9, 0x41, 0xf1, 0x11, 0x0d,
0xf8, 0x2e, 0x74, 0xf6, 0xe3, 0x20, 0x0f, 0xa3, 0xf9, 0x41, 0xf1, 0xa5, 0x35, 0xe6, 0x77, 0xa0,
0x7b, 0xea, 0x87, 0x32, 0x53, 0x5e, 0x98, 0x38, 0x16, 0xa5, 0x2c, 0x09, 0x77, 0x06, 0x1b, 0xda,
0x13, 0x3b, 0x59, 0x48, 0xc5, 0x37, 0xa1, 0xb1, 0xce, 0xde, 0x98, 0x1f, 0xfc, 0xe3, 0x04, 0x3e,
0x33, 0xb0, 0xf1, 0x55, 0x1d, 0x41, 0x57, 0x8f, 0x80, 0x83, 0x7d, 0xba, 0x4a, 0x64, 0x51, 0x17,
0xbd, 0xf9, 0x10, 0x7a, 0x0b, 0x95, 0xfa, 0xd1, 0xc5, 0x4b, 0x2f, 0xc8, 0x25, 0x55, 0xd5, 0x15,
0x55, 0x0a, 0x3b, 0x9a, 0x47, 0x4a, 0x9b, 0x6d, 0x2a, 0x7a, 0x8d, 0xb1, 0xa3, 0x69, 0x1c, 0x07,
0xda, 0xd8, 0x1c, 0xb2, 0x51, 0x47, 0x94, 0x04, 0x1f, 0x00, 0x1c, 0x06, 0xb1, 0x57, 0xc4, 0xb6,
0x86, 0x6c, 0xc4, 0x44, 0x85, 0x71, 0xf7, 0xa0, 0x8d, 0x95, 0x1e, 0x7b, 0x49, 0xd9, 0x1b, 0xfb,
0x53, 0x6f, 0x5f, 0x19, 0xf4, 0x9f, 0xe7, 0x32, 0x5d, 0x09, 0xf9, 0x3a, 0x97, 0x19, 0xed, 0x80,
0x70, 0xd1, 0xa5, 0x06, 0x7c, 0x07, 0x5a, 0x8b, 0xc0, 0x5f, 0x4a, 0x3d, 0x29, 0x5b, 0x14, 0x08,
0x7b, 0x2d, 0x27, 0x9c, 0x51, 0xaf, 0x1d, 0x51, 0xa5, 0x30, 0x52, 0xc8, 0x30, 0x56, 0xa6, 0x99,
0x02, 0x71, 0x17, 0xfa, 0xb3, 0xab, 0x65, 0x90, 0x9f, 0x4b, 0x1d, 0xda, 0x22, 0x6b, 0x8d, 0xc3,
0xec, 0x05, 0x26, 0xed, 0xb6, 0x75, 0xf6, 0x0a, 0xe5, 0xbe, 0x63, 0xb0, 0x51, 0x94, 0x9f, 0x25,
0x71, 0x94, 0x49, 0xdc, 0xd1, 0x2c, 0x4d, 0xcd, 0x8e, 0x66, 0x69, 0xca, 0xf7, 0xa0, 0x2d, 0x64,
0x96, 0x07, 0xca, 0xac, 0xf9, 0x56, 0x39, 0x0a, 0x13, 0x9b, 0x07, 0x4a, 0x18, 0x2f, 0xfe, 0x04,
0x36, 0x6b, 0xb2, 0xc1, 0xbe, 0x30, 0xee, 0x76, 0x19, 0x57, 0xb3, 0x8b, 0xdf, 0xdc, 0xdd, 0x2f,
0x0c, 0x7a, 0x95, 0xcc, 0x7c, 0x64, 0xce, 0x90, 0xca, 0xea, 0x4d, 0xb6, 0xca, 0x44, 0x9a, 0x17,
0xe6, 0x4c, 0xfb, 0xc0, 0x4e, 0x0a, 0x31, 0xb1, 0x13, 0x5c, 0x21, 0x9e, 0x9e, 0xf9, 0x7e, 0x65,
0x85, 0x48, 0x0b, 0x6d, 0xe4, 0x0e, 0xb4, 0xf7, 0x5f, 0x79, 0xd1, 0x85, 0x3c, 0x27, 0x31, 0x75,
0x84, 0x81, 0x7c, 0x5c, 0x9e, 0x22, 0x4d, 0xbf, 0x37, 0xe1, 0x65, 0x0a, 0x63, 0x11, 0x6b, 0x1f,
0xf7, 0x13, 0x83, 0x8d, 0x79, 0x98, 0xc4, 0xa9, 0xaa, 0xa8, 0x61, 0x1e, 0x9d, 0xcb, 0x2b, 0xa3,
0x06, 0x02, 0xc8, 0x1e, 0xa6, 0x5e, 0xa8, 0x65, 0xdf, 0x15, 0x1a, 0x20, 0x4b, 0xaa, 0x20, 0x15,
0xd8, 0x42, 0x03, 0xda, 0x3f, 0x9e, 0x71, 0xe6, 0xd8, 0x5a, 0x39, 0x1a, 0xa1, 0xce, 0xcd, 0x15,
0x67, 0x4e, 0x93, 0x4c, 0x25, 0x81, 0x3a, 0x5f, 0x9f, 0x31, 0x6a, 0xc3, 0x1a, 0x59, 0xa2, 0xc2,
0xb8, 0x1f, 0x19, 0x70, 0x5d, 0x29, 0xe9, 0xfe, 0xff, 0x95, 0x8b, 0xbe, 0xbe, 0x0c, 0xf4, 0x28,
0xd1, 0x17, 0xc1, 0x5f, 0x8a, 0xdd, 0x81, 0x16, 0x55, 0x61, 0x0a, 0x2d, 0x90, 0xfb, 0x81, 0xc1,
0x36, 0x6a, 0x62, 0x1a, 0xc4, 0xcb, 0xcb, 0xb5, 0x40, 0x1f, 0xd7, 0xef, 0xf2, 0x5e, 0xfd, 0x2e,
0x6b, 0xbe, 0xc4, 0x64, 0xb3, 0x48, 0xa5, 0xab, 0xe2, 0x5e, 0x77, 0x8f, 0x00, 0x4a, 0x12, 0xc5,
0x7e, 0x59, 0xfe, 0x26, 0x5f, 0xca, 0x15, 0xbf, 0x0f, 0xcd, 0x37, 0xf4, 0xdb, 0xd0, 0xa0, 0x7d,
0x6f, 0xd7, 0xb3, 0x1f, 0x7b, 0x89, 0xd0, 0xf6, 0x47, 0x8d, 0x87, 0x6c, 0xba, 0xf5, 0xed, 0x7a,
0xc0, 0xbe, 0x5f, 0x0f, 0xd8, 0x8f, 0xeb, 0x01, 0x7b, 0xff, 0x73, 0x70, 0xe3, 0xac, 0x45, 0xff,
0x20, 0x0f, 0x7e, 0x05, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xaa, 0x7d, 0x27, 0x51, 0x06, 0x00, 0x00,
}

4
internal/public.proto
View file

@ -81,3 +81,7 @@ message ImportValueRequest {
repeated uint64 ColumnIDs = 5;
repeated int64 Values = 6;
}
message AttrBlockResponse {
map<uint64, AttrMap> Attrs = 1;
}