स्ट्रक्चर्स के एक स्लाइस पर लूप करें और वैल्यू अपडेट करें

मुझे स्रोत ए से डेटा मिल रहा है और इसे structs के टुकड़े में संग्रहीत कर रहा है:

type ProductPrice struct {
    Type          string
    Sku           string
    UnitPrice     string
    PriceList     string
    standardPrice string
    specialPrice  string
    specialStart  string
    specialEnd    string
    pricingUnit   string
    categoryCode  string
    isOnSpecial   bool
}

func getProductPricesFromDatabase(instance string) []ProductPrice {
    rows, err := myDBConnection.Query(// My query here)

    if err != nil {
        log.Fatal("There was an issue with the query for product price: ", err)
    }

    defer rows.Close()

    var productPrices []ProductPrice

    for rows.Next() {
        var product = ProductPrice{}
        err := rows.Scan(
            &product.Type,
            &product.Sku,
            &product.standardPrice,
            &product.specialPrice,
            &product.specialStart,
            &product.specialEnd,
            &product.pricingUnit,
            &product.PriceList,
            &product.categoryCode,
        )
        if err != nil {
            log.Fatal("product price scan error: ", err)
        }

        productPrices = append(productPrices, product)
    }

    return productPrices
}

मैं फिर स्रोत बी से कुछ डेटा प्राप्त कर रहा हूं और इसे structs के टुकड़े में संग्रहीत कर रहा हूं:

type ContractProductPrice struct {
    CustID                 string
    PriceBy                string
    AppliesTo              string
    PriceList              string
    StartDate              string
    EndDate                string
    PricingAdjustmentType  string
    PricingAdjustmentValue string
    UseLowest              string
}

func getContractProductPricesFromDatabase(instance string) []ContractProductPrice {
    rows, err := myDBConnection.Query(// My query here)

    if err != nil {
        log.Fatal("There was an issue with the query for contract product price: ", err)
    }

    defer rows.Close()

    var contractProductPrices []ContractProductPrice

    for rows.Next() {
        var product = ContractProductPrice{}
        err := rows.Scan(
            &product.CustID,
            &product.PriceBy,
            &product.AppliesTo,
            &product.PriceList,
            &product.StartDate,
            &product.EndDate,
            &product.PricingAdjustmentType,
            &product.PricingAdjustmentValue,
            &product.UseLowest,
        )
        if err != nil {
            log.Fatal("contract product price scan error: ", err)
        }
        contractProductPrices = append(contractProductPrices, product)
    }

    return contractProductPrices
}

स्रोत बी से डेटा प्राप्त करने के बाद, मैं स्रोत बी से कुछ डेटा के साथ स्रोत ए से structs के टुकड़े को अद्यतन करना चाहता हूँ।

productPrices := getProductPricesFromDatabase(instance)
contractProductPrices := getContractProductPricesFromDatabase(instance)

processedProductPrices := processProductPricesFromDatabase(productPrices, contractProductPrices)

func processProductPricesFromDatabase(productPrices []ProductPrice, contractProductPrices []ContractProductPrice) []ProductPrice {
    // Loop over contact prices and update relevant product prices
    for _, contractPrice := range contractProductPrices {
        for _, product := range productPrices {
            if contractPrice.AppliesTo == product.Sku {
                product.UnitPrice = contractPrice.PricingAdjustmentValue
            }
        }
    }

    return productPrices
}

हालांकि, इसके चलने के बाद, processedProductPrices में यूनिट की कीमतें अभी भी खाली हैं।

मेरी खोज से, मैं समझता हूं कि मुद्दा क्या है; जाओ मूल्य से गुजरता है और इसलिए मैं मूल स्मृति पता अपडेट नहीं कर रहा हूं और इसलिए मान नहीं बदल रहे हैं। हालाँकि, मुझे समझ नहीं आ रहा है कि मुझे इसे ठीक करने के लिए क्या बदलने की आवश्यकता है, क्योंकि मैं संख्या / तार आदि के एक सरल उदाहरण के बजाय संरचना के एक टुकड़े के साथ काम कर रहा हूँ।

मैं productPrices को कैसे अपडेट कर सकता हूं ताकि जब मैं इसे वापस कर दूं, processedProductPrices, स्ट्रक्चर्स के अपडेटेड productPrices स्लाइस के बराबर हो?