Add CHAR type support

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

Author: agarciamontoro

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, g DATETIME",
+			"b1 BOOL, b2 BOOLEAN NOT NULL, g DATETIME, h CHAR(40))",
 		[]sql.Row(nil),
 	)
 
@@ -2014,6 +2014,7 @@ func TestDDL(t *testing.T) {
 		{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"},
+		{Name: "h", Type: sql.Text, 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, g DATETIME)`: plan.NewCreateTable(
+	`CREATE TABLE t1(a INTEGER, b TEXT, c DATE, d TIMESTAMP, e VARCHAR(20), f BLOB NOT NULL, g DATETIME, h CHAR(40))`: plan.NewCreateTable(
 		sql.UnresolvedDatabase(""),
 		"t1",
 		sql.Schema{{
@@ -44,6 +44,10 @@ var fixtures = map[string]sql.Node{
 			Name:     "g",
 			Type:     sql.Datetime,
 			Nullable: true,
+		}, {
+			Name:     "h",
+			Type:     sql.Text,
+			Nullable: true,
 		}},
 	),
 	`DESCRIBE TABLE foo;`: plan.NewDescribe(

sql/type.go

@@ -27,7 +27,10 @@ var (
 	// ErrConvertingToTime is thrown when a value cannot be converted to a Time
 	ErrConvertingToTime = errors.NewKind("value %q can't be converted to time.Time")
 
-	// ErrVarCharTruncation is thrown when a value is textually longer than the destination capacity
+	// ErrCharTruncation is thrown when a Char value is textually longer than the destination capacity
+	ErrCharTruncation = errors.NewKind("string value of %q is longer than destination capacity %d")
+
+	// ErrVarCharTruncation is thrown when a VarChar value is textually longer than the destination capacity
 	ErrVarCharTruncation = errors.NewKind("string value of %q is longer than destination capacity %d")
 
 	// ErrValueNotNil is thrown when a value that was expected to be nil, is not
@@ -220,6 +223,11 @@ func Array(underlying Type) Type {
 	return arrayT{underlying}
 }
 
+// Char returns a new Char type of the given length.
+func Char(length int) Type {
+	return charT{length: length}
+}
+
 // VarChar returns a new VarChar type of the given length.
 func VarChar(length int) Type {
 	return varCharT{length: length}
@@ -256,6 +264,10 @@ func MysqlTypeToType(sql query.Type) (Type, error) {
 		return Date, nil
 	case sqltypes.Text:
 		return Text, nil
+	case sqltypes.Char:
+		// Since we can't get the size of the sqltypes.Char to instantiate a
+		// specific Char(length) type we return a Text here
+		return Text, nil
 	case sqltypes.VarChar:
 		// Since we can't get the size of the sqltypes.VarChar to instantiate a
 		// specific VarChar(length) type we return a Text here
@@ -660,6 +672,50 @@ func (t datetimeT) Compare(a, b interface{}) (int, error) {
 	return 0, nil
 }
 
+type charT struct {
+	length int
+}
+
+func (t charT) Capacity() int { return t.length }
+
+func (t charT) String() string { return fmt.Sprintf("CHAR(%d)", t.length) }
+
+func (t charT) Type() query.Type {
+	return sqltypes.Char
+}
+
+func (t charT) SQL(v interface{}) (sqltypes.Value, error) {
+	if v == nil {
+		return sqltypes.MakeTrusted(sqltypes.Char, nil), nil
+	}
+
+	v, err := t.Convert(v)
+	if err != nil {
+		return sqltypes.Value{}, err
+	}
+
+	return sqltypes.MakeTrusted(sqltypes.Char, []byte(v.(string))), nil
+}
+
+// Converts any value that can be casted to a string
+func (t charT) Convert(v interface{}) (interface{}, error) {
+	val, err := cast.ToStringE(v)
+	if err != nil {
+		return nil, ErrConvertToSQL.New(t)
+	}
+
+	if len(val) > t.length {
+		return nil, ErrCharTruncation.New(val, t.length)
+	}
+	return val, nil
+}
+
+// Compares two strings lexicographically
+func (t charT) Compare(a interface{}, b interface{}) (int, error) {
+	return strings.Compare(a.(string), b.(string)), nil
+}
+
+
 type varCharT struct {
 	length int
 }
@@ -1088,7 +1144,13 @@ func IsDecimal(t Type) bool {
 
 // IsText checks if t is a text type.
 func IsText(t Type) bool {
-	return t == Text || t == Blob || t == JSON || IsVarChar(t)
+	return t == Text || t == Blob || t == JSON || IsVarChar(t) || IsChar(t)
+}
+
+// IsChar checks if t is a Char type.
+func IsChar(t Type) bool {
+	_, ok := t.(charT)
+	return ok
 }
 
 // IsVarChar checks if t is a varchar type.
@@ -1150,6 +1212,8 @@ func MySQLTypeName(t Type) string {
 		return "DATETIME"
 	case sqltypes.Date:
 		return "DATE"
+	case sqltypes.Char:
+		return "CHAR"
 	case sqltypes.VarChar:
 		return "VARCHAR"
 	case sqltypes.Text:

sql/type_test.go

@@ -342,20 +342,22 @@ func TestTuple(t *testing.T) {
 	gt(t, typ, []interface{}{1, 2, 4}, []interface{}{1, 2, 3})
 }
 
-func TestVarChar(t *testing.T) {
-	typ := VarChar(3)
-	require.True(t, IsVarChar(typ))
+// Generic test for Char and VarChar types.
+// genType should be sql.Char or sql.VarChar
+func testCharTypes(genType func(int) Type, checkType func(Type) bool, t *testing.T) {
+	typ := genType(3)
+	require.True(t, checkType(typ))
 	require.True(t, IsText(typ))
 	convert(t, typ, "foo", "foo")
 	fooByte := []byte{'f', 'o', 'o'}
 	convert(t, typ, fooByte, "foo")
 
-	typ = VarChar(1)
+	typ = genType(1)
 	convertErr(t, typ, "foo")
 	convertErr(t, typ, fooByte)
 	convertErr(t, typ, 123)
 
-	typ = VarChar(10)
+	typ = genType(10)
 	convert(t, typ, 123, "123")
 	convertErr(t, typ, 1234567890123)
 
@@ -370,10 +372,18 @@ func TestVarChar(t *testing.T) {
 	require.NoError(t, err)
 
 	convert(t, typ, text, "abc")
-	typ1 := VarChar(1)
+	typ1 := genType(1)
 	convertErr(t, typ1, text)
 }
 
+func TestChar(t *testing.T) {
+	testCharTypes(Char, IsChar, t)
+}
+
+func TestVarChar(t *testing.T) {
+	testCharTypes(VarChar, IsVarChar, t)
+}
+
 func TestArray(t *testing.T) {
 	require := require.New(t)