Add DATETIME type support

Signed-off-by: Alejandro García Montoro <[email protected]>

Author: agarciamontoro

_integration/go/mysql_test.go

@@ -82,7 +82,7 @@ func TestGrafana(t *testing.T) {
 				{"name", "TEXT"},
 				{"email", "TEXT"},
 				{"phone_numbers", "JSON"},
-				{"created_at", "DATETIME"},
+				{"created_at", "TIMESTAMP"},
 			},
 		},
 		{

engine_test.go

@@ -1994,7 +1994,7 @@ func TestDDL(t *testing.T) {
 	testQuery(t, e,
 		"CREATE TABLE t1(a INTEGER, b TEXT, c DATE, "+
 			"d TIMESTAMP, e VARCHAR(20), f BLOB NOT NULL, "+
-			"b1 BOOL, b2 BOOLEAN NOT NULL)",
+			"b1 BOOL, b2 BOOLEAN NOT NULL, g DATETIME",
 		[]sql.Row(nil),
 	)
 
@@ -2013,6 +2013,7 @@ func TestDDL(t *testing.T) {
 		{Name: "f", Type: sql.Blob, Source: "t1"},
 		{Name: "b1", Type: sql.Uint8, Nullable: true, Source: "t1"},
 		{Name: "b2", Type: sql.Uint8, Source: "t1"},
+		{Name: "g", Type: sql.Datetime, Nullable: true, Source: "t1"},
 	}
 
 	require.Equal(s, testTable.Schema())

sql/parse/parse_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 var fixtures = map[string]sql.Node{
-	`CREATE TABLE t1(a INTEGER, b TEXT, c DATE, d TIMESTAMP, e VARCHAR(20), f BLOB NOT NULL)`: plan.NewCreateTable(
+	`CREATE TABLE t1(a INTEGER, b TEXT, c DATE, d TIMESTAMP, e VARCHAR(20), f BLOB NOT NULL, g DATETIME)`: plan.NewCreateTable(
 		sql.UnresolvedDatabase(""),
 		"t1",
 		sql.Schema{{
@@ -40,6 +40,10 @@ var fixtures = map[string]sql.Node{
 			Name:     "f",
 			Type:     sql.Blob,
 			Nullable: false,
+		}, {
+			Name:     "g",
+			Type:     sql.Datetime,
+			Nullable: true,
 		}},
 	),
 	`DESCRIBE TABLE foo;`: plan.NewDescribe(

sql/type.go

@@ -198,6 +198,8 @@ var (
 	Timestamp timestampT
 	// Date is a date with day, month and year.
 	Date dateT
+	// Datetime is a date and a time
+	Datetime datetimeT
 	// Text is a string type.
 	Text textT
 	// Boolean is a boolean type.
@@ -258,6 +260,8 @@ func MysqlTypeToType(sql query.Type) (Type, error) {
 		// Since we can't get the size of the sqltypes.VarChar to instantiate a
 		// specific VarChar(length) type we return a Text here
 		return Text, nil
+	case sqltypes.Datetime:
+		return Datetime, nil
 	case sqltypes.Bit:
 		return Boolean, nil
 	case sqltypes.TypeJSON:
@@ -597,6 +601,65 @@ func (t dateT) Compare(a, b interface{}) (int, error) {
 	return 0, nil
 }
 
+type datetimeT struct{}
+
+// DatetimeLayout is the layout of the MySQL date format in the representation
+// Go understands.
+const DatetimeLayout = "2006-01-02 15:04:05"
+
+func (t datetimeT) String() string { return "DATETIME" }
+
+func (t datetimeT) Type() query.Type {
+	return sqltypes.Datetime
+}
+
+func (t datetimeT) SQL(v interface{}) (sqltypes.Value, error) {
+	if v == nil {
+		return sqltypes.NULL, nil
+	}
+
+	v, err := t.Convert(v)
+	if err != nil {
+		return sqltypes.Value{}, err
+	}
+
+	return sqltypes.MakeTrusted(
+		sqltypes.Datetime,
+		[]byte(v.(time.Time).Format(DatetimeLayout)),
+	), nil
+}
+
+func (t datetimeT) Convert(v interface{}) (interface{}, error) {
+	switch value := v.(type) {
+	case time.Time:
+		return value.UTC(), nil
+	case string:
+		t, err := time.Parse(DatetimeLayout, value)
+		if err != nil {
+			return nil, ErrConvertingToTime.Wrap(err, v)
+		}
+		return t.UTC(), nil
+	default:
+		ts, err := Int64.Convert(v)
+		if err != nil {
+			return nil, ErrInvalidType.New(reflect.TypeOf(v))
+		}
+
+		return time.Unix(ts.(int64), 0).UTC(), nil
+	}
+}
+
+func (t datetimeT) Compare(a, b interface{}) (int, error) {
+	av := a.(time.Time)
+	bv := b.(time.Time)
+	if av.Before(bv) {
+		return -1, nil
+	} else if av.After(bv) {
+		return 1, nil
+	}
+	return 0, nil
+}
+
 type varCharT struct {
 	length int
 }
@@ -1013,9 +1076,9 @@ func IsInteger(t Type) bool {
 	return IsSigned(t) || IsUnsigned(t)
 }
 
-// IsTime checks if t is a timestamp or date.
+// IsTime checks if t is a timestamp, date or datetime
 func IsTime(t Type) bool {
-	return t == Timestamp || t == Date
+	return t == Timestamp || t == Date || t == Datetime
 }
 
 // IsDecimal checks if t is decimal type.
@@ -1082,6 +1145,8 @@ func MySQLTypeName(t Type) string {
 	case sqltypes.Float64:
 		return "DOUBLE"
 	case sqltypes.Timestamp:
+		return "TIMESTAMP"
+	case sqltypes.Datetime:
 		return "DATETIME"
 	case sqltypes.Date:
 		return "DATE"

sql/type_test.go

@@ -236,40 +236,57 @@ func TestExtraTimestamps(t *testing.T) {
 	}
 }
 
-func TestDate(t *testing.T) {
+// Generic tests for Date and Datetime.
+// typ should be Date or Datetime
+func commonTestsDatesTypes(typ Type, layout string, t *testing.T) {
 	require := require.New(t)
 	now := time.Now().UTC()
-	v, err := Date.Convert(now)
+	v, err := typ.Convert(now)
 	require.NoError(err)
-	require.Equal(now.Format(DateLayout), v.(time.Time).Format(DateLayout))
+	require.Equal(now.Format(layout), v.(time.Time).Format(layout))
 
-	v, err = Date.Convert(now.Format(DateLayout))
+	v, err = typ.Convert(now.Format(layout))
 	require.NoError(err)
 	require.Equal(
-		now.Format(DateLayout),
-		v.(time.Time).Format(DateLayout),
+		now.Format(layout),
+		v.(time.Time).Format(layout),
 	)
 
-	v, err = Date.Convert(now.Unix())
+	v, err = typ.Convert(now.Unix())
 	require.NoError(err)
 	require.Equal(
-		now.Format(DateLayout),
-		v.(time.Time).Format(DateLayout),
+		now.Format(layout),
+		v.(time.Time).Format(layout),
 	)
 
-	sql, err := Date.SQL(now)
+	sql, err := typ.SQL(now)
 	require.NoError(err)
-	require.Equal([]byte(now.Format(DateLayout)), sql.Raw())
+	require.Equal([]byte(now.Format(layout)), sql.Raw())
+
+	after := now.Add(26 * time.Hour)
+	lt(t, typ, now, after)
+	eq(t, typ, now, now)
+	gt(t, typ, after, now)
+}
+
+func TestDate(t *testing.T) {
+	commonTestsDatesTypes(Date, DateLayout, t)
 
+	now := time.Now().UTC()
 	after := now.Add(time.Second)
 	eq(t, Date, now, after)
 	eq(t, Date, now, now)
 	eq(t, Date, after, now)
+}
 
-	after = now.Add(26 * time.Hour)
-	lt(t, Date, now, after)
-	eq(t, Date, now, now)
-	gt(t, Date, after, now)
+func TestDatetime(t *testing.T) {
+	commonTestsDatesTypes(Datetime, DatetimeLayout, t)
+
+	now := time.Now().UTC()
+	after := now.Add(time.Millisecond)
+	lt(t, Datetime, now, after)
+	eq(t, Datetime, now, now)
+	gt(t, Datetime, after, now)
 }
 
 func TestBlob(t *testing.T) {