replication: support datetime less than unix timestamp zero (go-mysql-org#409)

* replication: support datetime less than unix timestamp zero

Author: amyangfei

replication/row_event.go

@@ -754,6 +754,19 @@ func decodeDatetime2(data []byte, dec uint16) (interface{}, int, error) {
 	minute := int((hms >> 6) % (1 << 6))
 	hour := int((hms >> 12))
 
+	// DATETIME encoding for nonfractional part after MySQL 5.6.4
+	// https://dev.mysql.com/doc/internals/en/date-and-time-data-type-representation.html
+	// integer value for 1970-01-01 00:00:00 is
+	// year*13+month = 25611 = 0b110010000001011
+	// day = 1 = 0b00001
+	// hour = 0 = 0b00000
+	// minute = 0 = 0b000000
+	// second = 0 = 0b000000
+	// integer value = 0b1100100000010110000100000000000000000 = 107420450816
+	if intPart < 107420450816 {
+		return formatBeforeUnixZeroTime(year, month, day, hour, minute, second, int(frac), int(dec)), n, nil
+	}
+
 	return fracTime{
 		Time: time.Date(year, time.Month(month), day, hour, minute, second, int(frac*1000), time.UTC),
 		Dec:  int(dec),

replication/row_event_test.go

@@ -730,3 +730,36 @@ func (_ *testDecodeSuite) TestJsonCompatibility(c *C) {
 	c.Assert(rows.Rows[1][2], DeepEquals, []uint8("{}"))
 	c.Assert(rows.Rows[2][2], DeepEquals, []uint8("{}"))
 }
+
+func (_ *testDecodeSuite) TestDecodeDatetime2(c *C) {
+	testcases := []struct {
+		data        []byte
+		dec         uint16
+		getFracTime bool
+		expected    string
+	}{
+		{[]byte("\xfe\xf3\xff\x7e\xfb"), 0, true, "9999-12-31 23:59:59"},
+		{[]byte("\x99\x9a\xb8\xf7\xaa"), 0, true, "2016-10-28 15:30:42"},
+		{[]byte("\x99\x02\xc2\x00\x00"), 0, true, "1970-01-01 00:00:00"},
+		{[]byte("\x80\x00\x00\x00\x00"), 0, false, "0000-00-00 00:00:00"},
+		{[]byte("\x80\x00\x02\xf1\x05"), 0, false, "0000-00-01 15:04:05"},
+		{[]byte("\x80\x03\x82\x00\x00"), 0, false, "0001-01-01 00:00:00"},
+		{[]byte("\x80\x03\x82\x00\x00\x0c"), uint16(2), false, "0001-01-01 00:00:00.12"},
+		{[]byte("\x80\x03\x82\x00\x00\x04\xd3"), uint16(4), false, "0001-01-01 00:00:00.1235"},
+		{[]byte("\x80\x03\x82\x00\x00\x01\xe2\x40"), uint16(6), false, "0001-01-01 00:00:00.123456"},
+	}
+	for _, tc := range testcases {
+		value, _, err := decodeDatetime2(tc.data, tc.dec)
+		c.Assert(err, IsNil)
+		switch t := value.(type) {
+		case fracTime:
+			c.Assert(tc.getFracTime, IsTrue)
+			c.Assert(t.String(), Equals, tc.expected)
+		case string:
+			c.Assert(tc.getFracTime, IsFalse)
+			c.Assert(t, Equals, tc.expected)
+		default:
+			c.Errorf("invalid value type: %T", value)
+		}
+	}
+}

replication/time.go

@@ -39,6 +39,17 @@ func formatZeroTime(frac int, dec int) string {
 	return s[0 : len(s)-(6-dec)]
 }
 
+func formatBeforeUnixZeroTime(year, month, day, hour, minute, second, frac, dec int) string {
+	if dec == 0 {
+		return fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second)
+	}
+
+	s := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%06d", year, month, day, hour, minute, second, frac)
+
+	// dec must < 6, if frac is 924000, but dec is 3, we must output 924 here.
+	return s[0 : len(s)-(6-dec)]
+}
+
 func init() {
 	fracTimeFormat = make([]string, 7)
 	fracTimeFormat[0] = "2006-01-02 15:04:05"