ttypes.go

// Autogenerated by Thrift Compiler (0.9.2)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package hbase

import (
	"bytes"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

var GoUnusedProtection__ int

type Text []byte

func TextPtr(v Text) *Text { return &v }

type Bytes []byte

func BytesPtr(v Bytes) *Bytes { return &v }

type ScannerID int32

func ScannerIDPtr(v ScannerID) *ScannerID { return &v }

type TCell struct {
	Value     Bytes `thrift:"value,1" json:"value"`
	Timestamp int64 `thrift:"timestamp,2" json:"timestamp"`
}

func NewTCell() *TCell {
	return &TCell{}
}

func (p *TCell) GetValue() Bytes {
	return p.Value
}

func (p *TCell) GetTimestamp() int64 {
	return p.Timestamp
}
func (p *TCell) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TCell) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Bytes(v)
		p.Value = temp
	}
	return nil
}

func (p *TCell) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Timestamp = v
	}
	return nil
}

func (p *TCell) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TCell"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TCell) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("value", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:value: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Value); err != nil {
		return fmt.Errorf("%T.value (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:value: %s", p, err)
	}
	return err
}

func (p *TCell) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("timestamp", thrift.I64, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:timestamp: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.Timestamp)); err != nil {
		return fmt.Errorf("%T.timestamp (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:timestamp: %s", p, err)
	}
	return err
}

func (p *TCell) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TCell(%+v)", *p)
}

type ColumnDescriptor struct {
	Name                  Text   `thrift:"name,1" json:"name"`
	MaxVersions           int32  `thrift:"maxVersions,2" json:"maxVersions"`
	Compression           string `thrift:"compression,3" json:"compression"`
	InMemory              bool   `thrift:"inMemory,4" json:"inMemory"`
	BloomFilterType       string `thrift:"bloomFilterType,5" json:"bloomFilterType"`
	BloomFilterVectorSize int32  `thrift:"bloomFilterVectorSize,6" json:"bloomFilterVectorSize"`
	BloomFilterNbHashes   int32  `thrift:"bloomFilterNbHashes,7" json:"bloomFilterNbHashes"`
	BlockCacheEnabled     bool   `thrift:"blockCacheEnabled,8" json:"blockCacheEnabled"`
	TimeToLive            int32  `thrift:"timeToLive,9" json:"timeToLive"`
}

func NewColumnDescriptor() *ColumnDescriptor {
	return &ColumnDescriptor{
		MaxVersions: 3,

		Compression: "NONE",

		BloomFilterType: "NONE",

		TimeToLive: 2147483647,
	}
}

func (p *ColumnDescriptor) GetName() Text {
	return p.Name
}

func (p *ColumnDescriptor) GetMaxVersions() int32 {
	return p.MaxVersions
}

func (p *ColumnDescriptor) GetCompression() string {
	return p.Compression
}

func (p *ColumnDescriptor) GetInMemory() bool {
	return p.InMemory
}

func (p *ColumnDescriptor) GetBloomFilterType() string {
	return p.BloomFilterType
}

func (p *ColumnDescriptor) GetBloomFilterVectorSize() int32 {
	return p.BloomFilterVectorSize
}

func (p *ColumnDescriptor) GetBloomFilterNbHashes() int32 {
	return p.BloomFilterNbHashes
}

func (p *ColumnDescriptor) GetBlockCacheEnabled() bool {
	return p.BlockCacheEnabled
}

func (p *ColumnDescriptor) GetTimeToLive() int32 {
	return p.TimeToLive
}
func (p *ColumnDescriptor) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		case 8:
			if err := p.ReadField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.ReadField9(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *ColumnDescriptor) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.Name = temp
	}
	return nil
}

func (p *ColumnDescriptor) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.MaxVersions = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Compression = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.InMemory = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.BloomFilterType = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		p.BloomFilterVectorSize = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 7: %s", err)
	} else {
		p.BloomFilterNbHashes = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 8: %s", err)
	} else {
		p.BlockCacheEnabled = v
	}
	return nil
}

