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

package v1

// 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 "value":
			z.Value, err = dc.ReadIntf()
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "ApproximateBytes":
			z.ApproximateBytes, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ApproximateBytes")
				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 5
	// write "name"
	err = en.Append(0x85, 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 "value"
	err = en.Append(0xa5, 0x76, 0x61, 0x6c, 0x75, 0x65)
	if err != nil {
		return
	}
	err = en.WriteIntf(z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// write "ApproximateBytes"
	err = en.Append(0xb0, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.ApproximateBytes)
	if err != nil {
		err = msgp.WrapError(err, "ApproximateBytes")
		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 5
	// string "name"
	o = append(o, 0x85, 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 "value"
	o = append(o, 0xa5, 0x76, 0x61, 0x6c, 0x75, 0x65)
	o, err = msgp.AppendIntf(o, z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// string "ApproximateBytes"
	o = append(o, 0xb0, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73)
	o = msgp.AppendInt(o, z.ApproximateBytes)
	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 "value":
			z.Value, bts, err = msgp.ReadIntfBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "ApproximateBytes":
			z.ApproximateBytes, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ApproximateBytes")
				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) + 6 + msgp.GuessSize(z.Value) + 17 + msgp.IntSize
	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 *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":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Column")
					return
				}
				z.Column = nil
			} else {
				if z.Column == nil {
					z.Column = new(Column)
				}
				err = z.Column.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Column")
					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 2
	// write "column"
	err = en.Append(0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
	if err != nil {
		return
	}
	if z.Column == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Column.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Column")
			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 2
	// string "column"
	o = append(o, 0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
	if z.Column == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Column.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Column")
			return
		}
	}
	// 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":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Column = nil
			} else {
				if z.Column == nil {
					z.Column = new(Column)
				}
				bts, err = z.Column.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Column")
					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
	if z.Column == nil {
		s += msgp.NilSize
	} else {
		s += z.Column.Msgsize()
	}
	s += 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
			}
		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 2
	// write "ddl"
	err = en.Append(0x82, 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
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RedoDDLEvent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "ddl"
	o = append(o, 0x82, 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)
	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
			}
		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
	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":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "RedoRow")
					return
				}
				z.RedoRow = nil
			} else {
				if z.RedoRow == nil {
					z.RedoRow = new(RedoRowChangedEvent)
				}
				err = z.RedoRow.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "RedoRow")
					return
				}
			}
		case "ddl":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "RedoDDL")
					return
				}
				z.RedoDDL = nil
			} else {
				if z.RedoDDL == nil {
					z.RedoDDL = new(RedoDDLEvent)
				}
				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
	}
	if z.RedoRow == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		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
	}
	if z.RedoDDL == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		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)
	if z.RedoRow == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.RedoRow.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "RedoRow")
			return
		}
	}
	// string "ddl"
	o = append(o, 0xa3, 0x64, 0x64, 0x6c)
	if z.RedoDDL == nil {
		o = msgp.AppendNil(o)
	} else {
		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":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.RedoRow = nil
			} else {
				if z.RedoRow == nil {
					z.RedoRow = new(RedoRowChangedEvent)
				}
				bts, err = z.RedoRow.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "RedoRow")
					return
				}
			}
		case "ddl":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.RedoDDL = nil
			} else {
				if z.RedoDDL == nil {
					z.RedoDDL = new(RedoDDLEvent)
				}
				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
	if z.RedoRow == nil {
		s += msgp.NilSize
	} else {
		s += z.RedoRow.Msgsize()
	}
	s += 4
	if z.RedoDDL == nil {
		s += msgp.NilSize
	} else {
		s += z.RedoDDL.Msgsize()
	}
	s += 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(RowChangedEvent)
				}
				err = z.Row.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Row")
					return
				}
			}
		case "pre-columns":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0002) {
				z.PreColumns = (z.PreColumns)[:zb0002]
			} else {
				z.PreColumns = make([]*RedoColumn, zb0002)
			}
			for za0001 := range z.PreColumns {
				if dc.IsNil() {
					err = dc.ReadNil()
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0001)
						return
					}
					z.PreColumns[za0001] = nil
				} else {
					if z.PreColumns[za0001] == nil {
						z.PreColumns[za0001] = new(RedoColumn)
					}
					var zb0003 uint32
					zb0003, err = dc.ReadMapHeader()
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, err = dc.ReadMapKeyPtr()
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "column":
							if dc.IsNil() {
								err = dc.ReadNil()
								if err != nil {
									err = msgp.WrapError(err, "PreColumns", za0001, "Column")
									return
								}
								z.PreColumns[za0001].Column = nil
							} else {
								if z.PreColumns[za0001].Column == nil {
									z.PreColumns[za0001].Column = new(Column)
								}
								err = z.PreColumns[za0001].Column.DecodeMsg(dc)
								if err != nil {
									err = msgp.WrapError(err, "PreColumns", za0001, "Column")
									return
								}
							}
						case "flag":
							z.PreColumns[za0001].Flag, err = dc.ReadUint64()
							if err != nil {
								err = msgp.WrapError(err, "PreColumns", za0001, "Flag")
								return
							}
						default:
							err = dc.Skip()
							if err != nil {
								err = msgp.WrapError(err, "PreColumns", za0001)
								return
							}
						}
					}
				}
			}
		case "columns":
			var zb0004 uint32
			zb0004, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0004) {
				z.Columns = (z.Columns)[:zb0004]
			} else {
				z.Columns = make([]*RedoColumn, zb0004)
			}
			for za0002 := range z.Columns {
				if dc.IsNil() {
					err = dc.ReadNil()
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0002)
						return
					}
					z.Columns[za0002] = nil
				} else {
					if z.Columns[za0002] == nil {
						z.Columns[za0002] = new(RedoColumn)
					}
					var zb0005 uint32
					zb0005, err = dc.ReadMapHeader()
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0002)
						return
					}
					for zb0005 > 0 {
						zb0005--
						field, err = dc.ReadMapKeyPtr()
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0002)
							return
						}
						switch msgp.UnsafeString(field) {
						case "column":
							if dc.IsNil() {
								err = dc.ReadNil()
								if err != nil {
									err = msgp.WrapError(err, "Columns", za0002, "Column")
									return
								}
								z.Columns[za0002].Column = nil
							} else {
								if z.Columns[za0002].Column == nil {
									z.Columns[za0002].Column = new(Column)
								}
								err = z.Columns[za0002].Column.DecodeMsg(dc)
								if err != nil {
									err = msgp.WrapError(err, "Columns", za0002, "Column")
									return
								}
							}
						case "flag":
							z.Columns[za0002].Flag, err = dc.ReadUint64()
							if err != nil {
								err = msgp.WrapError(err, "Columns", za0002, "Flag")
								return
							}
						default:
							err = dc.Skip()
							if err != nil {
								err = msgp.WrapError(err, "Columns", 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 "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 za0001 := range z.PreColumns {
		if z.PreColumns[za0001] == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			// map header, size 2
			// write "column"
			err = en.Append(0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
			if err != nil {
				return
			}
			if z.PreColumns[za0001].Column == nil {
				err = en.WriteNil()
				if err != nil {
					return
				}
			} else {
				err = z.PreColumns[za0001].Column.EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "PreColumns", za0001, "Column")
					return
				}
			}
			// write "flag"
			err = en.Append(0xa4, 0x66, 0x6c, 0x61, 0x67)
			if err != nil {
				return
			}
			err = en.WriteUint64(z.PreColumns[za0001].Flag)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns", za0001, "Flag")
				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 za0002 := range z.Columns {
		if z.Columns[za0002] == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			// map header, size 2
			// write "column"
			err = en.Append(0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
			if err != nil {
				return
			}
			if z.Columns[za0002].Column == nil {
				err = en.WriteNil()
				if err != nil {
					return
				}
			} else {
				err = z.Columns[za0002].Column.EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Columns", za0002, "Column")
					return
				}
			}
			// write "flag"
			err = en.Append(0xa4, 0x66, 0x6c, 0x61, 0x67)
			if err != nil {
				return
			}
			err = en.WriteUint64(z.Columns[za0002].Flag)
			if err != nil {
				err = msgp.WrapError(err, "Columns", 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 "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 za0001 := range z.PreColumns {
		if z.PreColumns[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "column"
			o = append(o, 0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
			if z.PreColumns[za0001].Column == nil {
				o = msgp.AppendNil(o)
			} else {
				o, err = z.PreColumns[za0001].Column.MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "PreColumns", za0001, "Column")
					return
				}
			}
			// string "flag"
			o = append(o, 0xa4, 0x66, 0x6c, 0x61, 0x67)
			o = msgp.AppendUint64(o, z.PreColumns[za0001].Flag)
		}
	}
	// string "columns"
	o = append(o, 0xa7, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Columns)))
	for za0002 := range z.Columns {
		if z.Columns[za0002] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "column"
			o = append(o, 0x82, 0xa6, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e)
			if z.Columns[za0002].Column == nil {
				o = msgp.AppendNil(o)
			} else {
				o, err = z.Columns[za0002].Column.MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Columns", za0002, "Column")
					return
				}
			}
			// string "flag"
			o = append(o, 0xa4, 0x66, 0x6c, 0x61, 0x67)
			o = msgp.AppendUint64(o, z.Columns[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(RowChangedEvent)
				}
				bts, err = z.Row.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Row")
					return
				}
			}
		case "pre-columns":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PreColumns")
				return
			}
			if cap(z.PreColumns) >= int(zb0002) {
				z.PreColumns = (z.PreColumns)[:zb0002]
			} else {
				z.PreColumns = make([]*RedoColumn, zb0002)
			}
			for za0001 := range z.PreColumns {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.PreColumns[za0001] = nil
				} else {
					if z.PreColumns[za0001] == nil {
						z.PreColumns[za0001] = new(RedoColumn)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "PreColumns", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "PreColumns", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "column":
							if msgp.IsNil(bts) {
								bts, err = msgp.ReadNilBytes(bts)
								if err != nil {
									return
								}
								z.PreColumns[za0001].Column = nil
							} else {
								if z.PreColumns[za0001].Column == nil {
									z.PreColumns[za0001].Column = new(Column)
								}
								bts, err = z.PreColumns[za0001].Column.UnmarshalMsg(bts)
								if err != nil {
									err = msgp.WrapError(err, "PreColumns", za0001, "Column")
									return
								}
							}
						case "flag":
							z.PreColumns[za0001].Flag, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "PreColumns", za0001, "Flag")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "PreColumns", za0001)
								return
							}
						}
					}
				}
			}
		case "columns":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Columns")
				return
			}
			if cap(z.Columns) >= int(zb0004) {
				z.Columns = (z.Columns)[:zb0004]
			} else {
				z.Columns = make([]*RedoColumn, zb0004)
			}
			for za0002 := range z.Columns {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Columns[za0002] = nil
				} else {
					if z.Columns[za0002] == nil {
						z.Columns[za0002] = new(RedoColumn)
					}
					var zb0005 uint32
					zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Columns", za0002)
						return
					}
					for zb0005 > 0 {
						zb0005--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "Columns", za0002)
							return
						}
						switch msgp.UnsafeString(field) {
						case "column":
							if msgp.IsNil(bts) {
								bts, err = msgp.ReadNilBytes(bts)
								if err != nil {
									return
								}
								z.Columns[za0002].Column = nil
							} else {
								if z.Columns[za0002].Column == nil {
									z.Columns[za0002].Column = new(Column)
								}
								bts, err = z.Columns[za0002].Column.UnmarshalMsg(bts)
								if err != nil {
									err = msgp.WrapError(err, "Columns", za0002, "Column")
									return
								}
							}
						case "flag":
							z.Columns[za0002].Flag, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Columns", za0002, "Flag")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "Columns", 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 += 12 + msgp.ArrayHeaderSize
	for za0001 := range z.PreColumns {
		if z.PreColumns[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 7
			if z.PreColumns[za0001].Column == nil {
				s += msgp.NilSize
			} else {
				s += z.PreColumns[za0001].Column.Msgsize()
			}
			s += 5 + msgp.Uint64Size
		}
	}
	s += 8 + msgp.ArrayHeaderSize
	for za0002 := range z.Columns {
		if z.Columns[za0002] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 7
			if z.Columns[za0002].Column == nil {
				s += msgp.NilSize
			} else {
				s += z.Columns[za0002].Column.Msgsize()
			}
			s += 5 + msgp.Uint64Size
		}
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *RowChangedEvent) 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 "index-columns":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns")
				return
			}
			if cap(z.IndexColumns) >= int(zb0002) {
				z.IndexColumns = (z.IndexColumns)[:zb0002]
			} else {
				z.IndexColumns = make([][]int, zb0002)
			}
			for za0001 := range z.IndexColumns {
				var zb0003 uint32
				zb0003, err = dc.ReadArrayHeader()
				if err != nil {
					err = msgp.WrapError(err, "IndexColumns", za0001)
					return
				}
				if cap(z.IndexColumns[za0001]) >= int(zb0003) {
					z.IndexColumns[za0001] = (z.IndexColumns[za0001])[:zb0003]
				} else {
					z.IndexColumns[za0001] = make([]int, zb0003)
				}
				for za0002 := range z.IndexColumns[za0001] {
					z.IndexColumns[za0001][za0002], err = dc.ReadInt()
					if err != nil {
						err = msgp.WrapError(err, "IndexColumns", za0001, za0002)
						return
					}
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RowChangedEvent) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "start-ts"
	err = en.Append(0x84, 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 "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 za0001 := range z.IndexColumns {
		err = en.WriteArrayHeader(uint32(len(z.IndexColumns[za0001])))
		if err != nil {
			err = msgp.WrapError(err, "IndexColumns", za0001)
			return
		}
		for za0002 := range z.IndexColumns[za0001] {
			err = en.WriteInt(z.IndexColumns[za0001][za0002])
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns", za0001, za0002)
				return
			}
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *RowChangedEvent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "start-ts"
	o = append(o, 0x84, 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 "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 za0001 := range z.IndexColumns {
		o = msgp.AppendArrayHeader(o, uint32(len(z.IndexColumns[za0001])))
		for za0002 := range z.IndexColumns[za0001] {
			o = msgp.AppendInt(o, z.IndexColumns[za0001][za0002])
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RowChangedEvent) 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 "index-columns":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IndexColumns")
				return
			}
			if cap(z.IndexColumns) >= int(zb0002) {
				z.IndexColumns = (z.IndexColumns)[:zb0002]
			} else {
				z.IndexColumns = make([][]int, zb0002)
			}
			for za0001 := range z.IndexColumns {
				var zb0003 uint32
				zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "IndexColumns", za0001)
					return
				}
				if cap(z.IndexColumns[za0001]) >= int(zb0003) {
					z.IndexColumns[za0001] = (z.IndexColumns[za0001])[:zb0003]
				} else {
					z.IndexColumns[za0001] = make([]int, zb0003)
				}
				for za0002 := range z.IndexColumns[za0001] {
					z.IndexColumns[za0001][za0002], bts, err = msgp.ReadIntBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "IndexColumns", za0001, 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 *RowChangedEvent) 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 += 14 + msgp.ArrayHeaderSize
	for za0001 := range z.IndexColumns {
		s += msgp.ArrayHeaderSize + (len(z.IndexColumns[za0001]) * (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
}