forgejo/vendor/github.com/pingcap/go-hbase/proto/WAL.pb.go

// Code generated by protoc-gen-go.
// source: WAL.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 ScopeType int32

const (
	ScopeType_REPLICATION_SCOPE_LOCAL  ScopeType = 0
	ScopeType_REPLICATION_SCOPE_GLOBAL ScopeType = 1
)

var ScopeType_name = map[int32]string{
	0: "REPLICATION_SCOPE_LOCAL",
	1: "REPLICATION_SCOPE_GLOBAL",
}
var ScopeType_value = map[string]int32{
	"REPLICATION_SCOPE_LOCAL":  0,
	"REPLICATION_SCOPE_GLOBAL": 1,
}

func (x ScopeType) Enum() *ScopeType {
	p := new(ScopeType)
	*p = x
	return p
}
func (x ScopeType) String() string {
	return proto1.EnumName(ScopeType_name, int32(x))
}
func (x *ScopeType) UnmarshalJSON(data []byte) error {
	value, err := proto1.UnmarshalJSONEnum(ScopeType_value, data, "ScopeType")
	if err != nil {
		return err
	}
	*x = ScopeType(value)
	return nil
}

type WALHeader struct {
	HasCompression    *bool   `protobuf:"varint,1,opt,name=has_compression" json:"has_compression,omitempty"`
	EncryptionKey     []byte  `protobuf:"bytes,2,opt,name=encryption_key" json:"encryption_key,omitempty"`
	HasTagCompression *bool   `protobuf:"varint,3,opt,name=has_tag_compression" json:"has_tag_compression,omitempty"`
	WriterClsName     *string `protobuf:"bytes,4,opt,name=writer_cls_name" json:"writer_cls_name,omitempty"`
	CellCodecClsName  *string `protobuf:"bytes,5,opt,name=cell_codec_cls_name" json:"cell_codec_cls_name,omitempty"`
	XXX_unrecognized  []byte  `json:"-"`
}

func (m *WALHeader) Reset()         { *m = WALHeader{} }
func (m *WALHeader) String() string { return proto1.CompactTextString(m) }
func (*WALHeader) ProtoMessage()    {}

func (m *WALHeader) GetHasCompression() bool {
	if m != nil && m.HasCompression != nil {
		return *m.HasCompression
	}
	return false
}

func (m *WALHeader) GetEncryptionKey() []byte {
	if m != nil {
		return m.EncryptionKey
	}
	return nil
}

func (m *WALHeader) GetHasTagCompression() bool {
	if m != nil && m.HasTagCompression != nil {
		return *m.HasTagCompression
	}
	return false
}

func (m *WALHeader) GetWriterClsName() string {
	if m != nil && m.WriterClsName != nil {
		return *m.WriterClsName
	}
	return ""
}

func (m *WALHeader) GetCellCodecClsName() string {
	if m != nil && m.CellCodecClsName != nil {
		return *m.CellCodecClsName
	}
	return ""
}