func (p *ColumnDescriptor) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 9: %s", err)
	} else {
		p.TimeToLive = v
	}
	return nil
}

func (p *ColumnDescriptor) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ColumnDescriptor"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := p.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *ColumnDescriptor) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("name", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:name: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Name); err != nil {
		return fmt.Errorf("%T.name (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:name: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("maxVersions", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:maxVersions: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.MaxVersions)); err != nil {
		return fmt.Errorf("%T.maxVersions (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:maxVersions: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("compression", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:compression: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Compression)); err != nil {
		return fmt.Errorf("%T.compression (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:compression: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("inMemory", thrift.BOOL, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:inMemory: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.InMemory)); err != nil {
		return fmt.Errorf("%T.inMemory (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:inMemory: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("bloomFilterType", thrift.STRING, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:bloomFilterType: %s", p, err)
	}
	if err := oprot.WriteString(string(p.BloomFilterType)); err != nil {
		return fmt.Errorf("%T.bloomFilterType (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:bloomFilterType: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("bloomFilterVectorSize", thrift.I32, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:bloomFilterVectorSize: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.BloomFilterVectorSize)); err != nil {
		return fmt.Errorf("%T.bloomFilterVectorSize (6) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:bloomFilterVectorSize: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("bloomFilterNbHashes", thrift.I32, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:bloomFilterNbHashes: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.BloomFilterNbHashes)); err != nil {
		return fmt.Errorf("%T.bloomFilterNbHashes (7) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:bloomFilterNbHashes: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField8(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("blockCacheEnabled", thrift.BOOL, 8); err != nil {
		return fmt.Errorf("%T write field begin error 8:blockCacheEnabled: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.BlockCacheEnabled)); err != nil {
		return fmt.Errorf("%T.blockCacheEnabled (8) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 8:blockCacheEnabled: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) writeField9(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("timeToLive", thrift.I32, 9); err != nil {
		return fmt.Errorf("%T write field begin error 9:timeToLive: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.TimeToLive)); err != nil {
		return fmt.Errorf("%T.timeToLive (9) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 9:timeToLive: %s", p, err)
	}
	return err
}

func (p *ColumnDescriptor) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ColumnDescriptor(%+v)", *p)
}

type TRegionInfo struct {
	StartKey   Text  `thrift:"startKey,1" json:"startKey"`
	EndKey     Text  `thrift:"endKey,2" json:"endKey"`
	Id         int64 `thrift:"id,3" json:"id"`
	Name       Text  `thrift:"name,4" json:"name"`
	Version    int8  `thrift:"version,5" json:"version"`
	ServerName Text  `thrift:"serverName,6" json:"serverName"`
	Port       int32 `thrift:"port,7" json:"port"`
}

func NewTRegionInfo() *TRegionInfo {
	return &TRegionInfo{}
}

func (p *TRegionInfo) GetStartKey() Text {
	return p.StartKey
}

func (p *TRegionInfo) GetEndKey() Text {
	return p.EndKey
}

func (p *TRegionInfo) GetId() int64 {
	return p.Id
}

func (p *TRegionInfo) GetName() Text {
	return p.Name
}

func (p *TRegionInfo) GetVersion() int8 {
	return p.Version
}

func (p *TRegionInfo) GetServerName() Text {
	return p.ServerName
}

func (p *TRegionInfo) GetPort() int32 {
	return p.Port
}
func (p *TRegionInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TRegionInfo) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.StartKey = temp
	}
	return nil
}

func (p *TRegionInfo) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := Text(v)
		p.EndKey = temp
	}
	return nil
}

func (p *TRegionInfo) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Id = v
	}
	return nil
}

func (p *TRegionInfo) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		temp := Text(v)
		p.Name = temp
	}
	return nil
}

func (p *TRegionInfo) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		temp := int8(v)
		p.Version = temp
	}
	return nil
}

func (p *TRegionInfo) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		temp := Text(v)
		p.ServerName = temp
	}
	return nil
}

