问通过减少内存占用，高效地将数据解析为结构

EN

type ProductInfo struct {
    Name map[Locale]map[int]string
}

type Locale string

type CustomerProduct struct {
    Prs            string
    ProductId      int64
    Catalogs       []int32
    Categories     []int
    BaseProductId  *int64
    StatusCode     int
    IsActive       bool
    Common
}

type ValueMetrics struct {
    Value    string
    ClientId int64
}

type Common struct {
    Leagues []ValueMetrics
    Teams   []ValueMetrics
    ProductInfo
}

var productRows []ClientProduct
err = json.Unmarshal(byteSlice, &productRows)
if err != nil {
  return errs.Wrap(err)
}

for i := range productRows {
  var flatProduct definitions.CustomerProduct
  err = r.Convert(spn, &productRows[i], &flatProduct)
  if err != nil {
    return errs.Wrap(err)
  }

  if flatProduct.StatusCode == definitions.DONE {
    continue
  }

  // populate map here from each "flatProduct"
}

func (r *clientRepo) Convert(span log.Span, in *ClientProduct, out *definitions.CustomerProduct) error {
    commons, err := r.getCommonStruct(span, in)
    if err != nil {
        return errs.Wrap(err)
    }

    out.Common = commons
    out.Catalogs = r.convertParquetIntSliceToInt32Slice(in.Catalogs)
    out.Categories = in.Categories
    out.ProductId = in.Id
    out.IsActive = in.IsActive
    out.Prs = in.PRS
    out.StatusCode = in.StatusCode

    return nil
}

func (r *clientRepo) getCommonStruct(span log.Span, in *ClientProduct) (definitions.Common, error) {
    out := definitions.Common{}

    for _, pv := range in.PropertyValues {
        switch pv.Name {
        case "ABC":
            out.Leagues = r.concatStringSlice(pv, out.Leagues)
        case "DEF":
            out.Teams = r.concatStringSlice(pv, out.Teams)
        }
    }

    for _, opv := range in.OverriddenPropertyValues {
        switch opv.Name {
        case "CustomerName":
            if opv.Locale == "" {
                // log error
            } else {
                out.Name = r.attach(definitions.Locale(opv.Locale), opv, out.Name)
            }
        }
    }

    return out, nil
}

func (r *clientRepo) concatStringSlice(pv PropertyValue, list []definitions.ValueMetrics) []definitions.ValueMetrics {
    treeValue := definitions.ValueMetrics{Value: pv.Value, ClientId: pv.ClientId}
    if list == nil {
        return []definitions.ValueMetrics{treeValue}
    }
    return append(list, treeValue)
}

func (r *clientRepo) attach(locale definitions.Locale, opv OverriddenPropertyValue, m map[definitions.Locale]map[int]string) map[definitions.Locale]map[int]string {
    if m == nil {
        om := map[int]string{
            opv.GroupId: opv.Value,
        }
        return map[definitions.Locale]map[int]string{
            locale: om,
        }
    }

    os, ok := m[locale]
    if ok {
        os[opv.GroupId] = opv.Value
        m[locale] = os
    } else {
        m[locale] = map[int]string{
            opv.GroupId: opv.Value,
        }
    }

    return m
}

func (r *clientRepo) convertParquetIntSliceToInt32Slice(catalogs []int) []int32 {
    var out []int32
    for _, catalog := range catalogs {
        out = append(out, int32(catalog))
    }
    return out
}