mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-02 10:07:07 -05:00
b6a95a8cb3
* Dropped unused codekit config * Integrated dynamic and static bindata for public * Ignore public bindata * Add a general generate make task * Integrated flexible public assets into web command * Updated vendoring, added all missiong govendor deps * Made the linter happy with the bindata and dynamic code * Moved public bindata definition to modules directory * Ignoring the new bindata path now * Updated to the new public modules import path * Updated public bindata command and drop the new prefix
1411 lines
42 KiB
Go
1411 lines
42 KiB
Go
// Code generated by protoc-gen-go.
|
|
// source: Client.proto
|
|
// DO NOT EDIT!
|
|
|
|
package proto
|
|
|
|
import proto1 "github.com/golang/protobuf/proto"
|
|
import math "math"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto1.Marshal
|
|
var _ = math.Inf
|
|
|
|
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 proto1.EnumName(MutationProto_Durability_name, int32(x))
|
|
}
|
|
func (x *MutationProto_Durability) UnmarshalJSON(data []byte) error {
|
|
value, err := proto1.UnmarshalJSONEnum(MutationProto_Durability_value, data, "MutationProto_Durability")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_Durability(value)
|
|
return nil
|
|
}
|
|
|
|
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 proto1.EnumName(MutationProto_MutationType_name, int32(x))
|
|
}
|
|
func (x *MutationProto_MutationType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto1.UnmarshalJSONEnum(MutationProto_MutationType_value, data, "MutationProto_MutationType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_MutationType(value)
|
|
return nil
|
|
}
|
|
|
|
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 proto1.EnumName(MutationProto_DeleteType_name, int32(x))
|
|
}
|
|
func (x *MutationProto_DeleteType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto1.UnmarshalJSONEnum(MutationProto_DeleteType_value, data, "MutationProto_DeleteType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MutationProto_DeleteType(value)
|
|
return nil
|
|
}
|
|
|
|
// *
|
|
// 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 proto1.CompactTextString(m) }
|
|
func (*Authorizations) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*CellVisibility) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*Column) ProtoMessage() {}
|
|
|
|
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:"time_range,omitempty"`
|
|
MaxVersions *uint32 `protobuf:"varint,6,opt,name=max_versions,def=1" json:"max_versions,omitempty"`
|
|
CacheBlocks *bool `protobuf:"varint,7,opt,name=cache_blocks,def=1" json:"cache_blocks,omitempty"`
|
|
StoreLimit *uint32 `protobuf:"varint,8,opt,name=store_limit" json:"store_limit,omitempty"`
|
|
StoreOffset *uint32 `protobuf:"varint,9,opt,name=store_offset" json:"store_offset,omitempty"`
|
|
// The result isn't asked for, just check for
|
|
// the existence.
|
|
ExistenceOnly *bool `protobuf:"varint,10,opt,name=existence_only,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,def=0" json:"closest_row_before,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Get) Reset() { *m = Get{} }
|
|
func (m *Get) String() string { return proto1.CompactTextString(m) }
|
|
func (*Get) ProtoMessage() {}
|
|
|
|
const Default_Get_MaxVersions uint32 = 1
|
|
const Default_Get_CacheBlocks bool = true
|
|
const Default_Get_ExistenceOnly bool = false
|
|
const Default_Get_ClosestRowBefore bool = false
|
|
|
|
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
|
|
}
|
|
|
|
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:"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"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Result) Reset() { *m = Result{} }
|
|
func (m *Result) String() string { return proto1.CompactTextString(m) }
|
|
func (*Result) ProtoMessage() {}
|
|
|
|
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
|
|
}
|
|
|
|
// *
|
|
// 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 proto1.CompactTextString(m) }
|
|
func (*GetRequest) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*GetResponse) ProtoMessage() {}
|
|
|
|
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,enum=proto.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 proto1.CompactTextString(m) }
|
|
func (*Condition) ProtoMessage() {}
|
|
|
|
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,enum=proto.MutationProto_MutationType" json:"mutate_type,omitempty"`
|
|
ColumnValue []*MutationProto_ColumnValue `protobuf:"bytes,3,rep,name=column_value" 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=proto.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:"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:"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 proto1.CompactTextString(m) }
|
|
func (*MutationProto) ProtoMessage() {}
|
|
|
|
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:"qualifier_value,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutationProto_ColumnValue) Reset() { *m = MutationProto_ColumnValue{} }
|
|
func (m *MutationProto_ColumnValue) String() string { return proto1.CompactTextString(m) }
|
|
func (*MutationProto_ColumnValue) ProtoMessage() {}
|
|
|
|
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,enum=proto.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 proto1.CompactTextString(m) }
|
|
func (*MutationProto_ColumnValue_QualifierValue) ProtoMessage() {}
|
|
|
|
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:"nonce_group,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MutateRequest) Reset() { *m = MutateRequest{} }
|
|
func (m *MutateRequest) String() string { return proto1.CompactTextString(m) }
|
|
func (*MutateRequest) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*MutateResponse) ProtoMessage() {}
|
|
|
|
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:"start_row,omitempty"`
|
|
StopRow []byte `protobuf:"bytes,4,opt,name=stop_row" 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:"time_range,omitempty"`
|
|
MaxVersions *uint32 `protobuf:"varint,7,opt,name=max_versions,def=1" json:"max_versions,omitempty"`
|
|
CacheBlocks *bool `protobuf:"varint,8,opt,name=cache_blocks,def=1" json:"cache_blocks,omitempty"`
|
|
BatchSize *uint32 `protobuf:"varint,9,opt,name=batch_size" json:"batch_size,omitempty"`
|
|
MaxResultSize *uint64 `protobuf:"varint,10,opt,name=max_result_size" json:"max_result_size,omitempty"`
|
|
StoreLimit *uint32 `protobuf:"varint,11,opt,name=store_limit" json:"store_limit,omitempty"`
|
|
StoreOffset *uint32 `protobuf:"varint,12,opt,name=store_offset" json:"store_offset,omitempty"`
|
|
LoadColumnFamiliesOnDemand *bool `protobuf:"varint,13,opt,name=load_column_families_on_demand" 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"`
|
|
Caching *uint32 `protobuf:"varint,17,opt,name=caching" json:"caching,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Scan) Reset() { *m = Scan{} }
|
|
func (m *Scan) String() string { return proto1.CompactTextString(m) }
|
|
func (*Scan) ProtoMessage() {}
|
|
|
|
const Default_Scan_MaxVersions uint32 = 1
|
|
const Default_Scan_CacheBlocks bool = true
|
|
const Default_Scan_Reversed bool = false
|
|
|
|
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) GetCaching() uint32 {
|
|
if m != nil && m.Caching != nil {
|
|
return *m.Caching
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// *
|
|
// 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:"scanner_id,omitempty"`
|
|
NumberOfRows *uint32 `protobuf:"varint,4,opt,name=number_of_rows" json:"number_of_rows,omitempty"`
|
|
CloseScanner *bool `protobuf:"varint,5,opt,name=close_scanner" json:"close_scanner,omitempty"`
|
|
NextCallSeq *uint64 `protobuf:"varint,6,opt,name=next_call_seq" json:"next_call_seq,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ScanRequest) Reset() { *m = ScanRequest{} }
|
|
func (m *ScanRequest) String() string { return proto1.CompactTextString(m) }
|
|
func (*ScanRequest) ProtoMessage() {}
|
|
|
|
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
|
|
}
|
|
|
|
// *
|
|
// 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:"cells_per_result,omitempty"`
|
|
ScannerId *uint64 `protobuf:"varint,2,opt,name=scanner_id" json:"scanner_id,omitempty"`
|
|
MoreResults *bool `protobuf:"varint,3,opt,name=more_results" 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"`
|
|
// 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:"more_results_in_region,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *ScanResponse) Reset() { *m = ScanResponse{} }
|
|
func (m *ScanResponse) String() string { return proto1.CompactTextString(m) }
|
|
func (*ScanResponse) ProtoMessage() {}
|
|
|
|
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) GetMoreResultsInRegion() bool {
|
|
if m != nil && m.MoreResultsInRegion != nil {
|
|
return *m.MoreResultsInRegion
|
|
}
|
|
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:"family_path,omitempty"`
|
|
AssignSeqNum *bool `protobuf:"varint,3,opt,name=assign_seq_num" json:"assign_seq_num,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *BulkLoadHFileRequest) Reset() { *m = BulkLoadHFileRequest{} }
|
|
func (m *BulkLoadHFileRequest) String() string { return proto1.CompactTextString(m) }
|
|
func (*BulkLoadHFileRequest) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*BulkLoadHFileRequest_FamilyPath) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*BulkLoadHFileResponse) ProtoMessage() {}
|
|
|
|
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:"service_name,omitempty"`
|
|
MethodName *string `protobuf:"bytes,3,req,name=method_name" 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 proto1.CompactTextString(m) }
|
|
func (*CoprocessorServiceCall) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*CoprocessorServiceResult) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*CoprocessorServiceRequest) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*CoprocessorServiceResponse) ProtoMessage() {}
|
|
|
|
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:"service_call,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Action) Reset() { *m = Action{} }
|
|
func (m *Action) String() string { return proto1.CompactTextString(m) }
|
|
func (*Action) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*RegionAction) ProtoMessage() {}
|
|
|
|
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"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *RegionLoadStats) Reset() { *m = RegionLoadStats{} }
|
|
func (m *RegionLoadStats) String() string { return proto1.CompactTextString(m) }
|
|
func (*RegionLoadStats) ProtoMessage() {}
|
|
|
|
const Default_RegionLoadStats_MemstoreLoad int32 = 0
|
|
const Default_RegionLoadStats_HeapOccupancy 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
|
|
}
|
|
|
|
// *
|
|
// 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:"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 proto1.CompactTextString(m) }
|
|
func (*ResultOrException) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*RegionActionResult) ProtoMessage() {}
|
|
|
|
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 proto1.CompactTextString(m) }
|
|
func (*MultiRequest) ProtoMessage() {}
|
|
|
|
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"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *MultiResponse) Reset() { *m = MultiResponse{} }
|
|
func (m *MultiResponse) String() string { return proto1.CompactTextString(m) }
|
|
func (*MultiResponse) ProtoMessage() {}
|
|
|
|
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 init() {
|
|
proto1.RegisterEnum("proto.MutationProto_Durability", MutationProto_Durability_name, MutationProto_Durability_value)
|
|
proto1.RegisterEnum("proto.MutationProto_MutationType", MutationProto_MutationType_name, MutationProto_MutationType_value)
|
|
proto1.RegisterEnum("proto.MutationProto_DeleteType", MutationProto_DeleteType_name, MutationProto_DeleteType_value)
|
|
}
|