// Protocol buffer version of HLogKey; see HLogKey comment, not really a key but WALEdit header for some KVs
type WALKey struct {
	EncodedRegionName []byte  `protobuf:"bytes,1,req,name=encoded_region_name" json:"encoded_region_name,omitempty"`
	TableName         []byte  `protobuf:"bytes,2,req,name=table_name" json:"table_name,omitempty"`
	LogSequenceNumber *uint64 `protobuf:"varint,3,req,name=log_sequence_number" json:"log_sequence_number,omitempty"`
	WriteTime         *uint64 `protobuf:"varint,4,req,name=write_time" json:"write_time,omitempty"`
	//
	// This parameter is deprecated in favor of clusters which
	// contains the list of clusters that have consumed the change.
	// It is retained so that the log created by earlier releases (0.94)
	// can be read by the newer releases.
	ClusterId        *UUID          `protobuf:"bytes,5,opt,name=cluster_id" json:"cluster_id,omitempty"`
	Scopes           []*FamilyScope `protobuf:"bytes,6,rep,name=scopes" json:"scopes,omitempty"`
	FollowingKvCount *uint32        `protobuf:"varint,7,opt,name=following_kv_count" json:"following_kv_count,omitempty"`
	//
	// This field contains the list of clusters that have
	// consumed the change
	ClusterIds       []*UUID `protobuf:"bytes,8,rep,name=cluster_ids" json:"cluster_ids,omitempty"`
	NonceGroup       *uint64 `protobuf:"varint,9,opt,name=nonceGroup" json:"nonceGroup,omitempty"`
	Nonce            *uint64 `protobuf:"varint,10,opt,name=nonce" json:"nonce,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *WALKey) Reset()         { *m = WALKey{} }
func (m *WALKey) String() string { return proto1.CompactTextString(m) }
func (*WALKey) ProtoMessage()    {}

func (m *WALKey) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *WALKey) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *WALKey) GetLogSequenceNumber() uint64 {
	if m != nil && m.LogSequenceNumber != nil {
		return *m.LogSequenceNumber
	}
	return 0
}

func (m *WALKey) GetWriteTime() uint64 {
	if m != nil && m.WriteTime != nil {
		return *m.WriteTime
	}
	return 0
}

func (m *WALKey) GetClusterId() *UUID {
	if m != nil {
		return m.ClusterId
	}
	return nil
}

func (m *WALKey) GetScopes() []*FamilyScope {
	if m != nil {
		return m.Scopes
	}
	return nil
}

func (m *WALKey) GetFollowingKvCount() uint32 {
	if m != nil && m.FollowingKvCount != nil {
		return *m.FollowingKvCount
	}
	return 0
}

func (m *WALKey) GetClusterIds() []*UUID {
	if m != nil {
		return m.ClusterIds
	}
	return nil
}

func (m *WALKey) GetNonceGroup() uint64 {
	if m != nil && m.NonceGroup != nil {
		return *m.NonceGroup
	}
	return 0
}

func (m *WALKey) GetNonce() uint64 {
	if m != nil && m.Nonce != nil {
		return *m.Nonce
	}
	return 0
}

type FamilyScope struct {
	Family           []byte     `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
	ScopeType        *ScopeType `protobuf:"varint,2,req,name=scope_type,enum=proto.ScopeType" json:"scope_type,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

func (m *FamilyScope) Reset()         { *m = FamilyScope{} }
func (m *FamilyScope) String() string { return proto1.CompactTextString(m) }
func (*FamilyScope) ProtoMessage()    {}

func (m *FamilyScope) GetFamily() []byte {
	if m != nil {
		return m.Family
	}
	return nil
}

func (m *FamilyScope) GetScopeType() ScopeType {
	if m != nil && m.ScopeType != nil {
		return *m.ScopeType
	}
	return ScopeType_REPLICATION_SCOPE_LOCAL
}

// *
// Special WAL entry to hold all related to a compaction.
// Written to WAL before completing compaction.  There is
// sufficient info in the below message to complete later
// the * compaction should we fail the WAL write.
type CompactionDescriptor struct {
	TableName         []byte   `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"`
	EncodedRegionName []byte   `protobuf:"bytes,2,req,name=encoded_region_name" json:"encoded_region_name,omitempty"`
	FamilyName        []byte   `protobuf:"bytes,3,req,name=family_name" json:"family_name,omitempty"`
	CompactionInput   []string `protobuf:"bytes,4,rep,name=compaction_input" json:"compaction_input,omitempty"`
	CompactionOutput  []string `protobuf:"bytes,5,rep,name=compaction_output" json:"compaction_output,omitempty"`
	StoreHomeDir      *string  `protobuf:"bytes,6,req,name=store_home_dir" json:"store_home_dir,omitempty"`
	RegionName        []byte   `protobuf:"bytes,7,opt,name=region_name" json:"region_name,omitempty"`
	XXX_unrecognized  []byte   `json:"-"`
}

func (m *CompactionDescriptor) Reset()         { *m = CompactionDescriptor{} }
func (m *CompactionDescriptor) String() string { return proto1.CompactTextString(m) }
func (*CompactionDescriptor) ProtoMessage()    {}

func (m *CompactionDescriptor) GetTableName() []byte {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *CompactionDescriptor) GetEncodedRegionName() []byte {
	if m != nil {
		return m.EncodedRegionName
	}
	return nil
}

func (m *CompactionDescriptor) GetFamilyName() []byte {
	if m != nil {
		return m.FamilyName
	}
	return nil
}

func (m *CompactionDescriptor) GetCompactionInput() []string {
	if m != nil {
		return m.CompactionInput
	}
	return nil
}

func (m *CompactionDescriptor) GetCompactionOutput() []string {
	if m != nil {
		return m.CompactionOutput
	}
	return nil
}

func (m *CompactionDescriptor) GetStoreHomeDir() string {
	if m != nil && m.StoreHomeDir != nil {
		return *m.StoreHomeDir
	}
	return ""
}

func (m *CompactionDescriptor) GetRegionName() []byte {
	if m != nil {
		return m.RegionName
	}
	return nil
}

// *
// A trailer that is appended to the end of a properly closed HLog WAL file.
// If missing, this is either a legacy or a corrupted WAL file.
type WALTrailer struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *WALTrailer) Reset()         { *m = WALTrailer{} }
func (m *WALTrailer) String() string { return proto1.CompactTextString(m) }
func (*WALTrailer) ProtoMessage()    {}

func init() {
	proto1.RegisterEnum("proto.ScopeType", ScopeType_name, ScopeType_value)
}