Gorm returns Scanner error on custom string type

I wrote the below entity:

type DataCategory string

const (
	DataCategory1 DataCategory = "Category1"
	DataCategory2 DataCategory = "Category2"
)

type Data struct {
	Name            string         `json:"name"`
	Categories      []DataCategory `json:"category" gorm:"type:text[]"`
}

I manually created a row in the database and filled the categories array type with Category1 and Category2.

But this gives the below error when reading the data:

sql: Scan error on column index 19, name "category": unsupported Scan, storing driver.Value type string into type *[]DataCategory

Example Value method:

func (s DataCategorySlice) Value() (driver.Value, error) {
	if s == nil {
		return nil, nil
	}
	if len(s) == 0 {
		return "{}", nil
	}

	v := []string{}
	for _, dc := range s {
		v = append(v, string(dc))
	}
	result := fmt.Sprintf("{%s}", strings.Join(v, ","))
	return result, nil
}

The following example assumes that you're using PostgreSQL as the RDBMS and that the DataCategory values do not contain commas nor unescaped single quotes.

// declare the custom type
type DataCategorySlice []DataCategory

// implement driver.Valuer to encode the value into the
// correct format that is accepted by the target RDBMS
func (s DataCategorySlice) Value() (driver.Value, error) {
    if s == nil {
        return nil, nil
    }
    if len(s) == 0 {
        return []byte(`{}`), nil
    }

    v := []byte(`{`)
    for i := range s {
        v = append(v, s[i]...)
        v = append(v, ',')
    }
    v[len(v)-1] = '}' // replace last comma with closing brace
    return v, nil
}

// implement scanner to decode the raw source
// value as retrieved from the database
func (s *DataCategorySlice) Scan(src any) error {
    var data []byte
    switch v := src.(type) {
    case []byte:
        data = v
    case string:
        data = []byte(v)
    case nil:
        return nil
    default:
        return fmt.Errorf("unsupported type: %T", src)
    }
    if len(data) == 0 {
        return nil
    }
    data = data[1:len(data)-1] // remove surrounding braces
    for _, v := range bytes.Split(data, []byte{','}) {
        *s = append(*s, DataCategory(v))
    }
    return nil
}

Alternatively, if returning []byte from Value() (driver.Value, error) doesn't work, e.g. it results in "ERROR: malformed array literal: <hex representation of the field's value> (SQLSTATE 22P02)", then you can try using string as the return type instead.

_{example from @kozhioyrin}

// implement driver.Valuer to encode the value into the
// correct format that is accepted by the target RDBMS
func (s DataCategorySlice) Value() (driver.Value, error) {
	if s == nil {
		return nil, nil
	}
	if len(s) == 0 {
		return "{}", nil
	}

	v := []string{}
	for _, dc := range s {
		v = append(v, string(dc))
	}
	result := fmt.Sprintf("{%s}", strings.Join(v, ","))
	return result, nil
}