func (p *TRegionInfo) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 7: %s", err)
	} else {
		p.Port = v
	}
	return nil
}

func (p *TRegionInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TRegionInfo"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TRegionInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("startKey", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:startKey: %s", p, err)
	}
	if err := oprot.WriteBinary(p.StartKey); err != nil {
		return fmt.Errorf("%T.startKey (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:startKey: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("endKey", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:endKey: %s", p, err)
	}
	if err := oprot.WriteBinary(p.EndKey); err != nil {
		return fmt.Errorf("%T.endKey (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:endKey: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("id", thrift.I64, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:id: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.Id)); err != nil {
		return fmt.Errorf("%T.id (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:id: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("name", thrift.STRING, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:name: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Name); err != nil {
		return fmt.Errorf("%T.name (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:name: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField5(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("version", thrift.BYTE, 5); err != nil {
		return fmt.Errorf("%T write field begin error 5:version: %s", p, err)
	}
	if err := oprot.WriteByte(int8(p.Version)); err != nil {
		return fmt.Errorf("%T.version (5) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 5:version: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField6(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("serverName", thrift.STRING, 6); err != nil {
		return fmt.Errorf("%T write field begin error 6:serverName: %s", p, err)
	}
	if err := oprot.WriteBinary(p.ServerName); err != nil {
		return fmt.Errorf("%T.serverName (6) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 6:serverName: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) writeField7(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("port", thrift.I32, 7); err != nil {
		return fmt.Errorf("%T write field begin error 7:port: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.Port)); err != nil {
		return fmt.Errorf("%T.port (7) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 7:port: %s", p, err)
	}
	return err
}

func (p *TRegionInfo) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TRegionInfo(%+v)", *p)
}

type Mutation struct {
	IsDelete   bool `thrift:"isDelete,1" json:"isDelete"`
	Column     Text `thrift:"column,2" json:"column"`
	Value      Text `thrift:"value,3" json:"value"`
	WriteToWAL bool `thrift:"writeToWAL,4" json:"writeToWAL"`
}

func NewMutation() *Mutation {
	return &Mutation{
		WriteToWAL: true,
	}
}

func (p *Mutation) GetIsDelete() bool {
	return p.IsDelete
}

func (p *Mutation) GetColumn() Text {
	return p.Column
}

func (p *Mutation) GetValue() Text {
	return p.Value
}

func (p *Mutation) GetWriteToWAL() bool {
	return p.WriteToWAL
}
func (p *Mutation) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Mutation) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.IsDelete = v
	}
	return nil
}

func (p *Mutation) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := Text(v)
		p.Column = temp
	}
	return nil
}

func (p *Mutation) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := Text(v)
		p.Value = temp
	}
	return nil
}

func (p *Mutation) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.WriteToWAL = v
	}
	return nil
}

func (p *Mutation) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Mutation"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *Mutation) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("isDelete", thrift.BOOL, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:isDelete: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.IsDelete)); err != nil {
		return fmt.Errorf("%T.isDelete (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:isDelete: %s", p, err)
	}
	return err
}

func (p *Mutation) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("column", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:column: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Column); err != nil {
		return fmt.Errorf("%T.column (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:column: %s", p, err)
	}
	return err
}

func (p *Mutation) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("value", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:value: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Value); err != nil {
		return fmt.Errorf("%T.value (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:value: %s", p, err)
	}
	return err
}

func (p *Mutation) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("writeToWAL", thrift.BOOL, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:writeToWAL: %s", p, err)
	}
	if err := oprot.WriteBool(bool(p.WriteToWAL)); err != nil {
		return fmt.Errorf("%T.writeToWAL (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:writeToWAL: %s", p, err)
	}
	return err
}

func (p *Mutation) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Mutation(%+v)", *p)
}

type BatchMutation struct {
	Row       Text        `thrift:"row,1" json:"row"`
	Mutations []*Mutation `thrift:"mutations,2" json:"mutations"`
}

