forgejo/vendor/github.com/pingcap/go-hbase/proto/Client.pb.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)
}