Moved enum type

Author: zachmu

server/handler_test.go

@@ -620,7 +620,7 @@ func TestSchemaToFields(t *testing.T) {
 
 		// Set and Enum Types
 		{Name: "set", Type: types.MustCreateSetType([]string{"one", "two", "three", "four"}, sql.Collation_Default)},
-		{Name: "enum", Type: sql.MustCreateEnumType([]string{"one", "two", "three", "four"}, sql.Collation_Default)},
+		{Name: "enum", Type: types.MustCreateEnumType([]string{"one", "two", "three", "four"}, sql.Collation_Default)},
 	}
 
 	expected := []*query.Field{

sql/core.go

@@ -281,9 +281,9 @@ func TypesEqual(a, b Type) bool {
 	// Some types cannot be compared structurally as they contain non-comparable types (such as slices), so we handle
 	// those separately.
 	switch at := a.(type) {
-	case EnumType_:
+	case types.EnumType_:
 		aEnumType := at
-		bEnumType := b.(EnumType_)
+		bEnumType := b.(types.EnumType_)
 		if len(aEnumType.indexToVal) != len(bEnumType.indexToVal) {
 			return false
 		}

sql/expression/in_test.go

@@ -28,7 +28,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/expression/function"
 )
 
-var testEnumType = sql.MustCreateEnumType([]string{"", "one", "two"}, sql.Collation_Default)
+var testEnumType = types.MustCreateEnumType([]string{"", "one", "two"}, sql.Collation_Default)
 
 var testSetType = types.MustCreateSetType([]string{"", "one", "two"}, sql.Collation_Default)
 

sql/information_schema/information_schema.go

@@ -219,7 +219,7 @@ func init() {
 	char32_utf8_bin := types.MustCreateString(sqltypes.Char, 32, sql.Collation_utf8_bin)
 	char64_utf8_bin := types.MustCreateString(sqltypes.Char, 64, sql.Collation_utf8_bin)
 	char255_ascii_general_ci := types.MustCreateString(sqltypes.Char, 255, sql.Collation_ascii_general_ci)
-	enum_N_Y_utf8_general_ci := sql.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
+	enum_N_Y_utf8_general_ci := types.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
 
 	// Column Templates
 	char32_utf8_bin_not_null_default_empty := &sql.Column{

sql/mysql_db/db_table.go

@@ -172,7 +172,7 @@ func init() {
 	// Types
 	char32_utf8_bin := types.MustCreateString(sqltypes.Char, 32, sql.Collation_utf8_bin)
 	char255_ascii_general_ci := types.MustCreateString(sqltypes.Char, 255, sql.Collation_ascii_general_ci)
-	enum_N_Y_utf8_general_ci := sql.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
+	enum_N_Y_utf8_general_ci := types.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
 
 	// Column Templates
 	char32_utf8_bin_not_null_default_empty := &sql.Column{

sql/mysql_db/role_edges_table.go

@@ -113,8 +113,8 @@ func init() {
 	char32_utf8_bin := types.MustCreateString(sqltypes.Char, 32, sql.Collation_utf8_bin)
 	char64_utf8_bin := types.MustCreateString(sqltypes.Char, 64, sql.Collation_utf8_bin)
 	char255_ascii_general_ci := types.MustCreateString(sqltypes.Char, 255, sql.Collation_ascii_general_ci)
-	enum_ANY_X509_SPECIFIED_utf8_general_ci := sql.MustCreateEnumType([]string{"", "ANY", "X509", "SPECIFIED"}, sql.Collation_utf8_general_ci)
-	enum_N_Y_utf8_general_ci := sql.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
+	enum_ANY_X509_SPECIFIED_utf8_general_ci := types.MustCreateEnumType([]string{"", "ANY", "X509", "SPECIFIED"}, sql.Collation_utf8_general_ci)
+	enum_N_Y_utf8_general_ci := types.MustCreateEnumType([]string{"N", "Y"}, sql.Collation_utf8_general_ci)
 	text_utf8_bin := types.CreateText(sql.Collation_utf8_bin)
 
 	// Column Templates

sql/mysql_db/user_table.go

@@ -161,7 +161,7 @@ func TestGroupByAggregationGrouping(t *testing.T) {
 
 func TestGroupByCollations(t *testing.T) {
 	tString := types.MustCreateString(query.Type_VARCHAR, 255, sql.Collation_utf8mb4_0900_ai_ci)
-	tEnum := sql.MustCreateEnumType([]string{"col1_1", "col1_2"}, sql.Collation_utf8mb4_0900_ai_ci)
+	tEnum := types.MustCreateEnumType([]string{"col1_1", "col1_2"}, sql.Collation_utf8mb4_0900_ai_ci)
 	tSet := types.MustCreateSetType([]string{"col1_1", "col1_2"}, sql.Collation_utf8mb4_0900_ai_ci)
 
 	var testCases = []struct {

sql/plan/group_by_test.go

@@ -134,6 +134,23 @@ type SetType interface {
 	Values() []string
 }
 
+// EnumType represents the ENUM type.
+// https://dev.mysql.com/doc/refman/8.0/en/enum.html
+// The type of the returned value is uint16.
+type EnumType interface {
+	Type
+	// At returns the string at the given index, as well if the string was found.
+	At(index int) (string, bool)
+	CharacterSet() CharacterSetID
+	Collation() CollationID
+	// IndexOf returns the index of the given string. If the string was not found, then this returns -1.
+	IndexOf(v string) int
+	// NumberOfElements returns the number of enumerations.
+	NumberOfElements() uint16
+	// Values returns the elements, in order, of every enumeration.
+	Values() []string
+}
+
 type Type2 interface {
 	Type
 
@@ -479,7 +496,7 @@ func ColumnTypeToType(ct *sqlparser.ColumnType) (Type, error) {
 		if err != nil {
 			return nil, err
 		}
-		return CreateEnumType(ct.EnumValues, collation)
+		return types.CreateEnumType(ct.EnumValues, collation)
 	case "set":
 		collation, err := ParseCollation(&ct.Charset, &ct.Collate, ct.BinaryCollate)
 		if err != nil {

sql/type.go

@@ -1,4 +1,4 @@
-// Copyright 2020-2021 Dolthub, Inc.
+// Copyright 2022 Dolthub, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package sql
+package types
 
 import (
 	"fmt"
@@ -21,62 +21,40 @@ import (
 	"strings"
 	"unicode/utf8"
 
-	"github.com/dolthub/go-mysql-server/sql/types"
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/encodings"
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/dolthub/vitess/go/vt/proto/query"
 	"github.com/shopspring/decimal"
 	"gopkg.in/src-d/go-errors.v1"
-
-	"github.com/dolthub/go-mysql-server/sql/encodings"
 )
 
 const (
 	// EnumTypeMinElements returns the minimum number of enumerations for the Enum type.
 	EnumTypeMinElements = 1
 	// EnumTypeMaxElements returns the maximum number of enumerations for the Enum type.
 	EnumTypeMaxElements = 65535
-	/// An ENUM column can have a maximum of 65,535 distinct elements.
+	// / An ENUM column can have a maximum of 65,535 distinct elements.
 )
 
 var (
-	ErrConvertingToEnum  = errors.NewKind("value %v is not valid for this Enum")
-	ErrUnmarshallingEnum = errors.NewKind("value %v is not a marshalled value for this Enum")
-	ErrTemporaryEnum     = errors.NewKind("attempted to use temporary enum")
+	ErrConvertingToEnum = errors.NewKind("value %v is not valid for this Enum")
 
 	enumValueType = reflect.TypeOf(uint16(0))
 )
 
-// Comments with three slashes were taken directly from the linked documentation.
-
-// EnumType represents the ENUM type.
-// https://dev.mysql.com/doc/refman/8.0/en/enum.html
-// The type of the returned value is uint16.
-type EnumType interface {
-	Type
-	// At returns the string at the given index, as well if the string was found.
-	At(index int) (string, bool)
-	CharacterSet() CharacterSetID
-	Collation() CollationID
-	// IndexOf returns the index of the given string. If the string was not found, then this returns -1.
-	IndexOf(v string) int
-	// NumberOfElements returns the number of enumerations.
-	NumberOfElements() uint16
-	// Values returns the elements, in order, of every enumeration.
-	Values() []string
-}
-
 type EnumType_ struct {
-	collation             CollationID
+	collation             sql.CollationID
 	hashedValToIndex      map[uint64]int
 	indexToVal            []string
 	maxResponseByteLength uint32
 }
 
-var _ EnumType = EnumType_{}
-var _ TypeWithCollation = EnumType_{}
+var _ sql.EnumType = EnumType_{}
+var _ sql.TypeWithCollation = EnumType_{}
 
 // CreateEnumType creates a EnumType.
-func CreateEnumType(values []string, collation CollationID) (EnumType, error) {
+func CreateEnumType(values []string, collation sql.CollationID) (sql.EnumType, error) {
 	if len(values) < EnumTypeMinElements {
 		return nil, fmt.Errorf("number of values may not be zero")
 	}
@@ -90,7 +68,7 @@ func CreateEnumType(values []string, collation CollationID) (EnumType, error) {
 	maxCharLength := collation.Collation().CharacterSet.MaxLength()
 	valToIndex := make(map[uint64]int)
 	for i, value := range values {
-		if !collation.Equals(Collation_binary) {
+		if !collation.Equals(sql.Collation_binary) {
 			// Trailing spaces are automatically deleted from ENUM member values in the table definition when a table
 			// is created, unless the binary charset and collation is in use
 			value = strings.TrimRight(value, " ")
@@ -120,7 +98,7 @@ func CreateEnumType(values []string, collation CollationID) (EnumType, error) {
 }
 
 // MustCreateEnumType is the same as CreateEnumType except it panics on errors.
-func MustCreateEnumType(values []string, collation CollationID) EnumType {
+func MustCreateEnumType(values []string, collation sql.CollationID) sql.EnumType {
 	et, err := CreateEnumType(values, collation)
 	if err != nil {
 		panic(err)
@@ -135,7 +113,7 @@ func (t EnumType_) MaxTextResponseByteLength() uint32 {
 
 // Compare implements Type interface.
 func (t EnumType_) Compare(a interface{}, b interface{}) (int, error) {
-	if hasNulls, res := CompareNulls(a, b); hasNulls {
+	if hasNulls, res := sql.CompareNulls(a, b); hasNulls {
 		return res, nil
 	}
 
@@ -230,7 +208,7 @@ func (t EnumType_) MustConvert(v interface{}) interface{} {
 }
 
 // Equals implements the Type interface.
-func (t EnumType_) Equals(otherType Type) bool {
+func (t EnumType_) Equals(otherType sql.Type) bool {
 	if ot, ok := otherType.(EnumType_); ok && t.collation.Equals(ot.collation) && len(t.indexToVal) == len(ot.indexToVal) {
 		for i, val := range t.indexToVal {
 			if ot.indexToVal[i] != val {
@@ -243,12 +221,12 @@ func (t EnumType_) Equals(otherType Type) bool {
 }
 
 // Promote implements the Type interface.
-func (t EnumType_) Promote() Type {
+func (t EnumType_) Promote() sql.Type {
 	return t
 }
 
 // SQL implements Type interface.
-func (t EnumType_) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value, error) {
+func (t EnumType_) SQL(ctx *sql.Context, dest []byte, v interface{}) (sqltypes.Value, error) {
 	if v == nil {
 		return sqltypes.NULL, nil
 	}
@@ -259,25 +237,25 @@ func (t EnumType_) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value
 	value, _ := t.At(int(convertedValue.(uint16)))
 
 	resultCharset := ctx.GetCharacterSetResults()
-	if resultCharset == CharacterSet_Unspecified || resultCharset == CharacterSet_binary {
+	if resultCharset == sql.CharacterSet_Unspecified || resultCharset == sql.CharacterSet_binary {
 		resultCharset = t.collation.CharacterSet()
 	}
 	encodedBytes, ok := resultCharset.Encoder().Encode(encodings.StringToBytes(value))
 	if !ok {
-		return sqltypes.Value{}, ErrCharSetFailedToEncode.New(t.collation.CharacterSet().Name())
+		return sqltypes.Value{}, sql.ErrCharSetFailedToEncode.New(t.collation.CharacterSet().Name())
 	}
-	val := types.AppendAndSliceBytes(dest, encodedBytes)
+	val := AppendAndSliceBytes(dest, encodedBytes)
 
 	return sqltypes.MakeTrusted(sqltypes.Enum, val), nil
 }
 
 // String implements Type interface.
 func (t EnumType_) String() string {
 	s := fmt.Sprintf("enum('%v')", strings.Join(t.indexToVal, `','`))
-	if t.CharacterSet() != Collation_Default.CharacterSet() {
+	if t.CharacterSet() != sql.Collation_Default.CharacterSet() {
 		s += " CHARACTER SET " + t.CharacterSet().String()
 	}
-	if !t.collation.Equals(Collation_Default) {
+	if !t.collation.Equals(sql.Collation_Default) {
 		s += " COLLATE " + t.collation.String()
 	}
 	return s
@@ -295,13 +273,13 @@ func (t EnumType_) ValueType() reflect.Type {
 
 // Zero implements Type interface.
 func (t EnumType_) Zero() interface{} {
-	/// If an ENUM column is declared NOT NULL, its default value is the first element of the list of permitted values.
+	// / If an ENUM column is declared NOT NULL, its default value is the first element of the list of permitted values.
 	return uint16(1)
 }
 
 // At implements EnumType interface.
 func (t EnumType_) At(index int) (string, bool) {
-	/// The elements listed in the column specification are assigned index numbers, beginning with 1.
+	// / The elements listed in the column specification are assigned index numbers, beginning with 1.
 	index -= 1
 	if index < 0 || index >= len(t.indexToVal) {
 		return "", false
@@ -310,12 +288,12 @@ func (t EnumType_) At(index int) (string, bool) {
 }
 
 // CharacterSet implements EnumType interface.
-func (t EnumType_) CharacterSet() CharacterSetID {
+func (t EnumType_) CharacterSet() sql.CharacterSetID {
 	return t.collation.CharacterSet()
 }
 
 // Collation implements EnumType interface.
-func (t EnumType_) Collation() CollationID {
+func (t EnumType_) Collation() sql.CollationID {
 	return t.collation
 }
 
@@ -327,8 +305,8 @@ func (t EnumType_) IndexOf(v string) int {
 			return index
 		}
 	}
-	/// ENUM('0','1','2')
-	/// If you store '3', it does not match any enumeration value, so it is treated as an index and becomes '2' (the value with index 3).
+	// / ENUM('0','1','2')
+	// / If you store '3', it does not match any enumeration value, so it is treated as an index and becomes '2' (the value with index 3).
 	if parsedIndex, err := strconv.ParseInt(v, 10, 32); err == nil {
 		if _, ok := t.At(int(parsedIndex)); ok {
 			return int(parsedIndex)
@@ -350,6 +328,6 @@ func (t EnumType_) Values() []string {
 }
 
 // WithNewCollation implements TypeWithCollation interface.
-func (t EnumType_) WithNewCollation(collation CollationID) (Type, error) {
+func (t EnumType_) WithNewCollation(collation sql.CollationID) (sql.Type, error) {
 	return CreateEnumType(t.indexToVal, collation)
 }