Where as interface

entity_schema.go

@@ -691,10 +691,10 @@ func (e *entitySchema) buildTableFields(t reflect.Type, registry *registry,
 				e.buildStructField(attributes, registry, schemaTags)
 			} else if fType.Implements(reflect.TypeOf((*EnumValues)(nil)).Elem()) {
 				definition := reflect.New(fType).Interface().(EnumValues).EnumValues()
-				e.buildEnumField(attributes, definition)
+				e.buildEnumField(attributes, fType.String(), definition)
 			} else if k == "slice" && fType.Elem().Implements(reflect.TypeOf((*EnumValues)(nil)).Elem()) {
 				definition := reflect.New(fType.Elem()).Interface().(EnumValues).EnumValues()
-				e.buildStringSliceField(attributes, definition)
+				e.buildStringSliceField(fType.String(), attributes, definition)
 			} else if fType.Implements(reflect.TypeOf((*referenceInterface)(nil)).Elem()) {
 				e.buildReferenceField(attributes)
 				if attributes.Tags["cached"] == "true" {
@@ -907,14 +907,14 @@ func (e *entitySchema) buildIntPointerField(attributes schemaFieldAttributes, mi
 	}
 }
 
-func (e *entitySchema) buildEnumField(attributes schemaFieldAttributes, definition any) {
+func (e *entitySchema) buildEnumField(attributes schemaFieldAttributes, enumName string, definition any) {
 	if attributes.IsArray {
 		attributes.Fields.stringsEnumsArray = append(attributes.Fields.stringsEnumsArray, attributes.Index)
 	} else {
 		attributes.Fields.stringsEnums = append(attributes.Fields.stringsEnums, attributes.Index)
 	}
 	for i, columnName := range attributes.GetColumnNames() {
-		def := initEnumDefinition(definition, attributes.Tags["required"] == "true")
+		def := initEnumDefinition(enumName, definition, attributes.Tags["required"] == "true")
 		if i == 0 {
 			if attributes.IsArray {
 				attributes.Fields.enumsArray = append(attributes.Fields.enumsArray, def)
@@ -997,14 +997,14 @@ func (e *entitySchema) buildBytesField(attributes schemaFieldAttributes) {
 	}
 }
 
-func (e *entitySchema) buildStringSliceField(attributes schemaFieldAttributes, definition any) {
+func (e *entitySchema) buildStringSliceField(enumName string, attributes schemaFieldAttributes, definition any) {
 	if attributes.IsArray {
 		attributes.Fields.sliceStringsSetsArray = append(attributes.Fields.sliceStringsSetsArray, attributes.Index)
 	} else {
 		attributes.Fields.sliceStringsSets = append(attributes.Fields.sliceStringsSets, attributes.Index)
 	}
 	for i, columnName := range attributes.GetColumnNames() {
-		def := initEnumDefinition(definition, attributes.Tags["required"] == "true")
+		def := initEnumDefinition(enumName, definition, attributes.Tags["required"] == "true")
 		if i == 0 {
 			if attributes.IsArray {
 				attributes.Fields.setsArray = append(attributes.Fields.setsArray, def)

enum.go

@@ -29,11 +29,11 @@ func (d *enumDefinition) Index(value string) int {
 	return d.mapping[value]
 }
 
-func initEnumDefinition(def any, required bool) *enumDefinition {
+func initEnumDefinition(name string, def any, required bool) *enumDefinition {
 	enum := &enumDefinition{required: required}
 	e := reflect.ValueOf(def)
 	enum.mapping = make(map[string]int)
-	enum.name = reflect.TypeOf(def).Name()
+	enum.name = name
 	enum.fields = make([]string, 0)
 	for i := 0; i < e.Type().NumField(); i++ {
 		name := e.Field(i).String()

schema.go

@@ -568,13 +568,13 @@ func checkColumn(engine Engine, schema *entitySchema, field *reflect.StructField
 				definition, addNotNullIfNotSet, defaultValue = handleInt("uint64", attributes, !isRequired)
 			} else if fieldType.Implements(reflect.TypeOf((*EnumValues)(nil)).Elem()) {
 				def := reflect.New(fieldType).Interface().(EnumValues)
-				definition, addNotNullIfNotSet, addDefaultNullIfNullable, defaultValue, err = handleSetEnum("enum", schema, def, !isRequired)
+				definition, addNotNullIfNotSet, addDefaultNullIfNullable, defaultValue, err = handleSetEnum("enum", fieldType.String(), schema, def, !isRequired)
 				if err != nil {
 					return nil, err
 				}
 			} else if kind == "slice" && fieldType.Elem().Implements(reflect.TypeOf((*EnumValues)(nil)).Elem()) {
 				def := reflect.New(fieldType.Elem()).Interface().(EnumValues)
-				definition, addNotNullIfNotSet, addDefaultNullIfNullable, defaultValue, err = handleSetEnum("set", schema, def, !isRequired)
+				definition, addNotNullIfNotSet, addDefaultNullIfNullable, defaultValue, err = handleSetEnum("set", fieldType.String(), schema, def, !isRequired)
 			} else {
 				return nil, fmt.Errorf("field type %s is not supported, consider adding  tag `ignore`", field.Type.String())
 			}
@@ -666,8 +666,8 @@ func handleString(schema *entitySchema, attributes map[string]string, nullable b
 	}
 	return definition, !nullable, addDefaultNullIfNullable, defaultValue, nil
 }
-func handleSetEnum(fieldType string, schema *entitySchema, def EnumValues, nullable bool) (string, bool, bool, string, error) {
-	enumDef := initEnumDefinition(def.EnumValues(), !nullable)
+func handleSetEnum(fieldType, enumName string, schema *entitySchema, def EnumValues, nullable bool) (string, bool, bool, string, error) {
+	enumDef := initEnumDefinition(enumName, def.EnumValues(), !nullable)
 	if len(enumDef.GetFields()) == 0 {
 		return "", false, false, "", errors.New("empty enum not allowed")
 	}