1863 lines
72 KiB
Go
1863 lines
72 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// source: Client.proto
|
|
|
|
package pb
|
|
|
|
import proto "github.com/golang/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// *
|
|
// Consistency defines the expected consistency level for an operation.
|
|
type Consistency int32
|
|
|
|
const (
|
|
Consistency_STRONG Consistency = 0
|
|
Consistency_TIMELINE Consistency = 1
|
|
)
|
|
|
|
var Consistency_name = map[int32]string{
|
|
0: "STRONG",
|
|
1: "TIMELINE",
|
|
}
|
|
var Consistency_value = map[string]int32{
|
|
"STRONG": 0,
|
|
"TIMELINE": 1,
|
|
}
|
|
|
|
func (x Consistency) Enum() *Consistency {
|
|
p := new(Consistency)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x Consistency) String() string {
|
|
return proto.EnumName(Consistency_name, int32(x))
|
|
}
|
|
func (x *Consistency) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(Consistency_value, data, "Consistency")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = Consistency(value)
|
|
return nil
|
|
}
|
|
func (Consistency) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
|
|
|
|
type MutationProto_Durability int32
|
|
|
|
const (
|
|
MutationProto_USE_DEFAULT MutationProto_Durability = 0
|
|
MutationProto_SKIP_WAL MutationProto_Durability = 1
|
|
MutationProto_ASYNC_WAL MutationProto_Durability = 2
|
|
MutationProto_SYNC_WAL MutationProto_Durability = 3
|
|
MutationProto_FSYNC_WAL MutationProto_Durability = 4
|
|
)
|
|
|
|
var MutationProto_Durability_name = map[int32]string{
|
|
0: "USE_DEFAULT",
|
|
1: "SKIP_WAL",
|
|
2: "ASYNC_WAL",
|
|
3: "SYNC_WAL",
|
|
4: "FSYNC_WAL",
|
|
}
|
|
var MutationProto_Durability_value = map[string]int32{
|
|
"USE_DEFAULT": 0,
|
|
"SKIP_WAL": 1,
|
|
"ASYNC_WAL": 2,
|
|
"SYNC_WAL": 3,
|
|
"FSYNC_WAL": 4,
|
|
}
|
|
|
|
func (x MutationProto_Durability) Enum() *MutationProto_Durability {
|
|
p := new(MutationProto_Durability)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MutationProto_Durability) String() string {
|
|
return proto.EnumName(MutationProto_Durability_name, int32(x))
|
|
}
|
|
func (x *MutationProto_Durability) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MutationProto_Durability_value, data, "MutationProto_Durability")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_Durability(value)
|
|
return nil
|
|
}
|
|
func (MutationProto_Durability) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{8, 0} }
|
|
|
|
type MutationProto_MutationType int32
|
|
|
|
const (
|
|
MutationProto_APPEND MutationProto_MutationType = 0
|
|
MutationProto_INCREMENT MutationProto_MutationType = 1
|
|
MutationProto_PUT MutationProto_MutationType = 2
|
|
MutationProto_DELETE MutationProto_MutationType = 3
|
|
)
|
|
|
|
var MutationProto_MutationType_name = map[int32]string{
|
|
0: "APPEND",
|
|
1: "INCREMENT",
|
|
2: "PUT",
|
|
3: "DELETE",
|
|
}
|
|
var MutationProto_MutationType_value = map[string]int32{
|
|
"APPEND": 0,
|
|
"INCREMENT": 1,
|
|
"PUT": 2,
|
|
"DELETE": 3,
|
|
}
|
|
|
|
func (x MutationProto_MutationType) Enum() *MutationProto_MutationType {
|
|
p := new(MutationProto_MutationType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MutationProto_MutationType) String() string {
|
|
return proto.EnumName(MutationProto_MutationType_name, int32(x))
|
|
}
|
|
func (x *MutationProto_MutationType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MutationProto_MutationType_value, data, "MutationProto_MutationType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_MutationType(value)
|
|
return nil
|
|
}
|
|
func (MutationProto_MutationType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor3, []int{8, 1}
|
|
}
|
|
|
|
type MutationProto_DeleteType int32
|
|
|
|
const (
|
|
MutationProto_DELETE_ONE_VERSION MutationProto_DeleteType = 0
|
|
MutationProto_DELETE_MULTIPLE_VERSIONS MutationProto_DeleteType = 1
|
|
MutationProto_DELETE_FAMILY MutationProto_DeleteType = 2
|
|
MutationProto_DELETE_FAMILY_VERSION MutationProto_DeleteType = 3
|
|
)
|
|
|
|
var MutationProto_DeleteType_name = map[int32]string{
|
|
0: "DELETE_ONE_VERSION",
|
|
1: "DELETE_MULTIPLE_VERSIONS",
|
|
2: "DELETE_FAMILY",
|
|
3: "DELETE_FAMILY_VERSION",
|
|
}
|
|
var MutationProto_DeleteType_value = map[string]int32{
|
|
"DELETE_ONE_VERSION": 0,
|
|
"DELETE_MULTIPLE_VERSIONS": 1,
|
|
"DELETE_FAMILY": 2,
|
|
"DELETE_FAMILY_VERSION": 3,
|
|
}
|
|
|
|
func (x MutationProto_DeleteType) Enum() *MutationProto_DeleteType {
|
|
p := new(MutationProto_DeleteType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MutationProto_DeleteType) String() string {
|
|
return proto.EnumName(MutationProto_DeleteType_name, int32(x))
|
|
}
|
|
func (x *MutationProto_DeleteType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MutationProto_DeleteType_value, data, "MutationProto_DeleteType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_DeleteType(value)
|
|
return nil
|
|
}
|
|
func (MutationProto_DeleteType) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{8, 2} }
|
|
|
|
// *
|
|
// The protocol buffer version of Authorizations.
|
|
type Authorizations struct {
|
|
Label []string `protobuf:"bytes,1,rep,name=label" json:"label,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Authorizations) Reset() { *m = Authorizations{} }
|
|
func (m *Authorizations) String() string { return proto.CompactTextString(m) }
|
|
func (*Authorizations) ProtoMessage() {}
|
|
func (*Authorizations) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
|
|
|
|
func (m *Authorizations) GetLabel() []string {
|
|
if m != nil {
|
|
return m.Label
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// The protocol buffer version of CellVisibility.
|
|
type CellVisibility struct {
|
|
Expression *string `protobuf:"bytes,1,req,name=expression" json:"expression,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CellVisibility) Reset() { *m = CellVisibility{} }
|
|
func (m *CellVisibility) String() string { return proto.CompactTextString(m) }
|
|
func (*CellVisibility) ProtoMessage() {}
|
|
func (*CellVisibility) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
|
|
|
|
func (m *CellVisibility) GetExpression() string {
|
|
if m != nil && m.Expression != nil {
|
|
return *m.Expression
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// *
|
|
// Container for a list of column qualifier names of a family.
|
|
type Column struct {
|
|
Family []byte `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
|
|
Qualifier [][]byte `protobuf:"bytes,2,rep,name=qualifier" json:"qualifier,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Column) Reset() { *m = Column{} }
|
|
func (m *Column) String() string { return proto.CompactTextString(m) }
|
|
func (*Column) ProtoMessage() {}
|
|
func (*Column) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
|
|
|
|
func (m *Column) GetFamily() []byte {
|
|
if m != nil {
|
|
return m.Family
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Column) GetQualifier() [][]byte {
|
|
if m != nil {
|
|
return m.Qualifier
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// The protocol buffer version of Get.
|
|
// Unless existence_only is specified, return all the requested data
|
|
// for the row that matches exactly, or the one that immediately
|
|
// precedes it if closest_row_before is specified.
|
|
type Get struct {
|
|
Row []byte `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
|
|
Column []*Column `protobuf:"bytes,2,rep,name=column" json:"column,omitempty"`
|
|
Attribute []*NameBytesPair `protobuf:"bytes,3,rep,name=attribute" json:"attribute,omitempty"`
|
|
Filter *Filter `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"`
|
|
TimeRange *TimeRange `protobuf:"bytes,5,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
|
|
MaxVersions *uint32 `protobuf:"varint,6,opt,name=max_versions,json=maxVersions,def=1" json:"max_versions,omitempty"`
|
|
CacheBlocks *bool `protobuf:"varint,7,opt,name=cache_blocks,json=cacheBlocks,def=1" json:"cache_blocks,omitempty"`
|
|
StoreLimit *uint32 `protobuf:"varint,8,opt,name=store_limit,json=storeLimit" json:"store_limit,omitempty"`
|
|
StoreOffset *uint32 `protobuf:"varint,9,opt,name=store_offset,json=storeOffset" json:"store_offset,omitempty"`
|
|
// The result isn't asked for, just check for
|
|
// the existence.
|
|
ExistenceOnly *bool `protobuf:"varint,10,opt,name=existence_only,json=existenceOnly,def=0" json:"existence_only,omitempty"`
|
|
// If the row to get doesn't exist, return the
|
|
// closest row before.
|
|
ClosestRowBefore *bool `protobuf:"varint,11,opt,name=closest_row_before,json=closestRowBefore,def=0" json:"closest_row_before,omitempty"`
|
|
Consistency *Consistency `protobuf:"varint,12,opt,name=consistency,enum=pb.Consistency,def=0" json:"consistency,omitempty"`
|
|
CfTimeRange []*ColumnFamilyTimeRange `protobuf:"bytes,13,rep,name=cf_time_range,json=cfTimeRange" json:"cf_time_range,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Get) Reset() { *m = Get{} }
|
|
func (m *Get) String() string { return proto.CompactTextString(m) }
|
|
func (*Get) ProtoMessage() {}
|
|
func (*Get) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
|
|
|
|
const Default_Get_MaxVersions uint32 = 1
|
|
const Default_Get_CacheBlocks bool = true
|
|
const Default_Get_ExistenceOnly bool = false
|
|
const Default_Get_ClosestRowBefore bool = false
|
|
const Default_Get_Consistency Consistency = Consistency_STRONG
|
|
|
|
func (m *Get) GetRow() []byte {
|
|
if m != nil {
|
|
return m.Row
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Get) GetColumn() []*Column {
|
|
if m != nil {
|
|
return m.Column
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Get) GetAttribute() []*NameBytesPair {
|
|
if m != nil {
|
|
return m.Attribute
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Get) GetFilter() *Filter {
|
|
if m != nil {
|
|
return m.Filter
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Get) GetTimeRange() *TimeRange {
|
|
if m != nil {
|
|
return m.TimeRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Get) GetMaxVersions() uint32 {
|
|
if m != nil && m.MaxVersions != nil {
|
|
return *m.MaxVersions
|
|
}
|
|
return Default_Get_MaxVersions
|
|
}
|
|
|
|
func (m *Get) GetCacheBlocks() bool {
|
|
if m != nil && m.CacheBlocks != nil {
|
|
return *m.CacheBlocks
|
|
}
|
|
return Default_Get_CacheBlocks
|
|
}
|
|
|
|
func (m *Get) GetStoreLimit() uint32 {
|
|
if m != nil && m.StoreLimit != nil {
|
|
return *m.StoreLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Get) GetStoreOffset() uint32 {
|
|
if m != nil && m.StoreOffset != nil {
|
|
return *m.StoreOffset
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Get) GetExistenceOnly() bool {
|
|
if m != nil && m.ExistenceOnly != nil {
|
|
return *m.ExistenceOnly
|
|
}
|
|
return Default_Get_ExistenceOnly
|
|
}
|
|
|
|
func (m *Get) GetClosestRowBefore() bool {
|
|
if m != nil && m.ClosestRowBefore != nil {
|
|
return *m.ClosestRowBefore
|
|
}
|
|
return Default_Get_ClosestRowBefore
|
|
}
|
|
|
|
func (m *Get) GetConsistency() Consistency {
|
|
if m != nil && m.Consistency != nil {
|
|
return *m.Consistency
|
|
}
|
|
return Default_Get_Consistency
|
|
}
|
|
|
|
func (m *Get) GetCfTimeRange() []*ColumnFamilyTimeRange {
|
|
if m != nil {
|
|
return m.CfTimeRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Result struct {
|
|
// Result includes the Cells or else it just has a count of Cells
|
|
// that are carried otherwise.
|
|
Cell []*Cell `protobuf:"bytes,1,rep,name=cell" json:"cell,omitempty"`
|
|
// The below count is set when the associated cells are
|
|
// not part of this protobuf message; they are passed alongside
|
|
// and then this Message is just a placeholder with metadata.
|
|
// The count is needed to know how many to peel off the block of Cells as
|
|
// ours. NOTE: This is different from the pb managed cell_count of the
|
|
// 'cell' field above which is non-null when the cells are pb'd.
|
|
AssociatedCellCount *int32 `protobuf:"varint,2,opt,name=associated_cell_count,json=associatedCellCount" json:"associated_cell_count,omitempty"`
|
|
// used for Get to check existence only. Not set if existence_only was not set to true
|
|
// in the query.
|
|
Exists *bool `protobuf:"varint,3,opt,name=exists" json:"exists,omitempty"`
|
|
// Whether or not the results are coming from possibly stale data
|
|
Stale *bool `protobuf:"varint,4,opt,name=stale,def=0" json:"stale,omitempty"`
|
|
// Whether or not the entire result could be returned. Results will be split when
|
|
// the RPC chunk size limit is reached. Partial results contain only a subset of the
|
|
// cells for a row and must be combined with a result containing the remaining cells
|
|
// to form a complete result
|
|
Partial *bool `protobuf:"varint,5,opt,name=partial,def=0" json:"partial,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Result) Reset() { *m = Result{} }
|
|
func (m *Result) String() string { return proto.CompactTextString(m) }
|
|
func (*Result) ProtoMessage() {}
|
|
func (*Result) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} }
|
|
|
|
const Default_Result_Stale bool = false
|
|
const Default_Result_Partial bool = false
|
|
|
|
func (m *Result) GetCell() []*Cell {
|
|
if m != nil {
|
|
return m.Cell
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Result) GetAssociatedCellCount() int32 {
|
|
if m != nil && m.AssociatedCellCount != nil {
|
|
return *m.AssociatedCellCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Result) GetExists() bool {
|
|
if m != nil && m.Exists != nil {
|
|
return *m.Exists
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Result) GetStale() bool {
|
|
if m != nil && m.Stale != nil {
|
|
return *m.Stale
|
|
}
|
|
return Default_Result_Stale
|
|
}
|
|
|
|
func (m *Result) GetPartial() bool {
|
|
if m != nil && m.Partial != nil {
|
|
return *m.Partial
|
|
}
|
|
return Default_Result_Partial
|
|
}
|
|
|
|
// *
|
|
// The get request. Perform a single Get operation.
|
|
type GetRequest struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
Get *Get `protobuf:"bytes,2,req,name=get" json:"get,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *GetRequest) Reset() { *m = GetRequest{} }
|
|
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*GetRequest) ProtoMessage() {}
|
|
func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{5} }
|
|
|
|
func (m *GetRequest) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetRequest) GetGet() *Get {
|
|
if m != nil {
|
|
return m.Get
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type GetResponse struct {
|
|
Result *Result `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *GetResponse) Reset() { *m = GetResponse{} }
|
|
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*GetResponse) ProtoMessage() {}
|
|
func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{6} }
|
|
|
|
func (m *GetResponse) GetResult() *Result {
|
|
if m != nil {
|
|
return m.Result
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// Condition to check if the value of a given cell (row,
|
|
// family, qualifier) matches a value via a given comparator.
|
|
//
|
|
// Condition is used in check and mutate operations.
|
|
type Condition struct {
|
|
Row []byte `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
|
|
Family []byte `protobuf:"bytes,2,req,name=family" json:"family,omitempty"`
|
|
Qualifier []byte `protobuf:"bytes,3,req,name=qualifier" json:"qualifier,omitempty"`
|
|
CompareType *CompareType `protobuf:"varint,4,req,name=compare_type,json=compareType,enum=pb.CompareType" json:"compare_type,omitempty"`
|
|
Comparator *Comparator `protobuf:"bytes,5,req,name=comparator" json:"comparator,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Condition) Reset() { *m = Condition{} }
|
|
func (m *Condition) String() string { return proto.CompactTextString(m) }
|
|
func (*Condition) ProtoMessage() {}
|
|
func (*Condition) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{7} }
|
|
|
|
func (m *Condition) GetRow() []byte {
|
|
if m != nil {
|
|
return m.Row
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Condition) GetFamily() []byte {
|
|
if m != nil {
|
|
return m.Family
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Condition) GetQualifier() []byte {
|
|
if m != nil {
|
|
return m.Qualifier
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Condition) GetCompareType() CompareType {
|
|
if m != nil && m.CompareType != nil {
|
|
return *m.CompareType
|
|
}
|
|
return CompareType_LESS
|
|
}
|
|
|
|
func (m *Condition) GetComparator() *Comparator {
|
|
if m != nil {
|
|
return m.Comparator
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// A specific mutation inside a mutate request.
|
|
// It can be an append, increment, put or delete based
|
|
// on the mutation type. It can be fully filled in or
|
|
// only metadata present because data is being carried
|
|
// elsewhere outside of pb.
|
|
type MutationProto struct {
|
|
Row []byte `protobuf:"bytes,1,opt,name=row" json:"row,omitempty"`
|
|
MutateType *MutationProto_MutationType `protobuf:"varint,2,opt,name=mutate_type,json=mutateType,enum=pb.MutationProto_MutationType" json:"mutate_type,omitempty"`
|
|
ColumnValue []*MutationProto_ColumnValue `protobuf:"bytes,3,rep,name=column_value,json=columnValue" json:"column_value,omitempty"`
|
|
Timestamp *uint64 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
|
|
Attribute []*NameBytesPair `protobuf:"bytes,5,rep,name=attribute" json:"attribute,omitempty"`
|
|
Durability *MutationProto_Durability `protobuf:"varint,6,opt,name=durability,enum=pb.MutationProto_Durability,def=0" json:"durability,omitempty"`
|
|
// For some mutations, a result may be returned, in which case,
|
|
// time range can be specified for potential performance gain
|
|
TimeRange *TimeRange `protobuf:"bytes,7,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
|
|
// The below count is set when the associated cells are NOT
|
|
// part of this protobuf message; they are passed alongside
|
|
// and then this Message is a placeholder with metadata. The
|
|
// count is needed to know how many to peel off the block of Cells as
|
|
// ours. NOTE: This is different from the pb managed cell_count of the
|
|
// 'cell' field above which is non-null when the cells are pb'd.
|
|
AssociatedCellCount *int32 `protobuf:"varint,8,opt,name=associated_cell_count,json=associatedCellCount" json:"associated_cell_count,omitempty"`
|
|
Nonce *uint64 `protobuf:"varint,9,opt,name=nonce" json:"nonce,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutationProto) Reset() { *m = MutationProto{} }
|
|
func (m *MutationProto) String() string { return proto.CompactTextString(m) }
|
|
func (*MutationProto) ProtoMessage() {}
|
|
func (*MutationProto) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{8} }
|
|
|
|
const Default_MutationProto_Durability MutationProto_Durability = MutationProto_USE_DEFAULT
|
|
|
|
func (m *MutationProto) GetRow() []byte {
|
|
if m != nil {
|
|
return m.Row
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto) GetMutateType() MutationProto_MutationType {
|
|
if m != nil && m.MutateType != nil {
|
|
return *m.MutateType
|
|
}
|
|
return MutationProto_APPEND
|
|
}
|
|
|
|
func (m *MutationProto) GetColumnValue() []*MutationProto_ColumnValue {
|
|
if m != nil {
|
|
return m.ColumnValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto) GetTimestamp() uint64 {
|
|
if m != nil && m.Timestamp != nil {
|
|
return *m.Timestamp
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MutationProto) GetAttribute() []*NameBytesPair {
|
|
if m != nil {
|
|
return m.Attribute
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto) GetDurability() MutationProto_Durability {
|
|
if m != nil && m.Durability != nil {
|
|
return *m.Durability
|
|
}
|
|
return Default_MutationProto_Durability
|
|
}
|
|
|
|
func (m *MutationProto) GetTimeRange() *TimeRange {
|
|
if m != nil {
|
|
return m.TimeRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto) GetAssociatedCellCount() int32 {
|
|
if m != nil && m.AssociatedCellCount != nil {
|
|
return *m.AssociatedCellCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MutationProto) GetNonce() uint64 {
|
|
if m != nil && m.Nonce != nil {
|
|
return *m.Nonce
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type MutationProto_ColumnValue struct {
|
|
Family []byte `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
|
|
QualifierValue []*MutationProto_ColumnValue_QualifierValue `protobuf:"bytes,2,rep,name=qualifier_value,json=qualifierValue" json:"qualifier_value,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue) Reset() { *m = MutationProto_ColumnValue{} }
|
|
func (m *MutationProto_ColumnValue) String() string { return proto.CompactTextString(m) }
|
|
func (*MutationProto_ColumnValue) ProtoMessage() {}
|
|
func (*MutationProto_ColumnValue) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{8, 0} }
|
|
|
|
func (m *MutationProto_ColumnValue) GetFamily() []byte {
|
|
if m != nil {
|
|
return m.Family
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue) GetQualifierValue() []*MutationProto_ColumnValue_QualifierValue {
|
|
if m != nil {
|
|
return m.QualifierValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MutationProto_ColumnValue_QualifierValue struct {
|
|
Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier" json:"qualifier,omitempty"`
|
|
Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
|
|
Timestamp *uint64 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"`
|
|
DeleteType *MutationProto_DeleteType `protobuf:"varint,4,opt,name=delete_type,json=deleteType,enum=pb.MutationProto_DeleteType" json:"delete_type,omitempty"`
|
|
Tags []byte `protobuf:"bytes,5,opt,name=tags" json:"tags,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) Reset() {
|
|
*m = MutationProto_ColumnValue_QualifierValue{}
|
|
}
|
|
func (m *MutationProto_ColumnValue_QualifierValue) String() string { return proto.CompactTextString(m) }
|
|
func (*MutationProto_ColumnValue_QualifierValue) ProtoMessage() {}
|
|
func (*MutationProto_ColumnValue_QualifierValue) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor3, []int{8, 0, 0}
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) GetQualifier() []byte {
|
|
if m != nil {
|
|
return m.Qualifier
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) GetValue() []byte {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) GetTimestamp() uint64 {
|
|
if m != nil && m.Timestamp != nil {
|
|
return *m.Timestamp
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) GetDeleteType() MutationProto_DeleteType {
|
|
if m != nil && m.DeleteType != nil {
|
|
return *m.DeleteType
|
|
}
|
|
return MutationProto_DELETE_ONE_VERSION
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue_QualifierValue) GetTags() []byte {
|
|
if m != nil {
|
|
return m.Tags
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// The mutate request. Perform a single Mutate operation.
|
|
//
|
|
// Optionally, you can specify a condition. The mutate
|
|
// will take place only if the condition is met. Otherwise,
|
|
// the mutate will be ignored. In the response result,
|
|
// parameter processed is used to indicate if the mutate
|
|
// actually happened.
|
|
type MutateRequest struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
Mutation *MutationProto `protobuf:"bytes,2,req,name=mutation" json:"mutation,omitempty"`
|
|
Condition *Condition `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
|
|
NonceGroup *uint64 `protobuf:"varint,4,opt,name=nonce_group,json=nonceGroup" json:"nonce_group,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutateRequest) Reset() { *m = MutateRequest{} }
|
|
func (m *MutateRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*MutateRequest) ProtoMessage() {}
|
|
func (*MutateRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{9} }
|
|
|
|
func (m *MutateRequest) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutateRequest) GetMutation() *MutationProto {
|
|
if m != nil {
|
|
return m.Mutation
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutateRequest) GetCondition() *Condition {
|
|
if m != nil {
|
|
return m.Condition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutateRequest) GetNonceGroup() uint64 {
|
|
if m != nil && m.NonceGroup != nil {
|
|
return *m.NonceGroup
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type MutateResponse struct {
|
|
Result *Result `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
|
|
// used for mutate to indicate processed only
|
|
Processed *bool `protobuf:"varint,2,opt,name=processed" json:"processed,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutateResponse) Reset() { *m = MutateResponse{} }
|
|
func (m *MutateResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*MutateResponse) ProtoMessage() {}
|
|
func (*MutateResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{10} }
|
|
|
|
func (m *MutateResponse) GetResult() *Result {
|
|
if m != nil {
|
|
return m.Result
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MutateResponse) GetProcessed() bool {
|
|
if m != nil && m.Processed != nil {
|
|
return *m.Processed
|
|
}
|
|
return false
|
|
}
|
|
|
|
// *
|
|
// Instead of get from a table, you can scan it with optional filters.
|
|
// You can specify the row key range, time range, the columns/families
|
|
// to scan and so on.
|
|
//
|
|
// This scan is used the first time in a scan request. The response of
|
|
// the initial scan will return a scanner id, which should be used to
|
|
// fetch result batches later on before it is closed.
|
|
type Scan struct {
|
|
Column []*Column `protobuf:"bytes,1,rep,name=column" json:"column,omitempty"`
|
|
Attribute []*NameBytesPair `protobuf:"bytes,2,rep,name=attribute" json:"attribute,omitempty"`
|
|
StartRow []byte `protobuf:"bytes,3,opt,name=start_row,json=startRow" json:"start_row,omitempty"`
|
|
StopRow []byte `protobuf:"bytes,4,opt,name=stop_row,json=stopRow" json:"stop_row,omitempty"`
|
|
Filter *Filter `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
|
|
TimeRange *TimeRange `protobuf:"bytes,6,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
|
|
MaxVersions *uint32 `protobuf:"varint,7,opt,name=max_versions,json=maxVersions,def=1" json:"max_versions,omitempty"`
|
|
CacheBlocks *bool `protobuf:"varint,8,opt,name=cache_blocks,json=cacheBlocks,def=1" json:"cache_blocks,omitempty"`
|
|
BatchSize *uint32 `protobuf:"varint,9,opt,name=batch_size,json=batchSize" json:"batch_size,omitempty"`
|
|
MaxResultSize *uint64 `protobuf:"varint,10,opt,name=max_result_size,json=maxResultSize" json:"max_result_size,omitempty"`
|
|
StoreLimit *uint32 `protobuf:"varint,11,opt,name=store_limit,json=storeLimit" json:"store_limit,omitempty"`
|
|
StoreOffset *uint32 `protobuf:"varint,12,opt,name=store_offset,json=storeOffset" json:"store_offset,omitempty"`
|
|
LoadColumnFamiliesOnDemand *bool `protobuf:"varint,13,opt,name=load_column_families_on_demand,json=loadColumnFamiliesOnDemand" json:"load_column_families_on_demand,omitempty"`
|
|
Small *bool `protobuf:"varint,14,opt,name=small" json:"small,omitempty"`
|
|
Reversed *bool `protobuf:"varint,15,opt,name=reversed,def=0" json:"reversed,omitempty"`
|
|
Consistency *Consistency `protobuf:"varint,16,opt,name=consistency,enum=pb.Consistency,def=0" json:"consistency,omitempty"`
|
|
Caching *uint32 `protobuf:"varint,17,opt,name=caching" json:"caching,omitempty"`
|
|
AllowPartialResults *bool `protobuf:"varint,18,opt,name=allow_partial_results,json=allowPartialResults" json:"allow_partial_results,omitempty"`
|
|
CfTimeRange []*ColumnFamilyTimeRange `protobuf:"bytes,19,rep,name=cf_time_range,json=cfTimeRange" json:"cf_time_range,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Scan) Reset() { *m = Scan{} }
|
|
func (m *Scan) String() string { return proto.CompactTextString(m) }
|
|
func (*Scan) ProtoMessage() {}
|
|
func (*Scan) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{11} }
|
|
|
|
const Default_Scan_MaxVersions uint32 = 1
|
|
const Default_Scan_CacheBlocks bool = true
|
|
const Default_Scan_Reversed bool = false
|
|
const Default_Scan_Consistency Consistency = Consistency_STRONG
|
|
|
|
func (m *Scan) GetColumn() []*Column {
|
|
if m != nil {
|
|
return m.Column
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetAttribute() []*NameBytesPair {
|
|
if m != nil {
|
|
return m.Attribute
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetStartRow() []byte {
|
|
if m != nil {
|
|
return m.StartRow
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetStopRow() []byte {
|
|
if m != nil {
|
|
return m.StopRow
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetFilter() *Filter {
|
|
if m != nil {
|
|
return m.Filter
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetTimeRange() *TimeRange {
|
|
if m != nil {
|
|
return m.TimeRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Scan) GetMaxVersions() uint32 {
|
|
if m != nil && m.MaxVersions != nil {
|
|
return *m.MaxVersions
|
|
}
|
|
return Default_Scan_MaxVersions
|
|
}
|
|
|
|
func (m *Scan) GetCacheBlocks() bool {
|
|
if m != nil && m.CacheBlocks != nil {
|
|
return *m.CacheBlocks
|
|
}
|
|
return Default_Scan_CacheBlocks
|
|
}
|
|
|
|
func (m *Scan) GetBatchSize() uint32 {
|
|
if m != nil && m.BatchSize != nil {
|
|
return *m.BatchSize
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Scan) GetMaxResultSize() uint64 {
|
|
if m != nil && m.MaxResultSize != nil {
|
|
return *m.MaxResultSize
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Scan) GetStoreLimit() uint32 {
|
|
if m != nil && m.StoreLimit != nil {
|
|
return *m.StoreLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Scan) GetStoreOffset() uint32 {
|
|
if m != nil && m.StoreOffset != nil {
|
|
return *m.StoreOffset
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Scan) GetLoadColumnFamiliesOnDemand() bool {
|
|
if m != nil && m.LoadColumnFamiliesOnDemand != nil {
|
|
return *m.LoadColumnFamiliesOnDemand
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Scan) GetSmall() bool {
|
|
if m != nil && m.Small != nil {
|
|
return *m.Small
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Scan) GetReversed() bool {
|
|
if m != nil && m.Reversed != nil {
|
|
return *m.Reversed
|
|
}
|
|
return Default_Scan_Reversed
|
|
}
|
|
|
|
func (m *Scan) GetConsistency() Consistency {
|
|
if m != nil && m.Consistency != nil {
|
|
return *m.Consistency
|
|
}
|
|
return Default_Scan_Consistency
|
|
}
|
|
|
|
func (m *Scan) GetCaching() uint32 {
|
|
if m != nil && m.Caching != nil {
|
|
return *m.Caching
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Scan) GetAllowPartialResults() bool {
|
|
if m != nil && m.AllowPartialResults != nil {
|
|
return *m.AllowPartialResults
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Scan) GetCfTimeRange() []*ColumnFamilyTimeRange {
|
|
if m != nil {
|
|
return m.CfTimeRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// A scan request. Initially, it should specify a scan. Later on, you
|
|
// can use the scanner id returned to fetch result batches with a different
|
|
// scan request.
|
|
//
|
|
// The scanner will remain open if there are more results, and it's not
|
|
// asked to be closed explicitly.
|
|
//
|
|
// You can fetch the results and ask the scanner to be closed to save
|
|
// a trip if you are not interested in remaining results.
|
|
type ScanRequest struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"`
|
|
Scan *Scan `protobuf:"bytes,2,opt,name=scan" json:"scan,omitempty"`
|
|
ScannerId *uint64 `protobuf:"varint,3,opt,name=scanner_id,json=scannerId" json:"scanner_id,omitempty"`
|
|
NumberOfRows *uint32 `protobuf:"varint,4,opt,name=number_of_rows,json=numberOfRows" json:"number_of_rows,omitempty"`
|
|
CloseScanner *bool `protobuf:"varint,5,opt,name=close_scanner,json=closeScanner" json:"close_scanner,omitempty"`
|
|
NextCallSeq *uint64 `protobuf:"varint,6,opt,name=next_call_seq,json=nextCallSeq" json:"next_call_seq,omitempty"`
|
|
ClientHandlesPartials *bool `protobuf:"varint,7,opt,name=client_handles_partials,json=clientHandlesPartials" json:"client_handles_partials,omitempty"`
|
|
ClientHandlesHeartbeats *bool `protobuf:"varint,8,opt,name=client_handles_heartbeats,json=clientHandlesHeartbeats" json:"client_handles_heartbeats,omitempty"`
|
|
TrackScanMetrics *bool `protobuf:"varint,9,opt,name=track_scan_metrics,json=trackScanMetrics" json:"track_scan_metrics,omitempty"`
|
|
Renew *bool `protobuf:"varint,10,opt,name=renew,def=0" json:"renew,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ScanRequest) Reset() { *m = ScanRequest{} }
|
|
func (m *ScanRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*ScanRequest) ProtoMessage() {}
|
|
func (*ScanRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{12} }
|
|
|
|
const Default_ScanRequest_Renew bool = false
|
|
|
|
func (m *ScanRequest) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ScanRequest) GetScan() *Scan {
|
|
if m != nil {
|
|
return m.Scan
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ScanRequest) GetScannerId() uint64 {
|
|
if m != nil && m.ScannerId != nil {
|
|
return *m.ScannerId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ScanRequest) GetNumberOfRows() uint32 {
|
|
if m != nil && m.NumberOfRows != nil {
|
|
return *m.NumberOfRows
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ScanRequest) GetCloseScanner() bool {
|
|
if m != nil && m.CloseScanner != nil {
|
|
return *m.CloseScanner
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanRequest) GetNextCallSeq() uint64 {
|
|
if m != nil && m.NextCallSeq != nil {
|
|
return *m.NextCallSeq
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ScanRequest) GetClientHandlesPartials() bool {
|
|
if m != nil && m.ClientHandlesPartials != nil {
|
|
return *m.ClientHandlesPartials
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanRequest) GetClientHandlesHeartbeats() bool {
|
|
if m != nil && m.ClientHandlesHeartbeats != nil {
|
|
return *m.ClientHandlesHeartbeats
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanRequest) GetTrackScanMetrics() bool {
|
|
if m != nil && m.TrackScanMetrics != nil {
|
|
return *m.TrackScanMetrics
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanRequest) GetRenew() bool {
|
|
if m != nil && m.Renew != nil {
|
|
return *m.Renew
|
|
}
|
|
return Default_ScanRequest_Renew
|
|
}
|
|
|
|
// *
|
|
// The scan response. If there are no more results, more_results will
|
|
// be false. If it is not specified, it means there are more.
|
|
type ScanResponse struct {
|
|
// This field is filled in if we are doing cellblocks. A cellblock is made up
|
|
// of all Cells serialized out as one cellblock BUT responses from a server
|
|
// have their Cells grouped by Result. So we can reconstitute the
|
|
// Results on the client-side, this field is a list of counts of Cells
|
|
// in each Result that makes up the response. For example, if this field
|
|
// has 3, 3, 3 in it, then we know that on the client, we are to make
|
|
// three Results each of three Cells each.
|
|
CellsPerResult []uint32 `protobuf:"varint,1,rep,name=cells_per_result,json=cellsPerResult" json:"cells_per_result,omitempty"`
|
|
ScannerId *uint64 `protobuf:"varint,2,opt,name=scanner_id,json=scannerId" json:"scanner_id,omitempty"`
|
|
MoreResults *bool `protobuf:"varint,3,opt,name=more_results,json=moreResults" json:"more_results,omitempty"`
|
|
Ttl *uint32 `protobuf:"varint,4,opt,name=ttl" json:"ttl,omitempty"`
|
|
// If cells are not carried in an accompanying cellblock, then they are pb'd here.
|
|
// This field is mutually exclusive with cells_per_result (since the Cells will
|
|
// be inside the pb'd Result)
|
|
Results []*Result `protobuf:"bytes,5,rep,name=results" json:"results,omitempty"`
|
|
Stale *bool `protobuf:"varint,6,opt,name=stale" json:"stale,omitempty"`
|
|
// This field is filled in if we are doing cellblocks. In the event that a row
|
|
// could not fit all of its cells into a single RPC chunk, the results will be
|
|
// returned as partials, and reconstructed into a complete result on the client
|
|
// side. This field is a list of flags indicating whether or not the result
|
|
// that the cells belong to is a partial result. For example, if this field
|
|
// has false, false, true in it, then we know that on the client side, we need to
|
|
// make another RPC request since the last result was only a partial.
|
|
PartialFlagPerResult []bool `protobuf:"varint,7,rep,name=partial_flag_per_result,json=partialFlagPerResult" json:"partial_flag_per_result,omitempty"`
|
|
// A server may choose to limit the number of results returned to the client for
|
|
// reasons such as the size in bytes or quantity of results accumulated. This field
|
|
// will true when more results exist in the current region.
|
|
MoreResultsInRegion *bool `protobuf:"varint,8,opt,name=more_results_in_region,json=moreResultsInRegion" json:"more_results_in_region,omitempty"`
|
|
// This field is filled in if the server is sending back a heartbeat message.
|
|
// Heartbeat messages are sent back to the client to prevent the scanner from
|
|
// timing out. Seeing a heartbeat message communicates to the Client that the
|
|
// server would have continued to scan had the time limit not been reached.
|
|
HeartbeatMessage *bool `protobuf:"varint,9,opt,name=heartbeat_message,json=heartbeatMessage" json:"heartbeat_message,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ScanResponse) Reset() { *m = ScanResponse{} }
|
|
func (m *ScanResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*ScanResponse) ProtoMessage() {}
|
|
func (*ScanResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{13} }
|
|
|
|
func (m *ScanResponse) GetCellsPerResult() []uint32 {
|
|
if m != nil {
|
|
return m.CellsPerResult
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ScanResponse) GetScannerId() uint64 {
|
|
if m != nil && m.ScannerId != nil {
|
|
return *m.ScannerId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ScanResponse) GetMoreResults() bool {
|
|
if m != nil && m.MoreResults != nil {
|
|
return *m.MoreResults
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanResponse) GetTtl() uint32 {
|
|
if m != nil && m.Ttl != nil {
|
|
return *m.Ttl
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ScanResponse) GetResults() []*Result {
|
|
if m != nil {
|
|
return m.Results
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ScanResponse) GetStale() bool {
|
|
if m != nil && m.Stale != nil {
|
|
return *m.Stale
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanResponse) GetPartialFlagPerResult() []bool {
|
|
if m != nil {
|
|
return m.PartialFlagPerResult
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ScanResponse) GetMoreResultsInRegion() bool {
|
|
if m != nil && m.MoreResultsInRegion != nil {
|
|
return *m.MoreResultsInRegion
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *ScanResponse) GetHeartbeatMessage() bool {
|
|
if m != nil && m.HeartbeatMessage != nil {
|
|
return *m.HeartbeatMessage
|
|
}
|
|
return false
|
|
}
|
|
|
|
// *
|
|
// Atomically bulk load multiple HFiles (say from different column families)
|
|
// into an open region.
|
|
type BulkLoadHFileRequest struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
FamilyPath []*BulkLoadHFileRequest_FamilyPath `protobuf:"bytes,2,rep,name=family_path,json=familyPath" json:"family_path,omitempty"`
|
|
AssignSeqNum *bool `protobuf:"varint,3,opt,name=assign_seq_num,json=assignSeqNum" json:"assign_seq_num,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest) Reset() { *m = BulkLoadHFileRequest{} }
|
|
func (m *BulkLoadHFileRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*BulkLoadHFileRequest) ProtoMessage() {}
|
|
func (*BulkLoadHFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{14} }
|
|
|
|
func (m *BulkLoadHFileRequest) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest) GetFamilyPath() []*BulkLoadHFileRequest_FamilyPath {
|
|
if m != nil {
|
|
return m.FamilyPath
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest) GetAssignSeqNum() bool {
|
|
if m != nil && m.AssignSeqNum != nil {
|
|
return *m.AssignSeqNum
|
|
}
|
|
return false
|
|
}
|
|
|
|
type BulkLoadHFileRequest_FamilyPath struct {
|
|
Family []byte `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
|
|
Path *string `protobuf:"bytes,2,req,name=path" json:"path,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest_FamilyPath) Reset() { *m = BulkLoadHFileRequest_FamilyPath{} }
|
|
func (m *BulkLoadHFileRequest_FamilyPath) String() string { return proto.CompactTextString(m) }
|
|
func (*BulkLoadHFileRequest_FamilyPath) ProtoMessage() {}
|
|
func (*BulkLoadHFileRequest_FamilyPath) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor3, []int{14, 0}
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest_FamilyPath) GetFamily() []byte {
|
|
if m != nil {
|
|
return m.Family
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest_FamilyPath) GetPath() string {
|
|
if m != nil && m.Path != nil {
|
|
return *m.Path
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BulkLoadHFileResponse struct {
|
|
Loaded *bool `protobuf:"varint,1,req,name=loaded" json:"loaded,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *BulkLoadHFileResponse) Reset() { *m = BulkLoadHFileResponse{} }
|
|
func (m *BulkLoadHFileResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*BulkLoadHFileResponse) ProtoMessage() {}
|
|
func (*BulkLoadHFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{15} }
|
|
|
|
func (m *BulkLoadHFileResponse) GetLoaded() bool {
|
|
if m != nil && m.Loaded != nil {
|
|
return *m.Loaded
|
|
}
|
|
return false
|
|
}
|
|
|
|
type CoprocessorServiceCall struct {
|
|
Row []byte `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
|
|
ServiceName *string `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"`
|
|
MethodName *string `protobuf:"bytes,3,req,name=method_name,json=methodName" json:"method_name,omitempty"`
|
|
Request []byte `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CoprocessorServiceCall) Reset() { *m = CoprocessorServiceCall{} }
|
|
func (m *CoprocessorServiceCall) String() string { return proto.CompactTextString(m) }
|
|
func (*CoprocessorServiceCall) ProtoMessage() {}
|
|
func (*CoprocessorServiceCall) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{16} }
|
|
|
|
func (m *CoprocessorServiceCall) GetRow() []byte {
|
|
if m != nil {
|
|
return m.Row
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *CoprocessorServiceCall) GetServiceName() string {
|
|
if m != nil && m.ServiceName != nil {
|
|
return *m.ServiceName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *CoprocessorServiceCall) GetMethodName() string {
|
|
if m != nil && m.MethodName != nil {
|
|
return *m.MethodName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *CoprocessorServiceCall) GetRequest() []byte {
|
|
if m != nil {
|
|
return m.Request
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CoprocessorServiceResult struct {
|
|
Value *NameBytesPair `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CoprocessorServiceResult) Reset() { *m = CoprocessorServiceResult{} }
|
|
func (m *CoprocessorServiceResult) String() string { return proto.CompactTextString(m) }
|
|
func (*CoprocessorServiceResult) ProtoMessage() {}
|
|
func (*CoprocessorServiceResult) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{17} }
|
|
|
|
func (m *CoprocessorServiceResult) GetValue() *NameBytesPair {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CoprocessorServiceRequest struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
Call *CoprocessorServiceCall `protobuf:"bytes,2,req,name=call" json:"call,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CoprocessorServiceRequest) Reset() { *m = CoprocessorServiceRequest{} }
|
|
func (m *CoprocessorServiceRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*CoprocessorServiceRequest) ProtoMessage() {}
|
|
func (*CoprocessorServiceRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{18} }
|
|
|
|
func (m *CoprocessorServiceRequest) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *CoprocessorServiceRequest) GetCall() *CoprocessorServiceCall {
|
|
if m != nil {
|
|
return m.Call
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CoprocessorServiceResponse struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
Value *NameBytesPair `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CoprocessorServiceResponse) Reset() { *m = CoprocessorServiceResponse{} }
|
|
func (m *CoprocessorServiceResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*CoprocessorServiceResponse) ProtoMessage() {}
|
|
func (*CoprocessorServiceResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{19} }
|
|
|
|
func (m *CoprocessorServiceResponse) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *CoprocessorServiceResponse) GetValue() *NameBytesPair {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Either a Get or a Mutation
|
|
type Action struct {
|
|
// If part of a multi action, useful aligning
|
|
// result with what was originally submitted.
|
|
Index *uint32 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
|
|
Mutation *MutationProto `protobuf:"bytes,2,opt,name=mutation" json:"mutation,omitempty"`
|
|
Get *Get `protobuf:"bytes,3,opt,name=get" json:"get,omitempty"`
|
|
ServiceCall *CoprocessorServiceCall `protobuf:"bytes,4,opt,name=service_call,json=serviceCall" json:"service_call,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Action) Reset() { *m = Action{} }
|
|
func (m *Action) String() string { return proto.CompactTextString(m) }
|
|
func (*Action) ProtoMessage() {}
|
|
func (*Action) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{20} }
|
|
|
|
func (m *Action) GetIndex() uint32 {
|
|
if m != nil && m.Index != nil {
|
|
return *m.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Action) GetMutation() *MutationProto {
|
|
if m != nil {
|
|
return m.Mutation
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Action) GetGet() *Get {
|
|
if m != nil {
|
|
return m.Get
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Action) GetServiceCall() *CoprocessorServiceCall {
|
|
if m != nil {
|
|
return m.ServiceCall
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// Actions to run against a Region.
|
|
type RegionAction struct {
|
|
Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
|
|
// When set, run mutations as atomic unit.
|
|
Atomic *bool `protobuf:"varint,2,opt,name=atomic" json:"atomic,omitempty"`
|
|
Action []*Action `protobuf:"bytes,3,rep,name=action" json:"action,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *RegionAction) Reset() { *m = RegionAction{} }
|
|
func (m *RegionAction) String() string { return proto.CompactTextString(m) }
|
|
func (*RegionAction) ProtoMessage() {}
|
|
func (*RegionAction) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{21} }
|
|
|
|
func (m *RegionAction) GetRegion() *RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RegionAction) GetAtomic() bool {
|
|
if m != nil && m.Atomic != nil {
|
|
return *m.Atomic
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *RegionAction) GetAction() []*Action {
|
|
if m != nil {
|
|
return m.Action
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//
|
|
// Statistics about the current load on the region
|
|
type RegionLoadStats struct {
|
|
// Percent load on the memstore. Guaranteed to be positive, between 0 and 100.
|
|
MemstoreLoad *int32 `protobuf:"varint,1,opt,name=memstoreLoad,def=0" json:"memstoreLoad,omitempty"`
|
|
// Percent JVM heap occupancy. Guaranteed to be positive, between 0 and 100.
|
|
// We can move this to "ServerLoadStats" should we develop them.
|
|
HeapOccupancy *int32 `protobuf:"varint,2,opt,name=heapOccupancy,def=0" json:"heapOccupancy,omitempty"`
|
|
// Compaction pressure. Guaranteed to be positive, between 0 and 100.
|
|
CompactionPressure *int32 `protobuf:"varint,3,opt,name=compactionPressure,def=0" json:"compactionPressure,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *RegionLoadStats) Reset() { *m = RegionLoadStats{} }
|
|
func (m *RegionLoadStats) String() string { return proto.CompactTextString(m) }
|
|
func (*RegionLoadStats) ProtoMessage() {}
|
|
func (*RegionLoadStats) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{22} }
|
|
|
|
const Default_RegionLoadStats_MemstoreLoad int32 = 0
|
|
const Default_RegionLoadStats_HeapOccupancy int32 = 0
|
|
const Default_RegionLoadStats_CompactionPressure int32 = 0
|
|
|
|
func (m *RegionLoadStats) GetMemstoreLoad() int32 {
|
|
if m != nil && m.MemstoreLoad != nil {
|
|
return *m.MemstoreLoad
|
|
}
|
|
return Default_RegionLoadStats_MemstoreLoad
|
|
}
|
|
|
|
func (m *RegionLoadStats) GetHeapOccupancy() int32 {
|
|
if m != nil && m.HeapOccupancy != nil {
|
|
return *m.HeapOccupancy
|
|
}
|
|
return Default_RegionLoadStats_HeapOccupancy
|
|
}
|
|
|
|
func (m *RegionLoadStats) GetCompactionPressure() int32 {
|
|
if m != nil && m.CompactionPressure != nil {
|
|
return *m.CompactionPressure
|
|
}
|
|
return Default_RegionLoadStats_CompactionPressure
|
|
}
|
|
|
|
type MultiRegionLoadStats struct {
|
|
Region []*RegionSpecifier `protobuf:"bytes,1,rep,name=region" json:"region,omitempty"`
|
|
Stat []*RegionLoadStats `protobuf:"bytes,2,rep,name=stat" json:"stat,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MultiRegionLoadStats) Reset() { *m = MultiRegionLoadStats{} }
|
|
func (m *MultiRegionLoadStats) String() string { return proto.CompactTextString(m) }
|
|
func (*MultiRegionLoadStats) ProtoMessage() {}
|
|
func (*MultiRegionLoadStats) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{23} }
|
|
|
|
func (m *MultiRegionLoadStats) GetRegion() []*RegionSpecifier {
|
|
if m != nil {
|
|
return m.Region
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MultiRegionLoadStats) GetStat() []*RegionLoadStats {
|
|
if m != nil {
|
|
return m.Stat
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// Either a Result or an Exception NameBytesPair (keyed by
|
|
// exception name whose value is the exception stringified)
|
|
// or maybe empty if no result and no exception.
|
|
type ResultOrException struct {
|
|
// If part of a multi call, save original index of the list of all
|
|
// passed so can align this response w/ original request.
|
|
Index *uint32 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
|
|
Result *Result `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"`
|
|
Exception *NameBytesPair `protobuf:"bytes,3,opt,name=exception" json:"exception,omitempty"`
|
|
// result if this was a coprocessor service call
|
|
ServiceResult *CoprocessorServiceResult `protobuf:"bytes,4,opt,name=service_result,json=serviceResult" json:"service_result,omitempty"`
|
|
// current load on the region
|
|
LoadStats *RegionLoadStats `protobuf:"bytes,5,opt,name=loadStats" json:"loadStats,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ResultOrException) Reset() { *m = ResultOrException{} }
|
|
func (m *ResultOrException) String() string { return proto.CompactTextString(m) }
|
|
func (*ResultOrException) ProtoMessage() {}
|
|
func (*ResultOrException) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{24} }
|
|
|
|
func (m *ResultOrException) GetIndex() uint32 {
|
|
if m != nil && m.Index != nil {
|
|
return *m.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ResultOrException) GetResult() *Result {
|
|
if m != nil {
|
|
return m.Result
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResultOrException) GetException() *NameBytesPair {
|
|
if m != nil {
|
|
return m.Exception
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResultOrException) GetServiceResult() *CoprocessorServiceResult {
|
|
if m != nil {
|
|
return m.ServiceResult
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResultOrException) GetLoadStats() *RegionLoadStats {
|
|
if m != nil {
|
|
return m.LoadStats
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// The result of a RegionAction.
|
|
type RegionActionResult struct {
|
|
ResultOrException []*ResultOrException `protobuf:"bytes,1,rep,name=resultOrException" json:"resultOrException,omitempty"`
|
|
// If the operation failed globally for this region, this exception is set
|
|
Exception *NameBytesPair `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *RegionActionResult) Reset() { *m = RegionActionResult{} }
|
|
func (m *RegionActionResult) String() string { return proto.CompactTextString(m) }
|
|
func (*RegionActionResult) ProtoMessage() {}
|
|
func (*RegionActionResult) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{25} }
|
|
|
|
func (m *RegionActionResult) GetResultOrException() []*ResultOrException {
|
|
if m != nil {
|
|
return m.ResultOrException
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RegionActionResult) GetException() *NameBytesPair {
|
|
if m != nil {
|
|
return m.Exception
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// Execute a list of actions on a given region in order.
|
|
// Nothing prevents a request to contains a set of RegionAction on the same region.
|
|
// For this reason, the matching between the MultiRequest and the MultiResponse is not
|
|
// done by the region specifier but by keeping the order of the RegionActionResult vs.
|
|
// the order of the RegionAction.
|
|
type MultiRequest struct {
|
|
RegionAction []*RegionAction `protobuf:"bytes,1,rep,name=regionAction" json:"regionAction,omitempty"`
|
|
NonceGroup *uint64 `protobuf:"varint,2,opt,name=nonceGroup" json:"nonceGroup,omitempty"`
|
|
Condition *Condition `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MultiRequest) Reset() { *m = MultiRequest{} }
|
|
func (m *MultiRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*MultiRequest) ProtoMessage() {}
|
|
func (*MultiRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{26} }
|
|
|
|
func (m *MultiRequest) GetRegionAction() []*RegionAction {
|
|
if m != nil {
|
|
return m.RegionAction
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MultiRequest) GetNonceGroup() uint64 {
|
|
if m != nil && m.NonceGroup != nil {
|
|
return *m.NonceGroup
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *MultiRequest) GetCondition() *Condition {
|
|
if m != nil {
|
|
return m.Condition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MultiResponse struct {
|
|
RegionActionResult []*RegionActionResult `protobuf:"bytes,1,rep,name=regionActionResult" json:"regionActionResult,omitempty"`
|
|
// used for mutate to indicate processed only
|
|
Processed *bool `protobuf:"varint,2,opt,name=processed" json:"processed,omitempty"`
|
|
RegionStatistics *MultiRegionLoadStats `protobuf:"bytes,3,opt,name=regionStatistics" json:"regionStatistics,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MultiResponse) Reset() { *m = MultiResponse{} }
|
|
func (m *MultiResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*MultiResponse) ProtoMessage() {}
|
|
func (*MultiResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{27} }
|
|
|
|
func (m *MultiResponse) GetRegionActionResult() []*RegionActionResult {
|
|
if m != nil {
|
|
return m.RegionActionResult
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MultiResponse) GetProcessed() bool {
|
|
if m != nil && m.Processed != nil {
|
|
return *m.Processed
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *MultiResponse) GetRegionStatistics() *MultiRegionLoadStats {
|
|
if m != nil {
|
|
return m.RegionStatistics
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*Authorizations)(nil), "pb.Authorizations")
|
|
proto.RegisterType((*CellVisibility)(nil), "pb.CellVisibility")
|
|
proto.RegisterType((*Column)(nil), "pb.Column")
|
|
proto.RegisterType((*Get)(nil), "pb.Get")
|
|
proto.RegisterType((*Result)(nil), "pb.Result")
|
|
proto.RegisterType((*GetRequest)(nil), "pb.GetRequest")
|
|
proto.RegisterType((*GetResponse)(nil), "pb.GetResponse")
|
|
proto.RegisterType((*Condition)(nil), "pb.Condition")
|
|
proto.RegisterType((*MutationProto)(nil), "pb.MutationProto")
|
|
proto.RegisterType((*MutationProto_ColumnValue)(nil), "pb.MutationProto.ColumnValue")
|
|
proto.RegisterType((*MutationProto_ColumnValue_QualifierValue)(nil), "pb.MutationProto.ColumnValue.QualifierValue")
|
|
proto.RegisterType((*MutateRequest)(nil), "pb.MutateRequest")
|
|
proto.RegisterType((*MutateResponse)(nil), "pb.MutateResponse")
|
|
proto.RegisterType((*Scan)(nil), "pb.Scan")
|
|
proto.RegisterType((*ScanRequest)(nil), "pb.ScanRequest")
|
|
proto.RegisterType((*ScanResponse)(nil), "pb.ScanResponse")
|
|
proto.RegisterType((*BulkLoadHFileRequest)(nil), "pb.BulkLoadHFileRequest")
|
|
proto.RegisterType((*BulkLoadHFileRequest_FamilyPath)(nil), "pb.BulkLoadHFileRequest.FamilyPath")
|
|
proto.RegisterType((*BulkLoadHFileResponse)(nil), "pb.BulkLoadHFileResponse")
|
|
proto.RegisterType((*CoprocessorServiceCall)(nil), "pb.CoprocessorServiceCall")
|
|
proto.RegisterType((*CoprocessorServiceResult)(nil), "pb.CoprocessorServiceResult")
|
|
proto.RegisterType((*CoprocessorServiceRequest)(nil), "pb.CoprocessorServiceRequest")
|
|
proto.RegisterType((*CoprocessorServiceResponse)(nil), "pb.CoprocessorServiceResponse")
|
|
proto.RegisterType((*Action)(nil), "pb.Action")
|
|
proto.RegisterType((*RegionAction)(nil), "pb.RegionAction")
|
|
proto.RegisterType((*RegionLoadStats)(nil), "pb.RegionLoadStats")
|
|
proto.RegisterType((*MultiRegionLoadStats)(nil), "pb.MultiRegionLoadStats")
|
|
proto.RegisterType((*ResultOrException)(nil), "pb.ResultOrException")
|
|
proto.RegisterType((*RegionActionResult)(nil), "pb.RegionActionResult")
|
|
proto.RegisterType((*MultiRequest)(nil), "pb.MultiRequest")
|
|
proto.RegisterType((*MultiResponse)(nil), "pb.MultiResponse")
|
|
proto.RegisterEnum("pb.Consistency", Consistency_name, Consistency_value)
|
|
proto.RegisterEnum("pb.MutationProto_Durability", MutationProto_Durability_name, MutationProto_Durability_value)
|
|
proto.RegisterEnum("pb.MutationProto_MutationType", MutationProto_MutationType_name, MutationProto_MutationType_value)
|
|
proto.RegisterEnum("pb.MutationProto_DeleteType", MutationProto_DeleteType_name, MutationProto_DeleteType_value)
|
|
}
|
|
|
|
func init() { proto.RegisterFile("Client.proto", fileDescriptor3) }
|
|
|
|
var fileDescriptor3 = []byte{
|
|
// 2529 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x59, 0x49, 0x6f, 0x1c, 0xc7,
|
|
0xf5, 0x77, 0xcf, 0xc6, 0x99, 0x37, 0x0b, 0x87, 0x25, 0x8a, 0x6a, 0xd2, 0xb2, 0x4c, 0xb7, 0xfd,
|
|
0xb7, 0xf8, 0xb7, 0x15, 0xca, 0xa6, 0xe3, 0x20, 0x11, 0x60, 0x27, 0xe4, 0x70, 0x28, 0x11, 0xe1,
|
|
0x96, 0x1a, 0x4a, 0x8e, 0x4f, 0x8d, 0x62, 0x4f, 0x0d, 0xd9, 0x70, 0x2f, 0xa3, 0xae, 0x1a, 0x91,
|
|
0xf4, 0x39, 0x07, 0x23, 0xb7, 0x00, 0xf9, 0x00, 0xb9, 0x04, 0xb9, 0x25, 0x39, 0x24, 0x08, 0x82,
|
|
0x7c, 0x9a, 0x1c, 0xf3, 0x0d, 0x82, 0x9c, 0x82, 0x7a, 0x55, 0xbd, 0x0c, 0x39, 0xd4, 0x62, 0xe4,
|
|
0xc4, 0xae, 0xdf, 0x7b, 0xf5, 0xfa, 0xd5, 0xdb, 0xfa, 0x57, 0x43, 0x68, 0xf5, 0x02, 0x9f, 0x47,
|
|
0x72, 0x7d, 0x9c, 0xc4, 0x32, 0x26, 0xa5, 0xf1, 0xc9, 0x4a, 0xf3, 0xc9, 0x16, 0x13, 0x5c, 0x03,
|
|
0x2b, 0xad, 0x1d, 0x3f, 0x90, 0x3c, 0x31, 0x2b, 0xe8, 0xf1, 0x20, 0x30, 0xcf, 0xdd, 0x5e, 0x1c,
|
|
0x8e, 0x59, 0xc2, 0x64, 0x6c, 0xa4, 0xce, 0x87, 0xd0, 0xd9, 0x9c, 0xc8, 0xb3, 0x38, 0xf1, 0xbf,
|
|
0x65, 0xd2, 0x8f, 0x23, 0x41, 0x16, 0xa1, 0x1a, 0xb0, 0x13, 0x1e, 0xd8, 0xd6, 0x6a, 0x79, 0xad,
|
|
0x41, 0xf5, 0xc2, 0xf9, 0x04, 0x3a, 0xca, 0xce, 0x33, 0x5f, 0xf8, 0x27, 0x7e, 0xe0, 0xcb, 0x4b,
|
|
0x72, 0x0f, 0x80, 0x5f, 0x8c, 0x13, 0x2e, 0x84, 0x1f, 0x47, 0xb6, 0xb5, 0x5a, 0x5a, 0x6b, 0xd0,
|
|
0x02, 0xe2, 0x7c, 0x09, 0xb5, 0x5e, 0x1c, 0x4c, 0xc2, 0x88, 0x2c, 0x41, 0x6d, 0xc4, 0x42, 0x3f,
|
|
0xb8, 0x44, 0xad, 0x16, 0x35, 0x2b, 0x72, 0x17, 0x1a, 0xcf, 0x27, 0x2c, 0xf0, 0x47, 0x3e, 0x4f,
|
|
0xec, 0xd2, 0x6a, 0x79, 0xad, 0x45, 0x73, 0xc0, 0xf9, 0x63, 0x05, 0xca, 0x8f, 0xb9, 0x24, 0x5d,
|
|
0x28, 0x27, 0xf1, 0xb9, 0xd9, 0xaa, 0x1e, 0x89, 0x03, 0x35, 0x0f, 0x2d, 0xe3, 0xa6, 0xe6, 0x06,
|
|
0xac, 0x8f, 0x4f, 0xd6, 0xf5, 0xbb, 0xa8, 0x91, 0x90, 0x87, 0xd0, 0x60, 0x52, 0x26, 0xfe, 0xc9,
|
|
0x44, 0x72, 0xbb, 0x8c, 0x6a, 0x0b, 0x4a, 0xed, 0x80, 0x85, 0x7c, 0xeb, 0x52, 0x72, 0x71, 0xc4,
|
|
0xfc, 0x84, 0xe6, 0x3a, 0xca, 0xe8, 0x08, 0xc3, 0x66, 0x57, 0x56, 0xad, 0xd4, 0xa8, 0x0e, 0x24,
|
|
0x35, 0x12, 0xf2, 0x00, 0x40, 0xfa, 0x21, 0x77, 0x13, 0x16, 0x9d, 0x72, 0xbb, 0x8a, 0x7a, 0x6d,
|
|
0xa5, 0x77, 0xec, 0x87, 0x9c, 0x2a, 0x90, 0x36, 0x64, 0xfa, 0x48, 0x3e, 0x80, 0x56, 0xc8, 0x2e,
|
|
0xdc, 0x17, 0x3c, 0x51, 0xf1, 0x10, 0x76, 0x6d, 0xd5, 0x5a, 0x6b, 0x3f, 0xb2, 0x3e, 0xa5, 0xcd,
|
|
0x90, 0x5d, 0x3c, 0x33, 0x28, 0xb9, 0x0f, 0x2d, 0x8f, 0x79, 0x67, 0xdc, 0x3d, 0x09, 0x62, 0xef,
|
|
0x1b, 0x61, 0xcf, 0xad, 0x5a, 0x6b, 0xf5, 0x47, 0x15, 0x99, 0x4c, 0x38, 0x6d, 0xa2, 0x64, 0x0b,
|
|
0x05, 0xe4, 0x5d, 0x68, 0x0a, 0x19, 0x27, 0xdc, 0x0d, 0xfc, 0xd0, 0x97, 0x76, 0x5d, 0x59, 0xa3,
|
|
0x80, 0xd0, 0x9e, 0x42, 0xc8, 0x7b, 0xd0, 0xd2, 0x0a, 0xf1, 0x68, 0x24, 0xb8, 0xb4, 0x1b, 0xa8,
|
|
0xa1, 0x37, 0x1d, 0x22, 0x44, 0x1e, 0x40, 0x87, 0x5f, 0xf8, 0x42, 0xf2, 0xc8, 0xe3, 0x6e, 0x1c,
|
|
0x05, 0x97, 0x36, 0xe0, 0xeb, 0xaa, 0x23, 0x16, 0x08, 0x4e, 0xdb, 0x99, 0xf0, 0x30, 0x0a, 0x2e,
|
|
0xc9, 0x67, 0x40, 0xbc, 0x20, 0x16, 0x5c, 0x48, 0x37, 0x89, 0xcf, 0xdd, 0x13, 0x3e, 0x8a, 0x13,
|
|
0x6e, 0x37, 0x8b, 0x3b, 0xba, 0x46, 0x81, 0xc6, 0xe7, 0x5b, 0x28, 0x26, 0x3f, 0x81, 0xa6, 0x17,
|
|
0x47, 0x42, 0xdb, 0xb9, 0xb4, 0x5b, 0xab, 0xd6, 0x5a, 0x67, 0x63, 0x5e, 0x67, 0x28, 0x83, 0x1f,
|
|
0xd5, 0x06, 0xc7, 0xf4, 0xf0, 0xe0, 0x31, 0x2d, 0xea, 0x92, 0x2f, 0xa0, 0xed, 0x8d, 0xdc, 0x42,
|
|
0x84, 0xdb, 0x98, 0xb7, 0xe5, 0x3c, 0xbd, 0x3b, 0x58, 0x38, 0x79, 0xb4, 0x9b, 0xde, 0x28, 0x5b,
|
|
0x38, 0x7f, 0xb6, 0xa0, 0x46, 0xb9, 0x98, 0x04, 0x92, 0xdc, 0x85, 0x8a, 0xc7, 0x03, 0x5d, 0xc2,
|
|
0xcd, 0x8d, 0x3a, 0x1a, 0xe0, 0x41, 0x40, 0x11, 0x25, 0x1b, 0x70, 0x9b, 0x09, 0x11, 0x7b, 0x3e,
|
|
0x93, 0x7c, 0xe8, 0x2a, 0xc8, 0xf5, 0xe2, 0x49, 0x24, 0xed, 0xd2, 0xaa, 0xb5, 0x56, 0xa5, 0xb7,
|
|
0x72, 0xa1, 0xda, 0xd4, 0x53, 0x22, 0x55, 0xc3, 0x18, 0x1c, 0x61, 0x97, 0xd5, 0xf9, 0xa9, 0x59,
|
|
0x91, 0xb7, 0xa1, 0x2a, 0x24, 0x0b, 0x38, 0x56, 0x4d, 0x16, 0x16, 0x8d, 0x91, 0x77, 0x61, 0x6e,
|
|
0xcc, 0x12, 0xe9, 0xb3, 0x00, 0x8b, 0x25, 0x13, 0xa7, 0xa8, 0x73, 0x0c, 0xf0, 0x98, 0x4b, 0xca,
|
|
0x9f, 0x4f, 0xb8, 0x90, 0xe4, 0x63, 0xa8, 0x25, 0xfc, 0x34, 0xed, 0xa6, 0xe6, 0xc6, 0x2d, 0xe5,
|
|
0x37, 0x45, 0x64, 0x30, 0xe6, 0x1e, 0xb6, 0x05, 0x35, 0x2a, 0x64, 0x19, 0xca, 0xa7, 0x5c, 0xb9,
|
|
0xac, 0x34, 0xe7, 0x94, 0xa6, 0xb2, 0xa4, 0x30, 0xe7, 0x53, 0x68, 0xa2, 0x55, 0x31, 0x8e, 0x23,
|
|
0x81, 0x95, 0x9d, 0x60, 0x58, 0x6c, 0x2b, 0xaf, 0x6c, 0x1d, 0x28, 0x6a, 0x24, 0xce, 0xdf, 0x2c,
|
|
0x68, 0xf4, 0xe2, 0x68, 0xe8, 0xab, 0x19, 0x30, 0xa3, 0xe5, 0xf2, 0x16, 0x2e, 0xdd, 0xdc, 0xc2,
|
|
0x65, 0x14, 0xe5, 0x00, 0xd9, 0x80, 0x96, 0x87, 0x03, 0x87, 0xbb, 0xf2, 0x72, 0xac, 0x62, 0x54,
|
|
0xca, 0x8b, 0x01, 0xf1, 0xe3, 0xcb, 0xb1, 0xca, 0x62, 0xbe, 0x20, 0xeb, 0x00, 0x5e, 0x36, 0xa4,
|
|
0xec, 0x2a, 0x1e, 0xaf, 0x93, 0xef, 0x50, 0x28, 0x2d, 0x68, 0x38, 0xff, 0x9e, 0x83, 0xf6, 0xfe,
|
|
0x44, 0xe2, 0xf0, 0x3a, 0xc2, 0x79, 0x98, 0x79, 0x6f, 0xa5, 0xde, 0xff, 0x14, 0x9a, 0xa1, 0x52,
|
|
0x31, 0x6e, 0x94, 0xb0, 0x26, 0xef, 0x29, 0xa3, 0x53, 0x3b, 0xb3, 0x15, 0x7a, 0x05, 0x7a, 0x0b,
|
|
0x3a, 0xf5, 0x33, 0x75, 0x10, 0x55, 0x80, 0xee, 0x0b, 0x16, 0x4c, 0xd2, 0x81, 0xf2, 0xce, 0x75,
|
|
0x0b, 0xba, 0x4c, 0x9f, 0x29, 0x25, 0x75, 0xac, 0x6c, 0xa1, 0x02, 0xa5, 0x0a, 0x5b, 0x48, 0x16,
|
|
0x8e, 0xb1, 0x56, 0x2a, 0x34, 0x07, 0xa6, 0xa7, 0x55, 0xf5, 0x35, 0xa6, 0xd5, 0x2e, 0xc0, 0x70,
|
|
0x92, 0x30, 0x3d, 0x8a, 0x71, 0xb2, 0x74, 0x36, 0xee, 0x5e, 0x77, 0x67, 0x3b, 0xd3, 0x79, 0xd4,
|
|
0x7c, 0x3a, 0xe8, 0xbb, 0xdb, 0xfd, 0x9d, 0xcd, 0xa7, 0x7b, 0xc7, 0xb4, 0xb0, 0xf9, 0xca, 0x50,
|
|
0x9b, 0x7b, 0xc5, 0x50, 0xbb, 0xb1, 0x77, 0xea, 0x37, 0xf7, 0xce, 0x22, 0x54, 0xa3, 0x38, 0xf2,
|
|
0x38, 0x4e, 0xa4, 0x0a, 0xd5, 0x8b, 0x95, 0xbf, 0x94, 0xa0, 0x59, 0x08, 0xd7, 0x8d, 0x5f, 0x89,
|
|
0xa7, 0x30, 0x9f, 0x55, 0x94, 0x09, 0xbf, 0x1e, 0xfb, 0x0f, 0x5e, 0x1a, 0xfe, 0xf5, 0x5f, 0xa4,
|
|
0x9b, 0x74, 0x36, 0x3a, 0xcf, 0xa7, 0xd6, 0x2b, 0x7f, 0xb5, 0xa0, 0x33, 0xad, 0x32, 0x5d, 0xcc,
|
|
0xba, 0x7c, 0x0a, 0xc5, 0xbc, 0x08, 0xd5, 0xf4, 0xed, 0x4a, 0xa2, 0x17, 0xd3, 0x79, 0x2d, 0x5f,
|
|
0xcd, 0xeb, 0x17, 0xd0, 0x1c, 0xf2, 0x80, 0xcb, 0xac, 0xfe, 0x6f, 0xca, 0x13, 0x2a, 0xe9, 0xb2,
|
|
0x1b, 0x66, 0xcf, 0x84, 0x40, 0x45, 0xb2, 0x53, 0x81, 0xc3, 0xa3, 0x45, 0xf1, 0xd9, 0xf9, 0x0a,
|
|
0x20, 0xcf, 0x2a, 0x99, 0x87, 0x62, 0x5e, 0xbb, 0x6f, 0x91, 0x16, 0xd4, 0x07, 0x3f, 0xdf, 0x3d,
|
|
0x72, 0xbf, 0xda, 0xdc, 0xeb, 0x5a, 0xa4, 0x0d, 0x8d, 0xcd, 0xc1, 0xd7, 0x07, 0x3d, 0x5c, 0x96,
|
|
0x50, 0x98, 0xae, 0xca, 0x4a, 0xb8, 0x93, 0x2d, 0x2b, 0xce, 0x97, 0xd0, 0x2a, 0xd6, 0x3f, 0x01,
|
|
0xa8, 0x6d, 0x1e, 0x1d, 0xf5, 0x0f, 0xb6, 0xbb, 0x6f, 0x29, 0xd5, 0xdd, 0x83, 0x1e, 0xed, 0xef,
|
|
0xf7, 0x0f, 0x8e, 0xbb, 0x16, 0x99, 0x83, 0xf2, 0xd1, 0xd3, 0xe3, 0x6e, 0x49, 0xe9, 0x6c, 0xf7,
|
|
0xf7, 0xfa, 0xc7, 0xfd, 0x6e, 0xd9, 0x19, 0x03, 0xe4, 0xc7, 0x20, 0x4b, 0x40, 0xb4, 0xc4, 0x3d,
|
|
0x3c, 0xe8, 0xbb, 0xcf, 0xfa, 0x74, 0xb0, 0x7b, 0x78, 0xd0, 0x7d, 0x8b, 0xdc, 0x05, 0xdb, 0xe0,
|
|
0xfb, 0x4f, 0xf7, 0x8e, 0x77, 0x8f, 0xf6, 0x32, 0xe1, 0xa0, 0x6b, 0x91, 0x05, 0x68, 0x1b, 0xe9,
|
|
0xce, 0xe6, 0xfe, 0xee, 0xde, 0xd7, 0xdd, 0x12, 0x59, 0x86, 0xdb, 0x53, 0x50, 0x66, 0xab, 0xec,
|
|
0xfc, 0xdd, 0x32, 0xad, 0xcf, 0xbf, 0xd7, 0x04, 0xfd, 0x01, 0xd4, 0x43, 0x73, 0x60, 0x33, 0x46,
|
|
0x17, 0xae, 0x65, 0x86, 0x66, 0x2a, 0xe4, 0x63, 0x68, 0x78, 0xe9, 0x84, 0xc4, 0x4c, 0x9b, 0x36,
|
|
0xc9, 0xc6, 0x26, 0xcd, 0xe5, 0xea, 0x63, 0x8d, 0x55, 0xee, 0x9e, 0x26, 0xf1, 0x24, 0x6d, 0x78,
|
|
0x40, 0xe8, 0xb1, 0x42, 0x1c, 0x0a, 0x9d, 0xd4, 0xf5, 0xd7, 0x1f, 0xd3, 0xaa, 0xda, 0xc6, 0x49,
|
|
0xec, 0x71, 0x21, 0xf8, 0x10, 0xeb, 0xb0, 0x4e, 0x73, 0xc0, 0xf9, 0x55, 0x0d, 0x2a, 0x03, 0x8f,
|
|
0x45, 0x05, 0x82, 0x64, 0xbd, 0x1e, 0x41, 0x2a, 0xbd, 0xc6, 0xc8, 0x79, 0x1b, 0x1a, 0x42, 0xb2,
|
|
0x04, 0xb9, 0x00, 0x9e, 0xbf, 0x45, 0xeb, 0x08, 0xd0, 0xf8, 0x9c, 0x2c, 0x43, 0x5d, 0xc8, 0x78,
|
|
0x8c, 0xb2, 0x0a, 0xca, 0xe6, 0xd4, 0x9a, 0x6a, 0xb6, 0x66, 0x88, 0x55, 0xf5, 0x35, 0x89, 0x55,
|
|
0xed, 0x0d, 0x89, 0xd5, 0xdc, 0x6b, 0x11, 0xab, 0xfa, 0x4d, 0xc4, 0xea, 0x1d, 0x80, 0x13, 0x26,
|
|
0xbd, 0x33, 0x57, 0xf8, 0xdf, 0x72, 0xc3, 0x9a, 0x1a, 0x88, 0x0c, 0xfc, 0x6f, 0x39, 0xf9, 0x10,
|
|
0xe6, 0xd5, 0xdb, 0x74, 0x06, 0xb4, 0x0e, 0x60, 0x3a, 0xdb, 0x21, 0xbb, 0xd0, 0xf9, 0x41, 0xbd,
|
|
0x2b, 0xfc, 0xac, 0xf9, 0x4a, 0x7e, 0xd6, 0xba, 0xce, 0xcf, 0xb6, 0xe0, 0x5e, 0x10, 0xb3, 0xa1,
|
|
0x6b, 0x3e, 0x36, 0x38, 0x01, 0x7d, 0x2e, 0xdc, 0x38, 0x72, 0x87, 0x3c, 0x64, 0xd1, 0xd0, 0x6e,
|
|
0x63, 0xd2, 0x57, 0x94, 0x56, 0x81, 0x12, 0xf9, 0x5c, 0x1c, 0x46, 0xdb, 0xa8, 0xa1, 0xe6, 0x94,
|
|
0x08, 0x59, 0x10, 0xd8, 0x1d, 0x54, 0xd5, 0x0b, 0xf2, 0x1e, 0xd4, 0x13, 0xae, 0x22, 0xc6, 0x87,
|
|
0xf6, 0x7c, 0x91, 0x8b, 0x64, 0xf0, 0x55, 0xe6, 0xd6, 0x7d, 0x03, 0xe6, 0x66, 0xc3, 0x9c, 0x8a,
|
|
0xa8, 0x1f, 0x9d, 0xda, 0x0b, 0x78, 0xaa, 0x74, 0x89, 0xdf, 0x8b, 0x20, 0x88, 0xcf, 0x5d, 0x43,
|
|
0x79, 0x4c, 0x1c, 0x85, 0x4d, 0xd0, 0xbb, 0x5b, 0x28, 0x3c, 0xd2, 0x32, 0x1d, 0x4c, 0x71, 0x9d,
|
|
0x07, 0xde, 0x7a, 0x23, 0x1e, 0xf8, 0xfb, 0x32, 0x34, 0x55, 0x1b, 0xcc, 0x1a, 0x0a, 0xd6, 0xab,
|
|
0x86, 0xc2, 0x5d, 0xa8, 0x08, 0x8f, 0x45, 0xd8, 0x5c, 0x86, 0x39, 0xa2, 0x2d, 0x44, 0x55, 0xa9,
|
|
0xa8, 0xbf, 0x11, 0x4f, 0x5c, 0x7f, 0x98, 0x8e, 0x7b, 0x83, 0xec, 0x0e, 0xc9, 0x07, 0xd0, 0x89,
|
|
0x26, 0xe1, 0x09, 0x4f, 0xdc, 0x78, 0xa4, 0x5a, 0x41, 0x60, 0x2f, 0xb4, 0x69, 0x4b, 0xa3, 0x87,
|
|
0x23, 0x1a, 0x9f, 0x0b, 0xf2, 0x3e, 0xb4, 0x91, 0x35, 0xbb, 0x66, 0xa3, 0xe6, 0x86, 0xb4, 0x85,
|
|
0xe0, 0x40, 0x63, 0xc4, 0x81, 0x76, 0xc4, 0x2f, 0xa4, 0xeb, 0xb1, 0x20, 0x70, 0x05, 0x7f, 0x8e,
|
|
0x4d, 0x51, 0xa1, 0x4d, 0x05, 0xf6, 0x58, 0x10, 0x0c, 0xf8, 0x73, 0xf2, 0x23, 0xb8, 0xe3, 0xe1,
|
|
0x45, 0xd0, 0x3d, 0x63, 0xd1, 0x30, 0xe0, 0x22, 0x0d, 0xb2, 0xb9, 0x45, 0xd0, 0xdb, 0x5a, 0xfc,
|
|
0x44, 0x4b, 0x4d, 0x94, 0x05, 0x79, 0x04, 0xcb, 0x57, 0xf6, 0x9d, 0x71, 0x96, 0xc8, 0x13, 0xce,
|
|
0xa4, 0x69, 0x13, 0x7a, 0x67, 0x6a, 0xe7, 0x93, 0x4c, 0x4c, 0x1e, 0x00, 0x91, 0x09, 0xf3, 0xbe,
|
|
0x41, 0xe7, 0xdd, 0x90, 0xcb, 0xc4, 0xf7, 0x04, 0x36, 0x4d, 0x9d, 0x76, 0x51, 0xa2, 0x4e, 0xb0,
|
|
0xaf, 0x71, 0xc5, 0x8e, 0x13, 0x1e, 0xf1, 0xf3, 0xe9, 0x6b, 0x86, 0xc6, 0x9c, 0x7f, 0x96, 0xa0,
|
|
0xa5, 0xf3, 0x64, 0x26, 0xe0, 0x1a, 0x74, 0x15, 0xa1, 0x10, 0xee, 0x98, 0x27, 0x6e, 0x36, 0x0b,
|
|
0xcb, 0x6b, 0x6d, 0xda, 0x41, 0xfc, 0x88, 0x27, 0x86, 0xdf, 0x4f, 0xe7, 0xa1, 0x74, 0x35, 0x0f,
|
|
0xef, 0x41, 0x2b, 0x54, 0x8d, 0x96, 0xd6, 0x9a, 0xa6, 0xec, 0x4d, 0x85, 0xa5, 0x35, 0xd6, 0x85,
|
|
0xb2, 0x94, 0x81, 0xc9, 0x8f, 0x7a, 0x24, 0x1f, 0xc0, 0x5c, 0xaa, 0x5f, 0xcd, 0xa7, 0xa6, 0x19,
|
|
0xc0, 0xa9, 0x08, 0xbb, 0x0b, 0xf9, 0x7e, 0xcd, 0x74, 0x17, 0x12, 0xfd, 0xcf, 0xe1, 0x4e, 0x5a,
|
|
0xdf, 0xa3, 0x80, 0x9d, 0x16, 0x0f, 0x30, 0xb7, 0x5a, 0x5e, 0xab, 0xd3, 0x45, 0x23, 0xde, 0x09,
|
|
0xd8, 0x69, 0x7e, 0x8c, 0xcf, 0x60, 0xa9, 0xe8, 0xa7, 0xeb, 0x47, 0xae, 0xa9, 0x54, 0x9d, 0x85,
|
|
0x5b, 0x05, 0x8f, 0x77, 0x23, 0x5d, 0xb2, 0xe4, 0x63, 0x58, 0xc8, 0xd2, 0xe5, 0x86, 0x5c, 0x08,
|
|
0x76, 0xca, 0xd3, 0x04, 0x64, 0x82, 0x7d, 0x8d, 0x3b, 0xff, 0xb2, 0x60, 0x71, 0x6b, 0x12, 0x7c,
|
|
0xb3, 0x17, 0xb3, 0xe1, 0x93, 0x1d, 0x3f, 0xf8, 0x7e, 0x5f, 0xca, 0x6d, 0x68, 0x6a, 0x32, 0xe6,
|
|
0x8e, 0x99, 0x3c, 0x33, 0x5f, 0x8b, 0xf7, 0xd5, 0x8e, 0x59, 0xb6, 0xd7, 0x75, 0x77, 0x1e, 0x31,
|
|
0x79, 0x46, 0x61, 0x94, 0x3d, 0xab, 0xee, 0x60, 0x42, 0xf8, 0xa7, 0x91, 0xaa, 0x67, 0x37, 0x9a,
|
|
0x84, 0x26, 0x2f, 0x2d, 0x8d, 0x0e, 0xf8, 0xf3, 0x83, 0x49, 0xb8, 0xf2, 0x63, 0x80, 0x7c, 0xff,
|
|
0x8d, 0xa4, 0x90, 0x40, 0xc5, 0xb8, 0x52, 0x5a, 0x6b, 0x50, 0x7c, 0x76, 0x1e, 0xc2, 0xed, 0x2b,
|
|
0xee, 0x98, 0xba, 0x5a, 0x82, 0x9a, 0x9a, 0x97, 0x7c, 0x88, 0x46, 0xea, 0xd4, 0xac, 0x9c, 0xef,
|
|
0x2c, 0x58, 0xea, 0xc5, 0xe6, 0xfb, 0x19, 0x27, 0x03, 0x9e, 0xbc, 0xf0, 0x3d, 0xae, 0xba, 0x6b,
|
|
0xc6, 0x0d, 0x48, 0x4d, 0x6f, 0xad, 0xe0, 0x46, 0x2c, 0xe4, 0xe6, 0xcd, 0x4d, 0x83, 0xa9, 0xaf,
|
|
0xa6, 0xfa, 0x02, 0x84, 0x5c, 0x9e, 0xc5, 0x43, 0xad, 0x51, 0xd6, 0x3f, 0x89, 0x68, 0x08, 0x15,
|
|
0x6c, 0x55, 0x62, 0x18, 0x23, 0xbc, 0x0a, 0xb5, 0x68, 0xba, 0x74, 0x7a, 0x60, 0x5f, 0xf7, 0xc4,
|
|
0x54, 0xc9, 0xfd, 0x94, 0x78, 0xea, 0xf1, 0x35, 0xe3, 0x2b, 0xad, 0xe5, 0xce, 0x05, 0x2c, 0xcf,
|
|
0x32, 0xf2, 0x3d, 0x12, 0xbe, 0x0e, 0x15, 0x35, 0x78, 0x0c, 0x2d, 0x5a, 0xd1, 0x83, 0x77, 0x56,
|
|
0xa0, 0x28, 0xea, 0x39, 0x09, 0xac, 0xcc, 0x74, 0x5f, 0xc7, 0xff, 0x8d, 0x5e, 0x7d, 0x3f, 0xa7,
|
|
0xd9, 0xa5, 0x97, 0x9e, 0xf6, 0x0f, 0x16, 0xd4, 0x36, 0x3d, 0x64, 0x5b, 0x8b, 0x50, 0xf5, 0xa3,
|
|
0x21, 0xbf, 0xc0, 0x08, 0xb5, 0xa9, 0x5e, 0x5c, 0xe1, 0x77, 0xd6, 0xab, 0xf8, 0x9d, 0xb9, 0x50,
|
|
0x6b, 0x66, 0x37, 0x75, 0xa1, 0x26, 0x5f, 0xe4, 0xb9, 0xc7, 0xb0, 0xe8, 0x5f, 0x88, 0x5e, 0x16,
|
|
0x96, 0xb4, 0x2e, 0xd4, 0xc2, 0x39, 0x87, 0x96, 0x3e, 0xad, 0x71, 0xf7, 0x8d, 0xe2, 0xb1, 0x04,
|
|
0x35, 0x26, 0xe3, 0xd0, 0xf7, 0x0c, 0xdf, 0x33, 0x2b, 0x45, 0xab, 0x98, 0x67, 0xb8, 0x68, 0x36,
|
|
0xad, 0xf4, 0x0b, 0xa8, 0x91, 0x38, 0xbf, 0xb5, 0x60, 0x5e, 0xdb, 0x55, 0x4d, 0x31, 0x90, 0x6a,
|
|
0x80, 0xff, 0x1f, 0xb4, 0x42, 0x1e, 0x6a, 0x5a, 0x12, 0xb3, 0x21, 0x86, 0xac, 0xfa, 0xc8, 0xfa,
|
|
0x84, 0x4e, 0xc1, 0xe4, 0x3e, 0xb4, 0xcf, 0x38, 0x1b, 0x1f, 0x7a, 0xde, 0x64, 0xcc, 0x14, 0x1d,
|
|
0x28, 0xa5, 0x7a, 0xd3, 0x38, 0xf9, 0x14, 0x08, 0xde, 0xc6, 0x3d, 0x1d, 0x53, 0x2e, 0xc4, 0x24,
|
|
0xe1, 0x18, 0x45, 0xd4, 0x9e, 0x21, 0x74, 0x02, 0x58, 0xdc, 0x9f, 0x04, 0xd2, 0xbf, 0xea, 0x5a,
|
|
0x31, 0x2e, 0xe5, 0x57, 0xd7, 0x49, 0x45, 0x48, 0x26, 0xcd, 0x30, 0x2a, 0xa8, 0x66, 0xf6, 0x28,
|
|
0x2a, 0x38, 0xff, 0xb1, 0x60, 0x41, 0x77, 0xd2, 0x61, 0xd2, 0xbf, 0xf0, 0xf8, 0xf8, 0x25, 0x25,
|
|
0x93, 0x73, 0xf0, 0xd2, 0x8d, 0x1c, 0xfc, 0x21, 0x34, 0x78, 0x6a, 0xc6, 0x54, 0xcb, 0x2c, 0xe2,
|
|
0x9c, 0xe9, 0x90, 0x1e, 0x74, 0xd2, 0xea, 0x31, 0xc6, 0x75, 0xfd, 0xdc, 0x9d, 0x5d, 0x3f, 0xe6,
|
|
0x75, 0x6d, 0x31, 0x35, 0x04, 0x3e, 0x87, 0x46, 0x90, 0x1e, 0xcc, 0x10, 0xe9, 0x59, 0x67, 0xde,
|
|
0x2a, 0xd9, 0x16, 0xcd, 0x35, 0x9d, 0x5f, 0x5b, 0x40, 0x8a, 0xb5, 0x67, 0xac, 0xf5, 0x60, 0x21,
|
|
0xb9, 0x1a, 0x12, 0x13, 0xf4, 0xdb, 0xf9, 0x91, 0x0b, 0x42, 0x7a, 0x5d, 0x7f, 0x3a, 0x10, 0xa5,
|
|
0x57, 0x07, 0xc2, 0xf9, 0x8d, 0xa5, 0xae, 0x98, 0x98, 0x78, 0x3d, 0x93, 0x7e, 0x08, 0xad, 0xa4,
|
|
0xe0, 0x9c, 0xf1, 0xa0, 0x9b, 0x9f, 0xcb, 0x38, 0x3d, 0xa5, 0x45, 0xee, 0x41, 0xe1, 0x22, 0x65,
|
|
0x3e, 0xfe, 0x05, 0xe4, 0x8d, 0x2e, 0x6a, 0xce, 0x3f, 0xf0, 0x0e, 0x89, 0x3e, 0x99, 0x69, 0xb5,
|
|
0x03, 0x24, 0xb9, 0x16, 0x31, 0xe3, 0xda, 0xd2, 0x35, 0xd7, 0x74, 0xb2, 0x66, 0xec, 0x78, 0xf9,
|
|
0x5d, 0x8d, 0x6c, 0x43, 0x57, 0xef, 0x51, 0x79, 0xf2, 0x85, 0x54, 0x2c, 0x4a, 0xfb, 0x6a, 0xeb,
|
|
0x21, 0x75, 0xbd, 0x3f, 0xe8, 0xb5, 0x1d, 0x1f, 0xdd, 0x87, 0x66, 0x81, 0x9b, 0xab, 0xeb, 0xb8,
|
|
0x66, 0xe7, 0xfa, 0x87, 0x80, 0xe3, 0xdd, 0xfd, 0xfe, 0xde, 0xee, 0x41, 0xbf, 0x6b, 0x6d, 0xfc,
|
|
0xa9, 0x0c, 0x6d, 0xfd, 0x4f, 0x03, 0x53, 0x65, 0xe4, 0x43, 0xfd, 0xeb, 0x7a, 0x27, 0x1d, 0x74,
|
|
0x3a, 0x25, 0x2b, 0xf3, 0xd9, 0xda, 0x84, 0xe3, 0x21, 0xd4, 0xf4, 0x45, 0x95, 0xe4, 0xd3, 0x33,
|
|
0xfd, 0xa8, 0xac, 0x90, 0x22, 0x64, 0x36, 0xfc, 0xbf, 0xb9, 0x84, 0xce, 0x67, 0xdc, 0xd9, 0x28,
|
|
0x77, 0x73, 0xc0, 0xa8, 0x6e, 0x43, 0x7b, 0xea, 0x8b, 0x4d, 0xec, 0x9b, 0x38, 0xc5, 0xca, 0xf2,
|
|
0x0c, 0x89, 0xb1, 0xb2, 0x07, 0xcd, 0xfe, 0x05, 0xf7, 0xd2, 0x83, 0xbd, 0x73, 0x53, 0x5b, 0x69,
|
|
0x43, 0xf7, 0x6e, 0xec, 0x3a, 0x6d, 0xed, 0x97, 0x70, 0x47, 0x59, 0x33, 0x63, 0x87, 0x27, 0x2f,
|
|
0x78, 0xf2, 0x3f, 0xb2, 0xfc, 0x00, 0xaa, 0x98, 0x56, 0xd2, 0x2d, 0x64, 0x58, 0x6f, 0x5d, 0x28,
|
|
0x20, 0x5a, 0x7b, 0x6b, 0x0b, 0x3e, 0x8a, 0x93, 0xd3, 0x75, 0x36, 0x56, 0x37, 0xd5, 0xf5, 0x33,
|
|
0x36, 0x8c, 0xe3, 0xf1, 0xfa, 0xd9, 0x49, 0xf6, 0x5f, 0x9e, 0x93, 0xc9, 0x68, 0xfd, 0x94, 0x47,
|
|
0x3c, 0x61, 0x92, 0x0f, 0xb7, 0xcc, 0x7f, 0x84, 0xf0, 0x9b, 0x26, 0x9e, 0x58, 0xdf, 0x59, 0xd6,
|
|
0xef, 0x2c, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x86, 0x46, 0xcb, 0xdc, 0x28, 0x1a, 0x00,
|
|
0x00,
|
|
}
|