func NewBatchMutation() *BatchMutation {
	return &BatchMutation{}
}

func (p *BatchMutation) GetRow() Text {
	return p.Row
}

func (p *BatchMutation) GetMutations() []*Mutation {
	return p.Mutations
}
func (p *BatchMutation) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *BatchMutation) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.Row = temp
	}
	return nil
}

func (p *BatchMutation) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*Mutation, 0, size)
	p.Mutations = tSlice
	for i := 0; i < size; i++ {
		_elem0 := &Mutation{
			WriteToWAL: true,
		}
		if err := _elem0.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem0, err)
		}
		p.Mutations = append(p.Mutations, _elem0)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *BatchMutation) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("BatchMutation"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *BatchMutation) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("row", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:row: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Row); err != nil {
		return fmt.Errorf("%T.row (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:row: %s", p, err)
	}
	return err
}

func (p *BatchMutation) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("mutations", thrift.LIST, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:mutations: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Mutations)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Mutations {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:mutations: %s", p, err)
	}
	return err
}

func (p *BatchMutation) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("BatchMutation(%+v)", *p)
}

type TIncrement struct {
	Table   Text  `thrift:"table,1" json:"table"`
	Row     Text  `thrift:"row,2" json:"row"`
	Column  Text  `thrift:"column,3" json:"column"`
	Ammount int64 `thrift:"ammount,4" json:"ammount"`
}

func NewTIncrement() *TIncrement {
	return &TIncrement{}
}

func (p *TIncrement) GetTable() Text {
	return p.Table
}

func (p *TIncrement) GetRow() Text {
	return p.Row
}

func (p *TIncrement) GetColumn() Text {
	return p.Column
}

func (p *TIncrement) GetAmmount() int64 {
	return p.Ammount
}
func (p *TIncrement) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TIncrement) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.Table = temp
	}
	return nil
}

func (p *TIncrement) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := Text(v)
		p.Row = temp
	}
	return nil
}

func (p *TIncrement) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		temp := Text(v)
		p.Column = temp
	}
	return nil
}

func (p *TIncrement) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.Ammount = v
	}
	return nil
}

func (p *TIncrement) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TIncrement"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TIncrement) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("table", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:table: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Table); err != nil {
		return fmt.Errorf("%T.table (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:table: %s", p, err)
	}
	return err
}

func (p *TIncrement) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("row", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:row: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Row); err != nil {
		return fmt.Errorf("%T.row (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:row: %s", p, err)
	}
	return err
}

func (p *TIncrement) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("column", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:column: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Column); err != nil {
		return fmt.Errorf("%T.column (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:column: %s", p, err)
	}
	return err
}

func (p *TIncrement) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("ammount", thrift.I64, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:ammount: %s", p, err)
	}
	if err := oprot.WriteI64(int64(p.Ammount)); err != nil {
		return fmt.Errorf("%T.ammount (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:ammount: %s", p, err)
	}
	return err
}

func (p *TIncrement) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TIncrement(%+v)", *p)
}

type TColumn struct {
	ColumnName Text   `thrift:"columnName,1" json:"columnName"`
	Cell       *TCell `thrift:"cell,2" json:"cell"`
}

func NewTColumn() *TColumn {
	return &TColumn{}
}

func (p *TColumn) GetColumnName() Text {
	return p.ColumnName
}

var TColumn_Cell_DEFAULT *TCell

func (p *TColumn) GetCell() *TCell {
	if !p.IsSetCell() {
		return TColumn_Cell_DEFAULT
	}
	return p.Cell
}
func (p *TColumn) IsSetCell() bool {
	return p.Cell != nil
}

func (p *TColumn) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TColumn) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.ColumnName = temp
	}
	return nil
}

func (p *TColumn) ReadField2(iprot thrift.TProtocol) error {
	p.Cell = &TCell{}
	if err := p.Cell.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Cell, err)
	}
	return nil
}

