How to convert struct-Type into []interface{} for pgx.CopyFromSlice

For copying data into a Postgres database, I collect all my data in a slice, which I then hand over to pgx.CopyFrom. CopyFrom requires a CopyFromSource which can be achieved with CopyFromSlice to which you have to pass a function which needs a function that returns for a given index the data of that "row". That's my GetAsInterface function below.

Currently I do it by listing all my struct's members, one after the other. Is there a more convenient and less verbose way? The sequence is identical after all.

My idea is to later have the column names as annotation to my MbpImport type in order to have a more maintainable code. Curently I have to list the members two times, once when defining the type and a second time when converting it to []interface{}. I also have to keep track in another function, which returns the database column names, that those have the correct sequence. I hope an annotation will help me here as the annotation will move with every change in the struct.

type MbpImport struct {
    Partner_id           int
    Target_table         string
    Keystring            string
    Info_date            time.Time 
    Mbp                  string
    Mbp_id               int
    Client_id            string
    Status               string
    Spam_traps           int64
    Spam_traps_imp       bool
    Email_volume         int64
    Spam_clicks          int64
    Spam_clicks_imp      bool
    Inbox                int64
    Spam_filter          int64
    Spam_filter_imp      bool
    Dkim_missing         int64
    Dkim_errors          int64
    Dkim_imp             bool
    Dkim_simple_strict   int64
    Dkim_simple_relaxed  int64
}

type MbpImportRows struct {
    index map[string]map[string]map[string]int
    rows []MbpImport
}

func (data *MbpImportRows) GetAsInterface(index int) ([]interface{}, error) {
    return []interface{}{
        data.rows[index].Partner_id,
        data.rows[index].Target_table,
        data.rows[index].Keystring,
        data.rows[index].Info_date,
        data.rows[index].Mbp,
        data.rows[index].Mbp_id,
        data.rows[index].Client_id,
        data.rows[index].Status,
        data.rows[index].Spam_traps,
        data.rows[index].Spam_traps_imp,
        data.rows[index].Email_volume,
        data.rows[index].Spam_clicks,
        data.rows[index].Spam_clicks_imp,
        data.rows[index].Inbox,
        data.rows[index].Spam_filter,
        data.rows[index].Spam_filter_imp,
        data.rows[index].Dkim_missing,
        data.rows[index].Dkim_errors,
        data.rows[index].Dkim_imp,
        data.rows[index].Dkim_simple_strict,
        data.rows[index].Dkim_simple_relaxed,
    },
    nil
}

I followed the comment of @mkopriva and use reflect:

type MbpImport struct {
    Partner_id           int        `dbcol:"partner_id"`
    Target_table         string     `dbcol:"target_table"`
    Keystring            string     `dbcol:"keystring"`
    Info_date            time.Time  `dbcol:"info_date"`
    Mbp                  string     `dbcol:"mbp"`
    Mbp_id               int        `dbcol:"mbp_id"`
    Client_id            string     `dbcol:"client_id"`
    Status               string     `dbcol:"status"`
    Spam_traps           int64      `dbcol:"spam_traps"`
    Spam_traps_imp       bool       `dbcol:"spam_traps_imp"`
    Email_volume         int64      `dbcol:"email_volume"`
    Spam_clicks          int64      `dbcol:"spam_clicks"`
    Spam_clicks_imp      bool       `dbcol:"spam_clicks_imp"`
    Inbox                int64      `dbcol:"inbox"`
    Spam_filter          int64      `dbcol:"spam_filter"`
    Spam_filter_imp      bool       `dbcol:"spam_filter_imp"`
    Dkim_missing         int64      `dbcol:"dkim_missing"`
    Dkim_errors          int64      `dbcol:"dkim_errors"`
    Dkim_imp             bool       `dbcol:"dkim_imp"`
    Dkim_simple_strict   int64      `dbcol:"dkim_simple_strict"`
    Dkim_simple_relaxed  int64      `dbcol:"dkim_simple_relaxed"`
}

func (data *MbpImportRows) Columns() []string {
    s := reflect.ValueOf(new(MbpImport)).Elem()
    myStr := make([]string, s.NumField())
    for i := 0; i < s.NumField(); i++ {
        myStr[i] = s.Type().Field(i).Tag.Get("dbcol")
    }
    return myStr
}

func (data *MbpImportRows) GetAsInterface(index int) ([]interface{}, error) {
    s := reflect.ValueOf(&data.rows[index]).Elem()
    result := make([]interface{}, s.NumField())
    for i := 0; i < s.NumField(); i++ {
        result[i] = s.Field(i).Interface()
    }
    return result, nil
}