prepare for negative values

Author: dveeden

replication/event.go

@@ -582,34 +582,24 @@ func (e *GtidTaggedLogEvent) Decode(data []byte) error {
 				},
 				{
 					Name: "immediate_commit_timestamp",
-					Type: serialization.FieldIntVar{
-						Unsigned: true,
-					},
+					Type: serialization.FieldUintVar{},
 				},
 				{
-					Name: "original_commit_timestamp",
-					Type: serialization.FieldIntVar{
-						Unsigned: true,
-					},
+					Name:     "original_commit_timestamp",
+					Type:     serialization.FieldUintVar{},
 					Optional: true,
 				},
 				{
 					Name: "transaction_length",
-					Type: serialization.FieldIntVar{
-						Unsigned: true,
-					},
+					Type: serialization.FieldUintVar{},
 				},
 				{
 					Name: "immediate_server_version",
-					Type: serialization.FieldIntVar{
-						Unsigned: true,
-					},
+					Type: serialization.FieldUintVar{},
 				},
 				{
-					Name: "original_server_version",
-					Type: serialization.FieldIntVar{
-						Unsigned: true,
-					},
+					Name:     "original_server_version",
+					Type:     serialization.FieldUintVar{},
 					Optional: true,
 				},
 				{
@@ -637,7 +627,7 @@ func (e *GtidTaggedLogEvent) Dump(w io.Writer) {
 	}
 
 	if v, ok := f.Type.(serialization.FieldIntVar); ok {
-		fmt.Printf("Immediate server version: %d\n",v.Value)
+		fmt.Printf("Immediate server version: %d\n", v.Value)
 	}
 }
 

serialization/serialization.go

@@ -84,14 +84,21 @@ func (f FieldIntFixed) String() string {
 }
 
 type FieldIntVar struct {
-	Value    uint64
-	Unsigned bool
+	Value int64
 }
 
 func (f FieldIntVar) String() string {
 	return fmt.Sprintf("%d", f.Value)
 }
 
+type FieldUintVar struct {
+	Value uint64
+}
+
+func (f FieldUintVar) String() string {
+	return fmt.Sprintf("%d", f.Value)
+}
+
 type FieldString struct {
 	Value string
 }
@@ -154,11 +161,27 @@ func Unmarshal(data []byte, v interface{}) error {
 					return err
 				}
 				m.Fields[i].Type = f
+			case FieldUintVar:
+				val, err := decodeVar(r, true)
+				if err != nil {
+					return err
+				}
+				if uintval, ok := val.(uint64); ok {
+					f.Value = uintval
+				} else {
+					return errors.New("unexpected type, expecting uint64")
+				}
+				m.Fields[i].Type = f
 			case FieldIntVar:
-				f.Value, err = decodeVar(r, f.Unsigned)
+				val, err := decodeVar(r, false)
 				if err != nil {
 					return err
 				}
+				if intval, ok := val.(int64); ok {
+					f.Value = intval
+				} else {
+					return errors.New("unexpected type, expecting int64")
+				}
 				m.Fields[i].Type = f
 			case FieldString:
 				f.Value, err = decodeString(r)
@@ -227,7 +250,7 @@ func decodeFixed(r io.Reader, len int) ([]byte, error) {
 	return b.Bytes(), nil
 }
 
-func decodeVar(r io.ReadSeeker, unsigned bool) (uint64, error) {
+func decodeVar(r io.ReadSeeker, unsigned bool) (interface{}, error) {
 	firstByte := make([]byte, 1)
 	_, err := r.Read(firstByte)
 	if err != nil {
@@ -243,7 +266,7 @@ func decodeVar(r io.ReadSeeker, unsigned bool) (uint64, error) {
 	if err != nil {
 		return 0, err
 	}
-	if n != tb+1{
+	if n != tb+1 {
 		return 0, fmt.Errorf("only read %d bytes, expected %d", n, tb+1)
 	}
 	var tNum uint64
@@ -270,9 +293,9 @@ func decodeVar(r io.ReadSeeker, unsigned bool) (uint64, error) {
 		tNum = binary.LittleEndian.Uint64(fieldBytes)
 	}
 	if unsigned {
-		return (tNum >> (tb + 2) * 2)+1, nil
+		return (tNum >> (tb + 2) * 2) + 1, nil
 	}
-	return tNum >> (tb + 2), nil
+	return int64(tNum >> (tb + 2)), nil
 }
 
 func trailingOneBitCount(b byte) (count int) {

serialization/serialization_test.go

@@ -75,7 +75,6 @@ func TestDecodeFixed(t *testing.T) {
 		} else {
 			require.ErrorContains(t, err, tc.err)
 		}
-
 	}
 }
 
@@ -120,10 +119,10 @@ func TestDecodeString(t *testing.T) {
 
 func TestDecodeVar(t *testing.T) {
 	testcases := []struct {
-		input  []byte
+		input    []byte
 		unsigned bool
-		result uint64
-		err    string
+		result   interface{}
+		err      string
 	}{
 		{
 			[]byte{},
@@ -140,68 +139,68 @@ func TestDecodeVar(t *testing.T) {
 		{
 			[]byte{0x4},
 			false,
-			1,
+			int64(1),
 			"",
 		},
 		{
 			[]byte{0xd9, 0x03},
 			false,
-			123,
+			int64(123),
 			"",
 		},
 		// {
 		// 	[]byte{0xc3, 02, 0x0b},
 		// 	true,
-		// 	90200,
+		// 	uint64(90200),
 		// 	"",
 		// },
 		{
 			// From the example on https://dev.mysql.com/doc/dev/mysql-server/latest/PageLibsMysqlSerialization.html
 			// But converted to LE
 			[]byte{0b11111011, 0b11111111, 0b00000111},
 			true,
-			65535,
+			uint64(65535),
 			"",
 		},
 		{
 			// From the example on https://dev.mysql.com/doc/dev/mysql-server/latest/PageLibsMysqlSerialization.html
 			// But converted to LE
 			[]byte{0b11111011, 0b11111111, 0b00001111},
 			false,
-			65535,
+			int64(65535),
 			"",
 		},
 		// {
 		// 	// From the example on https://dev.mysql.com/doc/dev/mysql-server/latest/PageLibsMysqlSerialization.html
 		// 	// But converted to LE
 		// 	[]byte{0b11101011, 0b11111111, 0b00001111},
 		// 	false,
-		// 	-65535,
+		// 	int64(-65535),
 		// 	"",
 		// },
 		// {
 		// 	// From the example on https://dev.mysql.com/doc/dev/mysql-server/latest/PageLibsMysqlSerialization.html
 		// 	// But converted to LE
 		// 	[]byte{0b11111011, 0b11111111, 0b00001111},
 		// 	false,
-		// 	-65536,
+		// 	int64(-65536),
 		// 	"",
 		// },
 		{
 			[]byte{0x5d, 0x03},
 			true,
-			215,
+			uint64(215),
 			"",
 		},
 		{
 			[]byte{0x7f, 0x39, 0x7d, 0x89, 0x70, 0xdb, 0x2d, 0x06},
 			true,
-			1739270369410361,
+			uint64(1739270369410361),
 			"",
 		},
 	}
 
-	for _, tc := range testcases{
+	for _, tc := range testcases {
 		r, err := decodeVar(bytes.NewReader(tc.input), tc.unsigned)
 		if tc.err == "" {
 			require.NoError(t, err)