func (p *TColumn) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TColumn"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TColumn) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("columnName", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:columnName: %s", p, err)
	}
	if err := oprot.WriteBinary(p.ColumnName); err != nil {
		return fmt.Errorf("%T.columnName (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:columnName: %s", p, err)
	}
	return err
}

func (p *TColumn) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("cell", thrift.STRUCT, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:cell: %s", p, err)
	}
	if err := p.Cell.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.Cell, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:cell: %s", p, err)
	}
	return err
}

func (p *TColumn) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TColumn(%+v)", *p)
}

type TRowResult_ struct {
	Row           Text              `thrift:"row,1" json:"row"`
	Columns       map[string]*TCell `thrift:"columns,2" json:"columns"`
	SortedColumns []*TColumn        `thrift:"sortedColumns,3" json:"sortedColumns"`
}

func NewTRowResult_() *TRowResult_ {
	return &TRowResult_{}
}

func (p *TRowResult_) GetRow() Text {
	return p.Row
}

var TRowResult__Columns_DEFAULT map[string]*TCell

func (p *TRowResult_) GetColumns() map[string]*TCell {
	return p.Columns
}

var TRowResult__SortedColumns_DEFAULT []*TColumn

func (p *TRowResult_) GetSortedColumns() []*TColumn {
	return p.SortedColumns
}
func (p *TRowResult_) IsSetColumns() bool {
	return p.Columns != nil
}

func (p *TRowResult_) IsSetSortedColumns() bool {
	return p.SortedColumns != nil
}

func (p *TRowResult_) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TRowResult_) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.Row = temp
	}
	return nil
}

func (p *TRowResult_) ReadField2(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return fmt.Errorf("error reading map begin: %s", err)
	}
	tMap := make(map[string]*TCell, size)
	p.Columns = tMap
	for i := 0; i < size; i++ {
		var _key1 string
		if v, err := iprot.ReadString(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := Text(v)
			_key1 = temp.String()
		}
		_val2 := &TCell{}
		if err := _val2.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _val2, err)
		}
		p.Columns[_key1] = _val2
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return fmt.Errorf("error reading map end: %s", err)
	}
	return nil
}

func (p *TRowResult_) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]*TColumn, 0, size)
	p.SortedColumns = tSlice
	for i := 0; i < size; i++ {
		_elem3 := &TColumn{}
		if err := _elem3.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem3, err)
		}
		p.SortedColumns = append(p.SortedColumns, _elem3)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TRowResult_) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TRowResult"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TRowResult_) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("row", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:row: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Row); err != nil {
		return fmt.Errorf("%T.row (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:row: %s", p, err)
	}
	return err
}

func (p *TRowResult_) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetColumns() {
		if err := oprot.WriteFieldBegin("columns", thrift.MAP, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:columns: %s", p, err)
		}
		if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRUCT, len(p.Columns)); err != nil {
			return fmt.Errorf("error writing map begin: %s", err)
		}
		for k, v := range p.Columns {
			if err := oprot.WriteString(string(k)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
			if err := v.Write(oprot); err != nil {
				return fmt.Errorf("%T error writing struct: %s", v, err)
			}
		}
		if err := oprot.WriteMapEnd(); err != nil {
			return fmt.Errorf("error writing map end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:columns: %s", p, err)
		}
	}
	return err
}

func (p *TRowResult_) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetSortedColumns() {
		if err := oprot.WriteFieldBegin("sortedColumns", thrift.LIST, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:sortedColumns: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.SortedColumns)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.SortedColumns {
			if err := v.Write(oprot); err != nil {
				return fmt.Errorf("%T error writing struct: %s", v, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:sortedColumns: %s", p, err)
		}
	}
	return err
}

func (p *TRowResult_) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TRowResult_(%+v)", *p)
}

