github.com/pingcap/tiflow@v0.0.0-20240520035814-5bf52d54e205/cdc/model/sink_gen.go

package model

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *Column) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "name":
			z.Name, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "type":
			z.Type, err = dc.ReadByte()
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}
		case "charset":
			z.Charset, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Charset")
				return
			}
		case "collation":
			z.Collation, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Collation")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *Column) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "name"
	err = en.Append(0x84, 0xa4, 0x6e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "type"
	err = en.Append(0xa4, 0x74, 0x79, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteByte(z.Type)
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	// write "charset"
	err = en.Append(0xa7, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Charset)
	if err != nil {
		err = msgp.WrapError(err, "Charset")
		return
	}
	// write "collation"
	err = en.Append(0xa9, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteString(z.Collation)
	if err != nil {
		err = msgp.WrapError(err, "Collation")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Column) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "name"
	o = append(o, 0x84, 0xa4, 0x6e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "type"
	o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
	o = msgp.AppendByte(o, z.Type)
	// string "charset"
	o = append(o, 0xa7, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74)
	o = msgp.AppendString(o, z.Charset)
	// string "collation"
	o = append(o, 0xa9, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.Collation)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Column) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "name":
			z.Name, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "type":
			z.Type, bts, err = msgp.ReadByteBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}
		case "charset":
			z.Charset, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Charset")
				return
			}
		case "collation":
			z.Collation, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Collation")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Column) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 5 + msgp.ByteSize + 8 + msgp.StringPrefixSize + len(z.Charset) + 10 + msgp.StringPrefixSize + len(z.Collation)
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ColumnData) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "column_id":
			z.ColumnID, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ColumnID")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z ColumnData) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "column_id"
	err = en.Append(0x81, 0xa9, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.ColumnID)
	if err != nil {
		err = msgp.WrapError(err, "ColumnID")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z ColumnData) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "column_id"
	o = append(o, 0x81, 0xa9, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x69, 0x64)
	o = msgp.AppendInt64(o, z.ColumnID)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ColumnData) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "column_id":
			z.ColumnID, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ColumnID")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z ColumnData) Msgsize() (s int) {
	s = 1 + 10 + msgp.Int64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *DDLEvent) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "start-ts":
			z.StartTs, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "StartTs")
				return
			}
		case "commit-ts":
			z.CommitTs, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "CommitTs")
				return
			}
		case "query":
			z.Query, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Query")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z DDLEvent) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "start-ts"
	err = en.Append(0x83, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.StartTs)
	if err != nil {
		err = msgp.WrapError(err, "StartTs")
		return
	}
	// write "commit-ts"
	err = en.Append(0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.CommitTs)
	if err != nil {
		err = msgp.WrapError(err, "CommitTs")
		return
	}
	// write "query"
	err = en.Append(0xa5, 0x71, 0x75, 0x65, 0x72, 0x79)
	if err != nil {
		return
	}
	err = en.WriteString(z.Query)
	if err != nil {
		err = msgp.WrapError(err, "Query")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z DDLEvent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "start-ts"
	o = append(o, 0x83, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
	o = msgp.AppendUint64(o, z.StartTs)
	// string "commit-ts"
	o = append(o, 0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
	o = msgp.AppendUint64(o, z.CommitTs)
	// string "query"
	o = append(o, 0xa5, 0x71, 0x75, 0x65, 0x72, 0x79)
	o = msgp.AppendString(o, z.Query)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DDLEvent) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "start-ts":
			z.StartTs, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "StartTs")
				return
			}
		case "commit-ts":
			z.CommitTs, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CommitTs")
				return
			}
		case "query":
			z.Query, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Query")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z DDLEvent) Msgsize() (s int) {
	s = 1 + 9 + msgp.Uint64Size + 10 + msgp.Uint64Size + 6 + msgp.StringPrefixSize + len(z.Query)
	return
}

