Move MySQL56 to MySQL

Signed-off-by: Matt Lord <[email protected]>

examples/local/vstream_client.go

@@ -47,7 +47,7 @@ func main() {
 				Shard:    "-80",
 				// Gtid "" is to stream from the start, "current" is to stream from the current gtid
 				// you can also specify a gtid to start with.
-				Gtid: "", //"current"  // "MySQL56/36a89abd-978f-11eb-b312-04ed332e05c2:1-265"
+				Gtid: "", //"current"  // "MySQL/36a89abd-978f-11eb-b312-04ed332e05c2:1-265"
 			}, {
 				Keyspace: "customer",
 				Shard:    "80-",

go/cmd/vtctldclient/command/vreplication/vdiff/vdiff_env_test.go

@@ -48,13 +48,13 @@ import (
 const (
 	// vdiffStopPosition is the default stop position for the target vreplication.
 	// It can be overridden with the positons argument to newTestVDiffEnv.
-	vdiffStopPosition = "MySQL56/d834e6b8-7cbf-11ed-a1eb-0242ac120002:1-892"
+	vdiffStopPosition = "MySQL/d834e6b8-7cbf-11ed-a1eb-0242ac120002:1-892"
 	// vdiffSourceGtid should be the position reported by the source side VStreamResults.
 	// It's expected to be higher the vdiffStopPosition.
-	vdiffSourceGtid = "MySQL56/d834e6b8-7cbf-11ed-a1eb-0242ac120002:1-893"
+	vdiffSourceGtid = "MySQL/d834e6b8-7cbf-11ed-a1eb-0242ac120002:1-893"
 	// vdiffTargetPrimaryPosition is the primary position of the target after
 	// vreplication has been synchronized.
-	vdiffTargetPrimaryPosition = "MySQL56/e34d6fb6-7cbf-11ed-a1eb-0242ac120002:1-892"
+	vdiffTargetPrimaryPosition = "MySQL/e34d6fb6-7cbf-11ed-a1eb-0242ac120002:1-892"
 )
 
 type testVDiffEnv struct {

go/cmd/vtctldclient/command/vreplication/vdiff/vdiff_test.go

@@ -572,8 +572,8 @@ func TestVDiffSharded(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	env := newTestVDiffEnv(t, ctx, []string{"-40", "40-"}, []string{"-80", "80-"}, "", map[string]string{
-		"-80": "MySQL56/0e45e704-7cb9-11ed-a1eb-0242ac120002:1-890",
-		"80-": "MySQL56/1497ddb0-7cb9-11ed-a1eb-0242ac120002:1-891",
+		"-80": "MySQL/0e45e704-7cb9-11ed-a1eb-0242ac120002:1-890",
+		"80-": "MySQL/1497ddb0-7cb9-11ed-a1eb-0242ac120002:1-891",
 	})
 	defer env.close()
 

go/mysql/binlog_event_compression.go

@@ -220,7 +220,7 @@ func (tp *TransactionPayload) decode() error {
 					eventLen, pos, decompressedPayloadLen))
 		}
 		eventData := decompressedPayload[pos : pos+eventLen]
-		ble := NewMysql56BinlogEvent(eventData)
+		ble := NewMysqlBinlogEvent(eventData)
 		tp.Events = append(tp.Events, ble)
 
 		pos += eventLen

go/mysql/binlog_event_make.go

@@ -30,8 +30,8 @@ const (
 // This file contains utility methods to create binlog replication
 // packets. They are mostly used for testing.
 
-// NewMySQL56BinlogFormat returns a typical BinlogFormat for MySQL 5.6.
-func NewMySQL56BinlogFormat() BinlogFormat {
+// NewMySQLBinlogFormat returns a typical BinlogFormat for MySQL 5.6.
+func NewMySQLBinlogFormat() BinlogFormat {
 	return BinlogFormat{
 		FormatVersion:     4,
 		ServerVersion:     "5.6.33-0ubuntu0.14.04.1-log",
@@ -133,11 +133,11 @@ func (s *FakeBinlogStream) Packetize(f BinlogFormat, typ byte, flags uint16, dat
 
 // NewInvalidEvent returns an invalid event (its size is <19).
 func NewInvalidEvent() BinlogEvent {
-	return NewMysql56BinlogEvent([]byte{0})
+	return NewMysqlBinlogEvent([]byte{0})
 }
 
 // NewFormatDescriptionEvent creates a new FormatDescriptionEvent
-// based on the provided BinlogFormat. It uses a mysql56BinlogEvent
+// based on the provided BinlogFormat. It uses a mysqlBinlogEvent
 // but could use a MariaDB one.
 func NewFormatDescriptionEvent(f BinlogFormat, s *FakeBinlogStream) BinlogEvent {
 	length := 2 + // binlog-version
@@ -155,7 +155,7 @@ func NewFormatDescriptionEvent(f BinlogFormat, s *FakeBinlogStream) BinlogEvent
 	data[57+len(f.HeaderSizes)] = f.ChecksumAlgorithm
 
 	ev := s.Packetize(f, eFormatDescriptionEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewInvalidFormatDescriptionEvent returns an invalid FormatDescriptionEvent.
@@ -166,7 +166,7 @@ func NewInvalidFormatDescriptionEvent(f BinlogFormat, s *FakeBinlogStream) Binlo
 	data[0] = 3
 
 	ev := s.Packetize(f, eFormatDescriptionEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewRotateEvent returns a RotateEvent.
@@ -179,7 +179,7 @@ func NewRotateEvent(f BinlogFormat, s *FakeBinlogStream, position uint64, filena
 	copy(data[8:], filename)
 
 	ev := s.Packetize(f, eRotateEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 func NewFakeRotateEvent(f BinlogFormat, s *FakeBinlogStream, filename string) BinlogEvent {
@@ -190,14 +190,14 @@ func NewFakeRotateEvent(f BinlogFormat, s *FakeBinlogStream, filename string) Bi
 	copy(data[8:], filename)
 
 	ev := s.Packetize(f, eRotateEvent, FlagLogEventArtificial, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewHeartbeatEvent returns a HeartbeatEvent.
 // see https://dev.mysql.com/doc/internals/en/heartbeat-event.html
 func NewHeartbeatEvent(f BinlogFormat, s *FakeBinlogStream) BinlogEvent {
 	ev := s.Packetize(f, eHeartbeatEvent, 0, []byte{})
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewHeartbeatEvent returns a HeartbeatEvent.
@@ -208,7 +208,7 @@ func NewHeartbeatEventWithLogFile(f BinlogFormat, s *FakeBinlogStream, filename
 	copy(data, filename)
 
 	ev := s.Packetize(f, eHeartbeatEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewQueryEvent makes up a QueryEvent based on the Query structure.
@@ -250,7 +250,7 @@ func NewQueryEvent(f BinlogFormat, s *FakeBinlogStream, q Query) BinlogEvent {
 	copy(data[pos:], q.SQL)
 
 	ev := s.Packetize(f, eQueryEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewInvalidQueryEvent returns an invalid QueryEvent. IsValid is however true.
@@ -261,7 +261,7 @@ func NewInvalidQueryEvent(f BinlogFormat, s *FakeBinlogStream) BinlogEvent {
 	data[4+4] = 200 // > 100
 
 	ev := s.Packetize(f, eQueryEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewXIDEvent returns a XID event. We do not use the data, so keep it 0.
@@ -270,7 +270,7 @@ func NewXIDEvent(f BinlogFormat, s *FakeBinlogStream) BinlogEvent {
 	data := make([]byte, length)
 
 	ev := s.Packetize(f, eXIDEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewIntVarEvent returns an IntVar event.
@@ -289,7 +289,7 @@ func NewIntVarEvent(f BinlogFormat, s *FakeBinlogStream, typ byte, value uint64)
 	data[8] = byte(value >> 56)
 
 	ev := s.Packetize(f, eIntVarEvent, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }
 
 // NewMariaDBGTIDEvent returns a MariaDB specific GTID event.
@@ -462,5 +462,5 @@ func newRowsEvent(f BinlogFormat, s *FakeBinlogStream, typ byte, tableID uint64,
 	}
 
 	ev := s.Packetize(f, typ, 0, data)
-	return NewMysql56BinlogEvent(ev)
+	return NewMysqlBinlogEvent(ev)
 }

go/mysql/binlog_event_make_test.go

@@ -33,7 +33,7 @@ import (
 // FormatDescriptionEvent is working properly.
 func TestFormatDescriptionEvent(t *testing.T) {
 	// MySQL 5.6
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	event := NewFormatDescriptionEvent(f, s)
@@ -59,7 +59,7 @@ func TestFormatDescriptionEvent(t *testing.T) {
 }
 
 func TestQueryEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	q := Query{
@@ -85,7 +85,7 @@ func TestQueryEvent(t *testing.T) {
 }
 
 func TestXIDEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	event := NewXIDEvent(f, s)
@@ -95,7 +95,7 @@ func TestXIDEvent(t *testing.T) {
 }
 
 func TestIntVarEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	event := NewIntVarEvent(f, s, IntVarLastInsertID, 0x123456789abcdef0)
@@ -117,7 +117,7 @@ func TestIntVarEvent(t *testing.T) {
 }
 
 func TestInvalidEvents(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	// InvalidEvent
@@ -146,7 +146,7 @@ func TestInvalidEvents(t *testing.T) {
 }
 
 func TestMariadDBGTIDEVent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 	s.ServerID = 0x87654321
 
@@ -190,7 +190,7 @@ func TestMariadDBGTIDEVent(t *testing.T) {
 }
 
 func TestTableMapEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	tm := &TableMap{
@@ -245,7 +245,7 @@ func TestTableMapEvent(t *testing.T) {
 }
 
 func TestLargeTableMapEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	colLen := 256
@@ -287,7 +287,7 @@ func TestLargeTableMapEvent(t *testing.T) {
 }
 
 func TestRowsEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	/*
@@ -375,7 +375,7 @@ func TestRowsEvent(t *testing.T) {
 
 func TestHeartbeatEvent(t *testing.T) {
 	// MySQL 5.6
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 	event := NewHeartbeatEvent(f, s)
 	require.NotNil(t, event)
@@ -385,7 +385,7 @@ func TestHeartbeatEvent(t *testing.T) {
 
 func TestRotateRotateEvent(t *testing.T) {
 	// MySQL 5.6
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 	event := NewRotateEvent(f, s, 456, "mysql-bin.000123")
 	require.NotNil(t, event)
@@ -398,7 +398,7 @@ func TestRotateRotateEvent(t *testing.T) {
 
 func TestFakeRotateEvent(t *testing.T) {
 	// MySQL 5.6
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 	event := NewFakeRotateEvent(f, s, "mysql-bin.000123")
 	require.NotNil(t, event)
@@ -409,7 +409,7 @@ func TestFakeRotateEvent(t *testing.T) {
 	assert.Equal(t, "mysql-bin.000123", nextFile)
 }
 func TestLargeRowsEvent(t *testing.T) {
-	f := NewMySQL56BinlogFormat()
+	f := NewMySQLBinlogFormat()
 	s := NewFakeBinlogStream()
 
 	/*

go/mysql/binlog_event_mysql56.go → go/mysql/binlog_event_mysql.go

@@ -24,31 +24,31 @@ import (
 	"vitess.io/vitess/go/vt/vterrors"
 )
 
-// mysql56BinlogEvent wraps a raw packet buffer and provides methods to examine
+// mysqlBinlogEvent wraps a raw packet buffer and provides methods to examine
 // it by implementing BinlogEvent. Some methods are pulled in from
 // binlogEvent.
-type mysql56BinlogEvent struct {
+type mysqlBinlogEvent struct {
 	binlogEvent
 	semiSyncAckRequested bool
 }
 
-// NewMysql56BinlogEventWithSemiSyncInfo creates a BinlogEvent from given byte array
-func NewMysql56BinlogEventWithSemiSyncInfo(buf []byte, semiSyncAckRequested bool) BinlogEvent {
-	return mysql56BinlogEvent{binlogEvent: binlogEvent(buf), semiSyncAckRequested: semiSyncAckRequested}
+// NewMysqlBinlogEventWithSemiSyncInfo creates a BinlogEvent from given byte array
+func NewMysqlBinlogEventWithSemiSyncInfo(buf []byte, semiSyncAckRequested bool) BinlogEvent {
+	return mysqlBinlogEvent{binlogEvent: binlogEvent(buf), semiSyncAckRequested: semiSyncAckRequested}
 }
 
-// NewMysql56BinlogEvent creates a BinlogEvent from given byte array
-func NewMysql56BinlogEvent(buf []byte) BinlogEvent {
-	return mysql56BinlogEvent{binlogEvent: binlogEvent(buf)}
+// NewMysqlBinlogEvent creates a BinlogEvent from given byte array
+func NewMysqlBinlogEvent(buf []byte) BinlogEvent {
+	return mysqlBinlogEvent{binlogEvent: binlogEvent(buf)}
 }
 
 // IsSemiSyncAckRequested implements BinlogEvent.IsSemiSyncAckRequested().
-func (ev mysql56BinlogEvent) IsSemiSyncAckRequested() bool {
+func (ev mysqlBinlogEvent) IsSemiSyncAckRequested() bool {
 	return ev.semiSyncAckRequested
 }
 
 // IsGTID implements BinlogEvent.IsGTID().
-func (ev mysql56BinlogEvent) IsGTID() bool {
+func (ev mysqlBinlogEvent) IsGTID() bool {
 	return ev.Type() == eGTIDEvent
 }
 
@@ -60,18 +60,18 @@ func (ev mysql56BinlogEvent) IsGTID() bool {
 //	1         flags
 //	16        SID (server UUID)
 //	8         GNO (sequence number, signed int)
-func (ev mysql56BinlogEvent) GTID(f BinlogFormat) (replication.GTID, bool, error) {
+func (ev mysqlBinlogEvent) GTID(f BinlogFormat) (replication.GTID, bool, error) {
 	data := ev.Bytes()[f.HeaderLength:]
 	var sid replication.SID
 	copy(sid[:], data[1:1+16])
 	gno := int64(binary.LittleEndian.Uint64(data[1+16 : 1+16+8]))
-	return replication.Mysql56GTID{Server: sid, Sequence: gno}, false /* hasBegin */, nil
+	return replication.MysqlGTID{Server: sid, Sequence: gno}, false /* hasBegin */, nil
 }
 
 // PreviousGTIDs implements BinlogEvent.PreviousGTIDs().
-func (ev mysql56BinlogEvent) PreviousGTIDs(f BinlogFormat) (replication.Position, error) {
+func (ev mysqlBinlogEvent) PreviousGTIDs(f BinlogFormat) (replication.Position, error) {
 	data := ev.Bytes()[f.HeaderLength:]
-	set, err := replication.NewMysql56GTIDSetFromSIDBlock(data)
+	set, err := replication.NewMysqlGTIDSetFromSIDBlock(data)
 	if err != nil {
 		return replication.Position{}, err
 	}
@@ -81,7 +81,7 @@ func (ev mysql56BinlogEvent) PreviousGTIDs(f BinlogFormat) (replication.Position
 }
 
 // StripChecksum implements BinlogEvent.StripChecksum().
-func (ev mysql56BinlogEvent) StripChecksum(f BinlogFormat) (BinlogEvent, []byte, error) {
+func (ev mysqlBinlogEvent) StripChecksum(f BinlogFormat) (BinlogEvent, []byte, error) {
 	switch f.ChecksumAlgorithm {
 	case BinlogChecksumAlgOff, BinlogChecksumAlgUndef:
 		// There is no checksum.
@@ -92,7 +92,7 @@ func (ev mysql56BinlogEvent) StripChecksum(f BinlogFormat) (BinlogEvent, []byte,
 		length := len(data)
 		checksum := data[length-BinlogCRC32ChecksumLen:]
 		data = data[:length-BinlogCRC32ChecksumLen]
-		return mysql56BinlogEvent{binlogEvent: binlogEvent(data)}, checksum, nil
+		return mysqlBinlogEvent{binlogEvent: binlogEvent(data)}, checksum, nil
 	default:
 		// MySQL 5.6 does not guarantee that future checksum algorithms will be
 		// 4 bytes, so we can't support them a priori.