type TScan struct {
	StartRow     Text     `thrift:"startRow,1" json:"startRow"`
	StopRow      Text     `thrift:"stopRow,2" json:"stopRow"`
	Timestamp    *int64   `thrift:"timestamp,3" json:"timestamp"`
	Columns      [][]byte `thrift:"columns,4" json:"columns"`
	Caching      *int32   `thrift:"caching,5" json:"caching"`
	FilterString Text     `thrift:"filterString,6" json:"filterString"`
	BatchSize    *int32   `thrift:"batchSize,7" json:"batchSize"`
	SortColumns  *bool    `thrift:"sortColumns,8" json:"sortColumns"`
	Reversed     *bool    `thrift:"reversed,9" json:"reversed"`
}

func NewTScan() *TScan {
	return &TScan{}
}

var TScan_StartRow_DEFAULT Text

func (p *TScan) GetStartRow() Text {
	return p.StartRow
}

var TScan_StopRow_DEFAULT Text

func (p *TScan) GetStopRow() Text {
	return p.StopRow
}

var TScan_Timestamp_DEFAULT int64

func (p *TScan) GetTimestamp() int64 {
	if !p.IsSetTimestamp() {
		return TScan_Timestamp_DEFAULT
	}
	return *p.Timestamp
}

var TScan_Columns_DEFAULT [][]byte

func (p *TScan) GetColumns() [][]byte {
	return p.Columns
}

var TScan_Caching_DEFAULT int32

func (p *TScan) GetCaching() int32 {
	if !p.IsSetCaching() {
		return TScan_Caching_DEFAULT
	}
	return *p.Caching
}

var TScan_FilterString_DEFAULT Text

func (p *TScan) GetFilterString() Text {
	return p.FilterString
}

var TScan_BatchSize_DEFAULT int32

func (p *TScan) GetBatchSize() int32 {
	if !p.IsSetBatchSize() {
		return TScan_BatchSize_DEFAULT
	}
	return *p.BatchSize
}

var TScan_SortColumns_DEFAULT bool

func (p *TScan) GetSortColumns() bool {
	if !p.IsSetSortColumns() {
		return TScan_SortColumns_DEFAULT
	}
	return *p.SortColumns
}

var TScan_Reversed_DEFAULT bool

func (p *TScan) GetReversed() bool {
	if !p.IsSetReversed() {
		return TScan_Reversed_DEFAULT
	}
	return *p.Reversed
}
func (p *TScan) IsSetStartRow() bool {
	return p.StartRow != nil
}

func (p *TScan) IsSetStopRow() bool {
	return p.StopRow != nil
}

func (p *TScan) IsSetTimestamp() bool {
	return p.Timestamp != nil
}

func (p *TScan) IsSetColumns() bool {
	return p.Columns != nil
}

func (p *TScan) IsSetCaching() bool {
	return p.Caching != nil
}

func (p *TScan) IsSetFilterString() bool {
	return p.FilterString != nil
}

func (p *TScan) IsSetBatchSize() bool {
	return p.BatchSize != nil
}

func (p *TScan) IsSetSortColumns() bool {
	return p.SortColumns != nil
}

func (p *TScan) IsSetReversed() bool {
	return p.Reversed != nil
}

func (p *TScan) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.ReadField5(iprot); err != nil {
				return err
			}
		case 6:
			if err := p.ReadField6(iprot); err != nil {
				return err
			}
		case 7:
			if err := p.ReadField7(iprot); err != nil {
				return err
			}
		case 8:
			if err := p.ReadField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.ReadField9(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TScan) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.StartRow = temp
	}
	return nil
}

func (p *TScan) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := Text(v)
		p.StopRow = temp
	}
	return nil
}

func (p *TScan) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Timestamp = &v
	}
	return nil
}

func (p *TScan) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([][]byte, 0, size)
	p.Columns = tSlice
	for i := 0; i < size; i++ {
		var _elem4 Text
		if v, err := iprot.ReadBinary(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := Text(v)
			_elem4 = temp
		}
		p.Columns = append(p.Columns, _elem4)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TScan) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 5: %s", err)
	} else {
		p.Caching = &v
	}
	return nil
}

func (p *TScan) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 6: %s", err)
	} else {
		temp := Text(v)
		p.FilterString = temp
	}
	return nil
}