// DecodeMsg implements msgp.Decodable
func (z *MessageType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 int
		zb0001, err = dc.ReadInt()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = MessageType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z MessageType) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt(int(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z MessageType) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt(o, int(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageType) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int
		zb0001, bts, err = msgp.ReadIntBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = MessageType(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z MessageType) Msgsize() (s int) {
	s = msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RedoColumn) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "column":
			z.Value, err = dc.ReadIntf()
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "value-is-empty-bytes":
			z.ValueIsEmptyBytes, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "ValueIsEmptyBytes")
				return
			}
		case "flag":
			z.Flag, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Flag")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z RedoColumn) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "column"
	err = en.Append(0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteIntf(z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// write "value-is-empty-bytes"
	err = en.Append(0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
	if err != nil {
		return
	}
	err = en.WriteBool(z.ValueIsEmptyBytes)
	if err != nil {
		err = msgp.WrapError(err, "ValueIsEmptyBytes")
		return
	}
	// write "flag"
	err = en.Append(0xa4, 0x66, 0x6c, 0x61, 0x67)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.Flag)
	if err != nil {
		err = msgp.WrapError(err, "Flag")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RedoColumn) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "column"
	o = append(o, 0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
	o, err = msgp.AppendIntf(o, z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// string "value-is-empty-bytes"
	o = append(o, 0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
	o = msgp.AppendBool(o, z.ValueIsEmptyBytes)
	// string "flag"
	o = append(o, 0xa4, 0x66, 0x6c, 0x61, 0x67)
	o = msgp.AppendUint64(o, z.Flag)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RedoColumn) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "column":
			z.Value, bts, err = msgp.ReadIntfBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "value-is-empty-bytes":
			z.ValueIsEmptyBytes, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ValueIsEmptyBytes")
				return
			}
		case "flag":
			z.Flag, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Flag")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z RedoColumn) Msgsize() (s int) {
	s = 1 + 7 + msgp.GuessSize(z.Value) + 21 + msgp.BoolSize + 5 + msgp.Uint64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RedoDDLEvent) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ddl":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "DDL")
					return
				}
				z.DDL = nil
			} else {
				if z.DDL == nil {
					z.DDL = new(DDLEvent)
				}
				var zb0002 uint32
				zb0002, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "DDL")
					return
				}
				for zb0002 > 0 {
					zb0002--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						err = msgp.WrapError(err, "DDL")
						return
					}
					switch msgp.UnsafeString(field) {
					case "start-ts":
						z.DDL.StartTs, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "DDL", "StartTs")
							return
						}
					case "commit-ts":
						z.DDL.CommitTs, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "DDL", "CommitTs")
							return
						}
					case "query":
						z.DDL.Query, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "DDL", "Query")
							return
						}
					default:
						err = dc.Skip()
						if err != nil {
							err = msgp.WrapError(err, "DDL")
							return
						}
					}
				}
			}
		case "type":
			z.Type, err = dc.ReadByte()
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}
		case "table-name":
			err = z.TableName.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "TableName")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RedoDDLEvent) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "ddl"
	err = en.Append(0x83, 0xa3, 0x64, 0x64, 0x6c)
	if err != nil {
		return
	}
	if z.DDL == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		// map header, size 3
		// write "start-ts"
		err = en.Append(0x83, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.DDL.StartTs)
		if err != nil {
			err = msgp.WrapError(err, "DDL", "StartTs")
			return
		}
		// write "commit-ts"
		err = en.Append(0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.DDL.CommitTs)
		if err != nil {
			err = msgp.WrapError(err, "DDL", "CommitTs")
			return
		}
		// write "query"
		err = en.Append(0xa5, 0x71, 0x75, 0x65, 0x72, 0x79)
		if err != nil {
			return
		}
		err = en.WriteString(z.DDL.Query)
		if err != nil {
			err = msgp.WrapError(err, "DDL", "Query")
			return
		}
	}
	// write "type"
	err = en.Append(0xa4, 0x74, 0x79, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteByte(z.Type)
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	// write "table-name"
	err = en.Append(0xaa, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = z.TableName.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "TableName")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RedoDDLEvent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "ddl"
	o = append(o, 0x83, 0xa3, 0x64, 0x64, 0x6c)
	if z.DDL == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 3
		// string "start-ts"
		o = append(o, 0x83, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
		o = msgp.AppendUint64(o, z.DDL.StartTs)
		// string "commit-ts"
		o = append(o, 0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
		o = msgp.AppendUint64(o, z.DDL.CommitTs)
		// string "query"
		o = append(o, 0xa5, 0x71, 0x75, 0x65, 0x72, 0x79)
		o = msgp.AppendString(o, z.DDL.Query)
	}
	// string "type"
	o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
	o = msgp.AppendByte(o, z.Type)
	// string "table-name"
	o = append(o, 0xaa, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	o, err = z.TableName.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "TableName")
		return
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RedoDDLEvent) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ddl":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.DDL = nil
			} else {
				if z.DDL == nil {
					z.DDL = new(DDLEvent)
				}
				var zb0002 uint32
				zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "DDL")
					return
				}
				for zb0002 > 0 {
					zb0002--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "DDL")
						return
					}
					switch msgp.UnsafeString(field) {
					case "start-ts":
						z.DDL.StartTs, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "DDL", "StartTs")
							return
						}
					case "commit-ts":
						z.DDL.CommitTs, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "DDL", "CommitTs")
							return
						}
					case "query":
						z.DDL.Query, bts, err = msgp.ReadStringBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "DDL", "Query")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "DDL")
							return
						}
					}
				}
			}
		case "type":
			z.Type, bts, err = msgp.ReadByteBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}
		case "table-name":
			bts, err = z.TableName.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "TableName")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *RedoDDLEvent) Msgsize() (s int) {
	s = 1 + 4
	if z.DDL == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 9 + msgp.Uint64Size + 10 + msgp.Uint64Size + 6 + msgp.StringPrefixSize + len(z.DDL.Query)
	}
	s += 5 + msgp.ByteSize + 11 + z.TableName.Msgsize()
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RedoLog) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "row":
			err = z.RedoRow.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "RedoRow")
				return
			}
		case "ddl":
			err = z.RedoDDL.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "RedoDDL")
				return
			}
		case "type":
			{
				var zb0002 int
				zb0002, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "Type")
					return
				}
				z.Type = RedoLogType(zb0002)
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RedoLog) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "row"
	err = en.Append(0x83, 0xa3, 0x72, 0x6f, 0x77)
	if err != nil {
		return
	}
	err = z.RedoRow.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "RedoRow")
		return
	}
	// write "ddl"
	err = en.Append(0xa3, 0x64, 0x64, 0x6c)
	if err != nil {
		return
	}
	err = z.RedoDDL.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "RedoDDL")
		return
	}
	// write "type"
	err = en.Append(0xa4, 0x74, 0x79, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt(int(z.Type))
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RedoLog) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "row"
	o = append(o, 0x83, 0xa3, 0x72, 0x6f, 0x77)
	o, err = z.RedoRow.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "RedoRow")
		return
	}
	// string "ddl"
	o = append(o, 0xa3, 0x64, 0x64, 0x6c)
	o, err = z.RedoDDL.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "RedoDDL")
		return
	}
	// string "type"
	o = append(o, 0xa4, 0x74, 0x79, 0x70, 0x65)
	o = msgp.AppendInt(o, int(z.Type))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RedoLog) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "row":
			bts, err = z.RedoRow.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "RedoRow")
				return
			}
		case "ddl":
			bts, err = z.RedoDDL.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "RedoDDL")
				return
			}
		case "type":
			{
				var zb0002 int
				zb0002, bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Type")
					return
				}
				z.Type = RedoLogType(zb0002)
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *RedoLog) Msgsize() (s int) {
	s = 1 + 4 + z.RedoRow.Msgsize() + 4 + z.RedoDDL.Msgsize() + 5 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RedoLogType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 int
		zb0001, err = dc.ReadInt()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = RedoLogType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z RedoLogType) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt(int(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RedoLogType) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt(o, int(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RedoLogType) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int
		zb0001, bts, err = msgp.ReadIntBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = RedoLogType(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z RedoLogType) Msgsize() (s int) {
	s = msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RedoRowChangedEvent) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "row":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Row")
					return
				}
				z.Row = nil
			} else {
				if z.Row == nil {
					z.Row = new(RowChangedEventInRedoLog)
				}
				err = z.Row.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Row")
					return
				}
			}
		case "columns":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0002) {
				z.Columns = (z.Columns)[:zb0002]
			} else {
				z.Columns = make([]RedoColumn, zb0002)
			}
			for za0001 := range z.Columns {
				var zb0003 uint32
				zb0003, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "Columns", za0001)
					return
				}
				for zb0003 > 0 {
					zb0003--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0001)
						return
					}
					switch msgp.UnsafeString(field) {
					case "column":
						z.Columns[za0001].Value, err = dc.ReadIntf()
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "Value")
							return
						}
					case "value-is-empty-bytes":
						z.Columns[za0001].ValueIsEmptyBytes, err = dc.ReadBool()
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "ValueIsEmptyBytes")
							return
						}
					case "flag":
						z.Columns[za0001].Flag, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "Flag")
							return
						}
					default:
						err = dc.Skip()
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001)
							return
						}
					}
				}
			}
		case "pre-columns":
			var zb0004 uint32
			zb0004, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0004) {
				z.PreColumns = (z.PreColumns)[:zb0004]
			} else {
				z.PreColumns = make([]RedoColumn, zb0004)
			}
			for za0002 := range z.PreColumns {
				var zb0005 uint32
				zb0005, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "PreColumns", za0002)
					return
				}
				for zb0005 > 0 {
					zb0005--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0002)
						return
					}
					switch msgp.UnsafeString(field) {
					case "column":
						z.PreColumns[za0002].Value, err = dc.ReadIntf()
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "Value")
							return
						}
					case "value-is-empty-bytes":
						z.PreColumns[za0002].ValueIsEmptyBytes, err = dc.ReadBool()
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "ValueIsEmptyBytes")
							return
						}
					case "flag":
						z.PreColumns[za0002].Flag, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "Flag")
							return
						}
					default:
						err = dc.Skip()
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002)
							return
						}
					}
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RedoRowChangedEvent) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "row"
	err = en.Append(0x83, 0xa3, 0x72, 0x6f, 0x77)
	if err != nil {
		return
	}
	if z.Row == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Row.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Row")
			return
		}
	}
	// write "columns"
	err = en.Append(0xa7, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Columns)))
	if err != nil {
		err = msgp.WrapError(err, "Columns")
		return
	}
	for za0001 := range z.Columns {
		// map header, size 3
		// write "column"
		err = en.Append(0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
		if err != nil {
			return
		}
		err = en.WriteIntf(z.Columns[za0001].Value)
		if err != nil {
			err = msgp.WrapError(err, "Columns", za0001, "Value")
			return
		}
		// write "value-is-empty-bytes"
		err = en.Append(0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
		if err != nil {
			return
		}
		err = en.WriteBool(z.Columns[za0001].ValueIsEmptyBytes)
		if err != nil {
			err = msgp.WrapError(err, "Columns", za0001, "ValueIsEmptyBytes")
			return
		}
		// write "flag"
		err = en.Append(0xa4, 0x66, 0x6c, 0x61, 0x67)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.Columns[za0001].Flag)
		if err != nil {
			err = msgp.WrapError(err, "Columns", za0001, "Flag")
			return
		}
	}
	// write "pre-columns"
	err = en.Append(0xab, 0x70, 0x72, 0x65, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.PreColumns)))
	if err != nil {
		err = msgp.WrapError(err, "PreColumns")
		return
	}
	for za0002 := range z.PreColumns {
		// map header, size 3
		// write "column"
		err = en.Append(0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
		if err != nil {
			return
		}
		err = en.WriteIntf(z.PreColumns[za0002].Value)
		if err != nil {
			err = msgp.WrapError(err, "PreColumns", za0002, "Value")
			return
		}
		// write "value-is-empty-bytes"
		err = en.Append(0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
		if err != nil {
			return
		}
		err = en.WriteBool(z.PreColumns[za0002].ValueIsEmptyBytes)
		if err != nil {
			err = msgp.WrapError(err, "PreColumns", za0002, "ValueIsEmptyBytes")
			return
		}
		// write "flag"
		err = en.Append(0xa4, 0x66, 0x6c, 0x61, 0x67)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.PreColumns[za0002].Flag)
		if err != nil {
			err = msgp.WrapError(err, "PreColumns", za0002, "Flag")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RedoRowChangedEvent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "row"
	o = append(o, 0x83, 0xa3, 0x72, 0x6f, 0x77)
	if z.Row == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Row.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Row")
			return
		}
	}
	// string "columns"
	o = append(o, 0xa7, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Columns)))
	for za0001 := range z.Columns {
		// map header, size 3
		// string "column"
		o = append(o, 0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
		o, err = msgp.AppendIntf(o, z.Columns[za0001].Value)
		if err != nil {
			err = msgp.WrapError(err, "Columns", za0001, "Value")
			return
		}
		// string "value-is-empty-bytes"
		o = append(o, 0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
		o = msgp.AppendBool(o, z.Columns[za0001].ValueIsEmptyBytes)
		// string "flag"
		o = append(o, 0xa4, 0x66, 0x6c, 0x61, 0x67)
		o = msgp.AppendUint64(o, z.Columns[za0001].Flag)
	}
	// string "pre-columns"
	o = append(o, 0xab, 0x70, 0x72, 0x65, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.PreColumns)))
	for za0002 := range z.PreColumns {
		// map header, size 3
		// string "column"
		o = append(o, 0x83, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
		o, err = msgp.AppendIntf(o, z.PreColumns[za0002].Value)
		if err != nil {
			err = msgp.WrapError(err, "PreColumns", za0002, "Value")
			return
		}
		// string "value-is-empty-bytes"
		o = append(o, 0xb4, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2d, 0x69, 0x73, 0x2d, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2d, 0x62, 0x79, 0x74, 0x65, 0x73)
		o = msgp.AppendBool(o, z.PreColumns[za0002].ValueIsEmptyBytes)
		// string "flag"
		o = append(o, 0xa4, 0x66, 0x6c, 0x61, 0x67)
		o = msgp.AppendUint64(o, z.PreColumns[za0002].Flag)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RedoRowChangedEvent) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "row":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Row = nil
			} else {
				if z.Row == nil {
					z.Row = new(RowChangedEventInRedoLog)
				}
				bts, err = z.Row.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Row")
					return
				}
			}
		case "columns":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0002) {
				z.Columns = (z.Columns)[:zb0002]
			} else {
				z.Columns = make([]RedoColumn, zb0002)
			}
			for za0001 := range z.Columns {
				var zb0003 uint32
				zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Columns", za0001)
					return
				}
				for zb0003 > 0 {
					zb0003--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0001)
						return
					}
					switch msgp.UnsafeString(field) {
					case "column":
						z.Columns[za0001].Value, bts, err = msgp.ReadIntfBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "Value")
							return
						}
					case "value-is-empty-bytes":
						z.Columns[za0001].ValueIsEmptyBytes, bts, err = msgp.ReadBoolBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "ValueIsEmptyBytes")
							return
						}
					case "flag":
						z.Columns[za0001].Flag, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001, "Flag")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0001)
							return
						}
					}
				}
			}
		case "pre-columns":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0004) {
				z.PreColumns = (z.PreColumns)[:zb0004]
			} else {
				z.PreColumns = make([]RedoColumn, zb0004)
			}
			for za0002 := range z.PreColumns {
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "PreColumns", za0002)
					return
				}
				for zb0005 > 0 {
					zb0005--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0002)
						return
					}
					switch msgp.UnsafeString(field) {
					case "column":
						z.PreColumns[za0002].Value, bts, err = msgp.ReadIntfBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "Value")
							return
						}
					case "value-is-empty-bytes":
						z.PreColumns[za0002].ValueIsEmptyBytes, bts, err = msgp.ReadBoolBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "ValueIsEmptyBytes")
							return
						}
					case "flag":
						z.PreColumns[za0002].Flag, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002, "Flag")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0002)
							return
						}
					}
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *RedoRowChangedEvent) Msgsize() (s int) {
	s = 1 + 4
	if z.Row == nil {
		s += msgp.NilSize
	} else {
		s += z.Row.Msgsize()
	}
	s += 8 + msgp.ArrayHeaderSize
	for za0001 := range z.Columns {
		s += 1 + 7 + msgp.GuessSize(z.Columns[za0001].Value) + 21 + msgp.BoolSize + 5 + msgp.Uint64Size
	}
	s += 12 + msgp.ArrayHeaderSize
	for za0002 := range z.PreColumns {
		s += 1 + 7 + msgp.GuessSize(z.PreColumns[za0002].Value) + 21 + msgp.BoolSize + 5 + msgp.Uint64Size
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RowChangedEventInRedoLog) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "start-ts":
			z.StartTs, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "StartTs")
				return
			}
		case "commit-ts":
			z.CommitTs, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "CommitTs")
				return
			}
		case "table":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Table")
					return
				}
				z.Table = nil
			} else {
				if z.Table == nil {
					z.Table = new(TableName)
				}
				err = z.Table.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Table")
					return
				}
			}
		case "columns":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0002) {
				z.Columns = (z.Columns)[:zb0002]
			} else {
				z.Columns = make([]*Column, zb0002)
			}
			for za0001 := range z.Columns {
				if dc.IsNil() {
					err = dc.ReadNil()
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0001)
						return
					}
					z.Columns[za0001] = nil
				} else {
					if z.Columns[za0001] == nil {
						z.Columns[za0001] = new(Column)
					}
					err = z.Columns[za0001].DecodeMsg(dc)
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0001)
						return
					}
				}
			}
		case "pre-columns":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0003) {
				z.PreColumns = (z.PreColumns)[:zb0003]
			} else {
				z.PreColumns = make([]*Column, zb0003)
			}
			for za0002 := range z.PreColumns {
				if dc.IsNil() {
					err = dc.ReadNil()
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0002)
						return
					}
					z.PreColumns[za0002] = nil
				} else {
					if z.PreColumns[za0002] == nil {
						z.PreColumns[za0002] = new(Column)
					}
					err = z.PreColumns[za0002].DecodeMsg(dc)
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0002)
						return
					}
				}
			}
		case "index-columns":
			var zb0004 uint32
			zb0004, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns")
				return
			}
			if cap(z.IndexColumns) >= int(zb0004) {
				z.IndexColumns = (z.IndexColumns)[:zb0004]
			} else {
				z.IndexColumns = make([][]int, zb0004)
			}
			for za0003 := range z.IndexColumns {
				var zb0005 uint32
				zb0005, err = dc.ReadArrayHeader()
				if err != nil {
					err = msgp.WrapError(err, "IndexColumns", za0003)
					return
				}
				if cap(z.IndexColumns[za0003]) >= int(zb0005) {
					z.IndexColumns[za0003] = (z.IndexColumns[za0003])[:zb0005]
				} else {
					z.IndexColumns[za0003] = make([]int, zb0005)
				}
				for za0004 := range z.IndexColumns[za0003] {
					z.IndexColumns[za0003][za0004], err = dc.ReadInt()
					if err != nil {
						err = msgp.WrapError(err, "IndexColumns", za0003, za0004)
						return
					}
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RowChangedEventInRedoLog) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 6
	// write "start-ts"
	err = en.Append(0x86, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.StartTs)
	if err != nil {
		err = msgp.WrapError(err, "StartTs")
		return
	}
	// write "commit-ts"
	err = en.Append(0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.CommitTs)
	if err != nil {
		err = msgp.WrapError(err, "CommitTs")
		return
	}
	// write "table"
	err = en.Append(0xa5, 0x74, 0x61, 0x62, 0x6c, 0x65)
	if err != nil {
		return
	}
	if z.Table == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Table.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Table")
			return
		}
	}
	// write "columns"
	err = en.Append(0xa7, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Columns)))
	if err != nil {
		err = msgp.WrapError(err, "Columns")
		return
	}
	for za0001 := range z.Columns {
		if z.Columns[za0001] == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			err = z.Columns[za0001].EncodeMsg(en)
			if err != nil {
				err = msgp.WrapError(err, "Columns", za0001)
				return
			}
		}
	}
	// write "pre-columns"
	err = en.Append(0xab, 0x70, 0x72, 0x65, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.PreColumns)))
	if err != nil {
		err = msgp.WrapError(err, "PreColumns")
		return
	}
	for za0002 := range z.PreColumns {
		if z.PreColumns[za0002] == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			err = z.PreColumns[za0002].EncodeMsg(en)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns", za0002)
				return
			}
		}
	}
	// write "index-columns"
	err = en.Append(0xad, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.IndexColumns)))
	if err != nil {
		err = msgp.WrapError(err, "IndexColumns")
		return
	}
	for za0003 := range z.IndexColumns {
		err = en.WriteArrayHeader(uint32(len(z.IndexColumns[za0003])))
		if err != nil {
			err = msgp.WrapError(err, "IndexColumns", za0003)
			return
		}
		for za0004 := range z.IndexColumns[za0003] {
			err = en.WriteInt(z.IndexColumns[za0003][za0004])
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns", za0003, za0004)
				return
			}
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RowChangedEventInRedoLog) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 6
	// string "start-ts"
	o = append(o, 0x86, 0xa8, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x73)
	o = msgp.AppendUint64(o, z.StartTs)
	// string "commit-ts"
	o = append(o, 0xa9, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x2d, 0x74, 0x73)
	o = msgp.AppendUint64(o, z.CommitTs)
	// string "table"
	o = append(o, 0xa5, 0x74, 0x61, 0x62, 0x6c, 0x65)
	if z.Table == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Table.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Table")
			return
		}
	}
	// string "columns"
	o = append(o, 0xa7, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Columns)))
	for za0001 := range z.Columns {
		if z.Columns[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.Columns[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Columns", za0001)
				return
			}
		}
	}
	// string "pre-columns"
	o = append(o, 0xab, 0x70, 0x72, 0x65, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.PreColumns)))
	for za0002 := range z.PreColumns {
		if z.PreColumns[za0002] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.PreColumns[za0002].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns", za0002)
				return
			}
		}
	}
	// string "index-columns"
	o = append(o, 0xad, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.IndexColumns)))
	for za0003 := range z.IndexColumns {
		o = msgp.AppendArrayHeader(o, uint32(len(z.IndexColumns[za0003])))
		for za0004 := range z.IndexColumns[za0003] {
			o = msgp.AppendInt(o, z.IndexColumns[za0003][za0004])
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RowChangedEventInRedoLog) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "start-ts":
			z.StartTs, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "StartTs")
				return
			}
		case "commit-ts":
			z.CommitTs, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CommitTs")
				return
			}
		case "table":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Table = nil
			} else {
				if z.Table == nil {
					z.Table = new(TableName)
				}
				bts, err = z.Table.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Table")
					return
				}
			}
		case "columns":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0002) {
				z.Columns = (z.Columns)[:zb0002]
			} else {
				z.Columns = make([]*Column, zb0002)
			}
			for za0001 := range z.Columns {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Columns[za0001] = nil
				} else {
					if z.Columns[za0001] == nil {
						z.Columns[za0001] = new(Column)
					}
					bts, err = z.Columns[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0001)
						return
					}
				}
			}
		case "pre-columns":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0003) {
				z.PreColumns = (z.PreColumns)[:zb0003]
			} else {
				z.PreColumns = make([]*Column, zb0003)
			}
			for za0002 := range z.PreColumns {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.PreColumns[za0002] = nil
				} else {
					if z.PreColumns[za0002] == nil {
						z.PreColumns[za0002] = new(Column)
					}
					bts, err = z.PreColumns[za0002].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0002)
						return
					}
				}
			}
		case "index-columns":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns")
				return
			}
			if cap(z.IndexColumns) >= int(zb0004) {
				z.IndexColumns = (z.IndexColumns)[:zb0004]
			} else {
				z.IndexColumns = make([][]int, zb0004)
			}
			for za0003 := range z.IndexColumns {
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "IndexColumns", za0003)
					return
				}
				if cap(z.IndexColumns[za0003]) >= int(zb0005) {
					z.IndexColumns[za0003] = (z.IndexColumns[za0003])[:zb0005]
				} else {
					z.IndexColumns[za0003] = make([]int, zb0005)
				}
				for za0004 := range z.IndexColumns[za0003] {
					z.IndexColumns[za0003][za0004], bts, err = msgp.ReadIntBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "IndexColumns", za0003, za0004)
						return
					}
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *RowChangedEventInRedoLog) Msgsize() (s int) {
	s = 1 + 9 + msgp.Uint64Size + 10 + msgp.Uint64Size + 6
	if z.Table == nil {
		s += msgp.NilSize
	} else {
		s += z.Table.Msgsize()
	}
	s += 8 + msgp.ArrayHeaderSize
	for za0001 := range z.Columns {
		if z.Columns[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.Columns[za0001].Msgsize()
		}
	}
	s += 12 + msgp.ArrayHeaderSize
	for za0002 := range z.PreColumns {
		if z.PreColumns[za0002] == nil {
			s += msgp.NilSize
		} else {
			s += z.PreColumns[za0002].Msgsize()
		}
	}
	s += 14 + msgp.ArrayHeaderSize
	for za0003 := range z.IndexColumns {
		s += msgp.ArrayHeaderSize + (len(z.IndexColumns[za0003]) * (msgp.IntSize))
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *TableName) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "db-name":
			z.Schema, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Schema")
				return
			}
		case "tbl-name":
			z.Table, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Table")
				return
			}
		case "tbl-id":
			z.TableID, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "TableID")
				return
			}
		case "is-partition":
			z.IsPartition, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "IsPartition")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *TableName) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "db-name"
	err = en.Append(0x84, 0xa7, 0x64, 0x62, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Schema)
	if err != nil {
		err = msgp.WrapError(err, "Schema")
		return
	}
	// write "tbl-name"
	err = en.Append(0xa8, 0x74, 0x62, 0x6c, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Table)
	if err != nil {
		err = msgp.WrapError(err, "Table")
		return
	}
	// write "tbl-id"
	err = en.Append(0xa6, 0x74, 0x62, 0x6c, 0x2d, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.TableID)
	if err != nil {
		err = msgp.WrapError(err, "TableID")
		return
	}
	// write "is-partition"
	err = en.Append(0xac, 0x69, 0x73, 0x2d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteBool(z.IsPartition)
	if err != nil {
		err = msgp.WrapError(err, "IsPartition")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TableName) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "db-name"
	o = append(o, 0x84, 0xa7, 0x64, 0x62, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Schema)
	// string "tbl-name"
	o = append(o, 0xa8, 0x74, 0x62, 0x6c, 0x2d, 0x6e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Table)
	// string "tbl-id"
	o = append(o, 0xa6, 0x74, 0x62, 0x6c, 0x2d, 0x69, 0x64)
	o = msgp.AppendInt64(o, z.TableID)
	// string "is-partition"
	o = append(o, 0xac, 0x69, 0x73, 0x2d, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	o = msgp.AppendBool(o, z.IsPartition)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TableName) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "db-name":
			z.Schema, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Schema")
				return
			}
		case "tbl-name":
			z.Table, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Table")
				return
			}
		case "tbl-id":
			z.TableID, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TableID")
				return
			}
		case "is-partition":
			z.IsPartition, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsPartition")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *TableName) Msgsize() (s int) {
	s = 1 + 8 + msgp.StringPrefixSize + len(z.Schema) + 9 + msgp.StringPrefixSize + len(z.Table) + 7 + msgp.Int64Size + 13 + msgp.BoolSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *TopicPartitionKey) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Topic":
			z.Topic, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Topic")
				return
			}
		case "Partition":
			z.Partition, err = dc.ReadInt32()
			if err != nil {
				err = msgp.WrapError(err, "Partition")
				return
			}
		case "PartitionKey":
			z.PartitionKey, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "PartitionKey")
				return
			}
		case "TotalPartition":
			z.TotalPartition, err = dc.ReadInt32()
			if err != nil {
				err = msgp.WrapError(err, "TotalPartition")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *TopicPartitionKey) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "Topic"
	err = en.Append(0x84, 0xa5, 0x54, 0x6f, 0x70, 0x69, 0x63)
	if err != nil {
		return
	}
	err = en.WriteString(z.Topic)
	if err != nil {
		err = msgp.WrapError(err, "Topic")
		return
	}
	// write "Partition"
	err = en.Append(0xa9, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteInt32(z.Partition)
	if err != nil {
		err = msgp.WrapError(err, "Partition")
		return
	}
	// write "PartitionKey"
	err = en.Append(0xac, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79)
	if err != nil {
		return
	}
	err = en.WriteString(z.PartitionKey)
	if err != nil {
		err = msgp.WrapError(err, "PartitionKey")
		return
	}
	// write "TotalPartition"
	err = en.Append(0xae, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteInt32(z.TotalPartition)
	if err != nil {
		err = msgp.WrapError(err, "TotalPartition")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TopicPartitionKey) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Topic"
	o = append(o, 0x84, 0xa5, 0x54, 0x6f, 0x70, 0x69, 0x63)
	o = msgp.AppendString(o, z.Topic)
	// string "Partition"
	o = append(o, 0xa9, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	o = msgp.AppendInt32(o, z.Partition)
	// string "PartitionKey"
	o = append(o, 0xac, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79)
	o = msgp.AppendString(o, z.PartitionKey)
	// string "TotalPartition"
	o = append(o, 0xae, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	o = msgp.AppendInt32(o, z.TotalPartition)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TopicPartitionKey) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Topic":
			z.Topic, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Topic")
				return
			}
		case "Partition":
			z.Partition, bts, err = msgp.ReadInt32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Partition")
				return
			}
		case "PartitionKey":
			z.PartitionKey, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PartitionKey")
				return
			}
		case "TotalPartition":
			z.TotalPartition, bts, err = msgp.ReadInt32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalPartition")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *TopicPartitionKey) Msgsize() (s int) {
	s = 1 + 6 + msgp.StringPrefixSize + len(z.Topic) + 10 + msgp.Int32Size + 13 + msgp.StringPrefixSize + len(z.PartitionKey) + 15 + msgp.Int32Size
	return
}