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 *ColumnDataX) 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 "ColumnData": if dc.IsNil() { err = dc.ReadNil() if err != nil { err = msgp.WrapError(err, "ColumnData") return } z.ColumnData = nil } else { if z.ColumnData == nil { z.ColumnData = new(ColumnData) } var zb0002 uint32 zb0002, err = dc.ReadMapHeader() if err != nil { err = msgp.WrapError(err, "ColumnData") return } for zb0002 > 0 { zb0002-- field, err = dc.ReadMapKeyPtr() if err != nil { err = msgp.WrapError(err, "ColumnData") return } switch msgp.UnsafeString(field) { case "column_id": z.ColumnData.ColumnID, err = dc.ReadInt64() if err != nil { err = msgp.WrapError(err, "ColumnData", "ColumnID") return } default: err = dc.Skip() if err != nil { err = msgp.WrapError(err, "ColumnData") return } } } } default: err = dc.Skip() if err != nil { err = msgp.WrapError(err) return } } } return } // EncodeMsg implements msgp.Encodable func (z *ColumnDataX) EncodeMsg(en *msgp.Writer) (err error) { // map header, size 1 // write "ColumnData" err = en.Append(0x81, 0xaa, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61) if err != nil { return } if z.ColumnData == nil { err = en.WriteNil() if err != nil { return } } else { // 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.ColumnData.ColumnID) if err != nil { err = msgp.WrapError(err, "ColumnData", "ColumnID") return } } return } // MarshalMsg implements msgp.Marshaler func (z *ColumnDataX) MarshalMsg(b []byte) (o []byte, err error) { o = msgp.Require(b, z.Msgsize()) // map header, size 1 // string "ColumnData" o = append(o, 0x81, 0xaa, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61) if z.ColumnData == nil { o = msgp.AppendNil(o) } else { // 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.ColumnData.ColumnID) } return } // UnmarshalMsg implements msgp.Unmarshaler func (z *ColumnDataX) 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 "ColumnData": if msgp.IsNil(bts) { bts, err = msgp.ReadNilBytes(bts) if err != nil { return } z.ColumnData = nil } else { if z.ColumnData == nil { z.ColumnData = new(ColumnData) } var zb0002 uint32 zb0002, bts, err = msgp.ReadMapHeaderBytes(bts) if err != nil { err = msgp.WrapError(err, "ColumnData") return } for zb0002 > 0 { zb0002-- field, bts, err = msgp.ReadMapKeyZC(bts) if err != nil { err = msgp.WrapError(err, "ColumnData") return } switch msgp.UnsafeString(field) { case "column_id": z.ColumnData.ColumnID, bts, err = msgp.ReadInt64Bytes(bts) if err != nil { err = msgp.WrapError(err, "ColumnData", "ColumnID") return } default: bts, err = msgp.Skip(bts) if err != nil { err = msgp.WrapError(err, "ColumnData") 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 *ColumnDataX) Msgsize() (s int) { s = 1 + 11 if z.ColumnData == nil { s += msgp.NilSize } else { 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 } case "seq": z.Seq, err = dc.ReadUint64() if err != nil { err = msgp.WrapError(err, "Seq") 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 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 "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 } // write "seq" err = en.Append(0xa3, 0x73, 0x65, 0x71) if err != nil { return } err = en.WriteUint64(z.Seq) if err != nil { err = msgp.WrapError(err, "Seq") 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 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 "query" o = append(o, 0xa5, 0x71, 0x75, 0x65, 0x72, 0x79) o = msgp.AppendString(o, z.Query) // string "seq" o = append(o, 0xa3, 0x73, 0x65, 0x71) o = msgp.AppendUint64(o, z.Seq) 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 } case "seq": z.Seq, bts, err = msgp.ReadUint64Bytes(bts) if err != nil { err = msgp.WrapError(err, "Seq") 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) + 4 + msgp.Uint64Size 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) } err = z.DDL.DecodeMsg(dc) 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 { err = z.DDL.EncodeMsg(en) if err != nil { err = msgp.WrapError(err, "DDL") 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 { o, err = z.DDL.MarshalMsg(o) if err != nil { err = msgp.WrapError(err, "DDL") return } } // 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) } bts, err = z.DDL.UnmarshalMsg(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 += z.DDL.Msgsize() } 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 }