func (p *TScan) ReadField7(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 7: %s", err)
	} else {
		p.BatchSize = &v
	}
	return nil
}

func (p *TScan) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 8: %s", err)
	} else {
		p.SortColumns = &v
	}
	return nil
}

func (p *TScan) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return fmt.Errorf("error reading field 9: %s", err)
	} else {
		p.Reversed = &v
	}
	return nil
}

func (p *TScan) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TScan"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := p.writeField6(oprot); err != nil {
		return err
	}
	if err := p.writeField7(oprot); err != nil {
		return err
	}
	if err := p.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TScan) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetStartRow() {
		if err := oprot.WriteFieldBegin("startRow", thrift.STRING, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:startRow: %s", p, err)
		}
		if err := oprot.WriteBinary(p.StartRow); err != nil {
			return fmt.Errorf("%T.startRow (1) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:startRow: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetStopRow() {
		if err := oprot.WriteFieldBegin("stopRow", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:stopRow: %s", p, err)
		}
		if err := oprot.WriteBinary(p.StopRow); err != nil {
			return fmt.Errorf("%T.stopRow (2) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:stopRow: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetTimestamp() {
		if err := oprot.WriteFieldBegin("timestamp", thrift.I64, 3); err != nil {
			return fmt.Errorf("%T write field begin error 3:timestamp: %s", p, err)
		}
		if err := oprot.WriteI64(int64(*p.Timestamp)); err != nil {
			return fmt.Errorf("%T.timestamp (3) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 3:timestamp: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetColumns() {
		if err := oprot.WriteFieldBegin("columns", thrift.LIST, 4); err != nil {
			return fmt.Errorf("%T write field begin error 4:columns: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.Columns)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.Columns {
			if err := oprot.WriteBinary(v); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 4:columns: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetCaching() {
		if err := oprot.WriteFieldBegin("caching", thrift.I32, 5); err != nil {
			return fmt.Errorf("%T write field begin error 5:caching: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.Caching)); err != nil {
			return fmt.Errorf("%T.caching (5) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 5:caching: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetFilterString() {
		if err := oprot.WriteFieldBegin("filterString", thrift.STRING, 6); err != nil {
			return fmt.Errorf("%T write field begin error 6:filterString: %s", p, err)
		}
		if err := oprot.WriteBinary(p.FilterString); err != nil {
			return fmt.Errorf("%T.filterString (6) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 6:filterString: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField7(oprot thrift.TProtocol) (err error) {
	if p.IsSetBatchSize() {
		if err := oprot.WriteFieldBegin("batchSize", thrift.I32, 7); err != nil {
			return fmt.Errorf("%T write field begin error 7:batchSize: %s", p, err)
		}
		if err := oprot.WriteI32(int32(*p.BatchSize)); err != nil {
			return fmt.Errorf("%T.batchSize (7) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 7:batchSize: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField8(oprot thrift.TProtocol) (err error) {
	if p.IsSetSortColumns() {
		if err := oprot.WriteFieldBegin("sortColumns", thrift.BOOL, 8); err != nil {
			return fmt.Errorf("%T write field begin error 8:sortColumns: %s", p, err)
		}
		if err := oprot.WriteBool(bool(*p.SortColumns)); err != nil {
			return fmt.Errorf("%T.sortColumns (8) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 8:sortColumns: %s", p, err)
		}
	}
	return err
}

func (p *TScan) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetReversed() {
		if err := oprot.WriteFieldBegin("reversed", thrift.BOOL, 9); err != nil {
			return fmt.Errorf("%T write field begin error 9:reversed: %s", p, err)
		}
		if err := oprot.WriteBool(bool(*p.Reversed)); err != nil {
			return fmt.Errorf("%T.reversed (9) field write error: %s", p, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 9:reversed: %s", p, err)
		}
	}
	return err
}

func (p *TScan) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TScan(%+v)", *p)
}

type TAppend struct {
	Table   Text     `thrift:"table,1" json:"table"`
	Row     Text     `thrift:"row,2" json:"row"`
	Columns [][]byte `thrift:"columns,3" json:"columns"`
	Values  [][]byte `thrift:"values,4" json:"values"`
}

func NewTAppend() *TAppend {
	return &TAppend{}
}

func (p *TAppend) GetTable() Text {
	return p.Table
}

func (p *TAppend) GetRow() Text {
	return p.Row
}

func (p *TAppend) GetColumns() [][]byte {
	return p.Columns
}

func (p *TAppend) GetValues() [][]byte {
	return p.Values
}
func (p *TAppend) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *TAppend) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		temp := Text(v)
		p.Table = temp
	}
	return nil
}

func (p *TAppend) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		temp := Text(v)
		p.Row = temp
	}
	return nil
}

func (p *TAppend) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([][]byte, 0, size)
	p.Columns = tSlice
	for i := 0; i < size; i++ {
		var _elem5 Text
		if v, err := iprot.ReadBinary(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := Text(v)
			_elem5 = temp
		}
		p.Columns = append(p.Columns, _elem5)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TAppend) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([][]byte, 0, size)
	p.Values = tSlice
	for i := 0; i < size; i++ {
		var _elem6 Text
		if v, err := iprot.ReadBinary(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			temp := Text(v)
			_elem6 = temp
		}
		p.Values = append(p.Values, _elem6)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *TAppend) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("TAppend"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *TAppend) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("table", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:table: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Table); err != nil {
		return fmt.Errorf("%T.table (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:table: %s", p, err)
	}
	return err
}

func (p *TAppend) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("row", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:row: %s", p, err)
	}
	if err := oprot.WriteBinary(p.Row); err != nil {
		return fmt.Errorf("%T.row (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:row: %s", p, err)
	}
	return err
}

func (p *TAppend) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("columns", thrift.LIST, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:columns: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.Columns)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Columns {
		if err := oprot.WriteBinary(v); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:columns: %s", p, err)
	}
	return err
}

func (p *TAppend) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("values", thrift.LIST, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:values: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.Values)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.Values {
		if err := oprot.WriteBinary(v); err != nil {
			return fmt.Errorf("%T. (0) field write error: %s", p, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:values: %s", p, err)
	}
	return err
}

func (p *TAppend) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("TAppend(%+v)", *p)
}

type IOError struct {
	Message string `thrift:"message,1" json:"message"`
}

func NewIOError() *IOError {
	return &IOError{}
}

func (p *IOError) GetMessage() string {
	return p.Message
}
func (p *IOError) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *IOError) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *IOError) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("IOError"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *IOError) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:message: %s", p, err)
	}
	return err
}

func (p *IOError) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("IOError(%+v)", *p)
}

func (p *IOError) Error() string {
	return p.String()
}

type IllegalArgument struct {
	Message string `thrift:"message,1" json:"message"`
}

func NewIllegalArgument() *IllegalArgument {
	return &IllegalArgument{}
}

func (p *IllegalArgument) GetMessage() string {
	return p.Message
}
func (p *IllegalArgument) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *IllegalArgument) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *IllegalArgument) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("IllegalArgument"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *IllegalArgument) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:message: %s", p, err)
	}
	return err
}

func (p *IllegalArgument) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("IllegalArgument(%+v)", *p)
}

func (p *IllegalArgument) Error() string {
	return p.String()
}

type AlreadyExists struct {
	Message string `thrift:"message,1" json:"message"`
}

func NewAlreadyExists() *AlreadyExists {
	return &AlreadyExists{}
}

func (p *AlreadyExists) GetMessage() string {
	return p.Message
}
func (p *AlreadyExists) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *AlreadyExists) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *AlreadyExists) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("AlreadyExists"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *AlreadyExists) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:message: %s", p, err)
	}
	return err
}

func (p *AlreadyExists) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("AlreadyExists(%+v)", *p)
}

func (p *AlreadyExists) Error() string {
	return p.String()
}