Często aktualizuj produkty

Interfejs Products API umożliwia częściowe aktualizowanie istniejących produktów. Jest to idealne rozwiązanie w przypadku często zmieniających się danych, takich jak cena i dostępność, ponieważ pozwala uniknąć ponownego przesyłania całego produktu w przypadku niewielkiej zmiany. Należy jednak regularnie ponownie wstawiać produkty, aby mieć pewność, że wszystkie dane produktów są zsynchronizowane.

Z tego przewodnika dowiesz się, jak zaktualizować produkty za pomocą metody productinputs.patch.

Wymagania wstępne

Zanim zaktualizujesz produkt, musisz mieć:

• dotychczasowy produkt, który chcesz zaktualizować; Aby dowiedzieć się, jak tworzyć produkty, zapoznaj się z przewodnikiem Dodawanie produktów i zarządzanie nimi.
• name źródła danych, do którego należy dane wejściowe produktu (np. accounts/12345/dataSources/67890). Aby dowiedzieć się, jak to znaleźć, zapoznaj się z przewodnikiem Zarządzanie źródłami danych API na potrzeby przesyłania produktów.

Aktualizowanie szczegółowych informacji o konkretnych produktach

Aby zmienić kilka szczegółów produktu, np. cenę lub dostępność, bez ponownego przesyłania wszystkich informacji, użyj metody productInputs.patch.

W parametrze updateMask możesz określić, które pola chcesz zmienić. updateMask to lista pól rozdzielona przecinkami, które chcesz zaktualizować. Metoda patch działa w ten sposób:

• Pola w updateMask i treści: te pola są aktualizowane o nowe wartości.
• Pola w updateMask, których nie ma w treści: te pola są usuwane z danych wejściowych produktu.
• Pola, których nie ma w updateMask: te pola pozostają bez zmian.
• Pominięto parametr updateMask: zaktualizowane zostaną wszystkie pola podane w treści żądania. Pola, które nie zostały podane w treści żądania, nie są usuwane z danych wejściowych produktu.

Oto przykład danych o produkcie przed aktualizacją:

{
  "name": "accounts/{ACCOUNT_ID}/productInputs/en~US~SKU12345",
  "product": "accounts/{ACCOUNT_ID}/products/en~US~SKU12345",
  "offerId": "SKU12345",
  "contentLanguage": "en",
  "feedLabel": "US",
  "productAttributes": {
    "title": "Classic Cotton T-Shirt",
    "description": "A comfortable, durable, and stylish t-shirt made from 100% cotton.",
    "link": "https://www.example.com/p/SKU12345",
    "availability": "IN_STOCK",
    "price": {
      "amountMicros": "15990000",
      "currencyCode": "USD"
    },
    "condition": "NEW",
    "gtins": [
      "9780007350896"
    ],
    "imageLink": "https://www.example.com/image/SKU12345"
  }
}

W tym przykładzie aktualizujemy title i availability produktu oraz usuwamy jego imageLink. Wartości description i price nie znajdują się w updateMask i pozostaną bez zmian.

PATCH https://merchantapi.googleapis.com/products/v1/accounts/{ACCOUNT_ID}/productInputs/en~US~SKU12345?updateMask=productAttributes.title,productAttributes.availability,productAttributes.imageLink&dataSource=accounts/{ACCOUNT_ID}/dataSources/{DATASOURCE_ID}

{
 "productAttributes": {
   "title": "Classic Cotton T-Shirt - New Edition",
   "availability": "OUT_OF_STOCK",
    "description": "A comfortable T-shirt from premium cotton, newer edition.",
    "price": {
      "amountMicros": "9990000",
      "currencyCode": "USD"
    }
 }
}

W przypadku udanego wywołania zwracany jest zaktualizowany zasób ProductInput. Pola title i availability są aktualizowane, a pole imageLink jest usuwane, ponieważ znajdowało się w updateMask, ale nie w treści żądania. Wartości description i price pozostają bez zmian, ponieważ nie były wymienione w updateMask.

{
  "name": "accounts/{ACCOUNT_ID}/productInputs/en~US~SKU12345",
  "product": "accounts/{ACCOUNT_ID}/products/en~US~SKU12345",
  "offerId": "SKU12345",
  "contentLanguage": "en",
  "feedLabel": "US",
  "productAttributes": {
    "title": "Classic Cotton T-Shirt - New Edition",
    "description": "A comfortable, durable, and stylish t-shirt made from 100% cotton.",
    "link": "https://www.example.com/p/SKU12345",
    "availability": "OUT_OF_STOCK",
    "price": {
      "amountMicros": "15990000",
      "currencyCode": "USD"
    },
    "condition": "NEW",
    "gtins": [
      "9780007350896"
    ],
  }
}

Poniższe przykłady kodu pokazują, jak zaktualizować produkt.

Java

import com.google.api.gax.core.FixedCredentialsProvider;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.protobuf.FieldMask;
import com.google.shopping.merchant.datasources.v1.DataSourceName;
import com.google.shopping.merchant.products.v1.Availability;
import com.google.shopping.merchant.products.v1.Condition;
import com.google.shopping.merchant.products.v1.ProductAttributes;
import com.google.shopping.merchant.products.v1.ProductInput;
import com.google.shopping.merchant.products.v1.ProductInputName;
import com.google.shopping.merchant.products.v1.ProductInputsServiceClient;
import com.google.shopping.merchant.products.v1.ProductInputsServiceSettings;
import com.google.shopping.merchant.products.v1.UpdateProductInputRequest;
import com.google.shopping.type.CustomAttribute;
import shopping.merchant.samples.utils.Authenticator;
import shopping.merchant.samples.utils.Config;

/** This class demonstrates how to update a product input */
public class UpdateProductInputSample {

  public static void updateProductInput(Config config, String productId, String dataSourceId)
      throws Exception {

    // Obtains OAuth token based on the user's configuration.
    GoogleCredentials credential = new Authenticator().authenticate();

    // Creates service settings using the credentials retrieved above.
    ProductInputsServiceSettings productInputsServiceSettings =
        ProductInputsServiceSettings.newBuilder()
            .setCredentialsProvider(FixedCredentialsProvider.create(credential))
            .build();

    // Creates product name to identify product.
    String name =
        ProductInputName.newBuilder()
            .setAccount(config.getAccountId().toString())
            .setProductinput(productId)
            .build()
            .toString();

    // Just productAttributes and customAttributes can be updated
    FieldMask fieldMask =
        FieldMask.newBuilder()
            .addPaths("product_attributes.title")
            .addPaths("product_attributes.description")
            .addPaths("product_attributes.link")
            .addPaths("product_attributes.image_link")
            .addPaths("product_attributes.availability")
            .addPaths("product_attributes.condition")
            .addPaths("product_attributes.gtins")
            .addPaths("custom_attributes.mycustomattribute")
            .build();

    // Calls the API and catches and prints any network failures/errors.
    try (ProductInputsServiceClient productInputsServiceClient =
        ProductInputsServiceClient.create(productInputsServiceSettings)) {

      ProductAttributes attributes =
          ProductAttributes.newBuilder()
              .setTitle("A Tale of Two Cities")
              .setDescription("A classic novel about the French Revolution")
              .setLink("https://exampleWebsite.com/tale-of-two-cities.html")
              .setImageLink("https://exampleWebsite.com/tale-of-two-cities.jpg")
              .setAvailability(Availability.IN_STOCK)
              .setCondition(Condition.NEW)
              .addGtins("9780007350896")
              .build();

      // The datasource can be either a primary or supplemental datasource.
      String dataSource =
          DataSourceName.newBuilder()
              .setAccount(config.getAccountId().toString())
              .setDatasource(dataSourceId)
              .build()
              .toString();

      UpdateProductInputRequest request =
          UpdateProductInputRequest.newBuilder()
              .setUpdateMask(fieldMask)
              // You can only update product attributes and custom_attributes
              .setDataSource(dataSource)
              .setProductInput(
                  ProductInput.newBuilder()
                      .setName(name)
                      .setProductAttributes(attributes)
                      .addCustomAttributes(
                          CustomAttribute.newBuilder()
                              .setName("mycustomattribute")
                              .setValue("Example value")
                              .build())
                      .build())
              .build();

      System.out.println("Sending update ProductInput request");
      ProductInput response = productInputsServiceClient.updateProductInput(request);
      System.out.println("Updated ProductInput Name below");
      // The last part of the product name will be the product ID assigned to a product by Google.
      // Product ID has the format `contentLanguage~feedLabel~offerId`
      System.out.println(response.getName());
      System.out.println("Updated Product below");
      System.out.println(response);
    } catch (Exception e) {
      System.out.println(e);
    }
  }

  public static void main(String[] args) throws Exception {
    Config config = Config.load();
    // An ID assigned to a product by Google. In the format
    // contentLanguage~feedLabel~offerId
    String productId = "en~label~sku123"; // Replace with your product ID.

    // Identifies the data source that will own the product input.
    String dataSourceId = "{INSERT_DATASOURCE_ID}"; // Replace with your datasource ID.

    updateProductInput(config, productId, dataSourceId);
  }
}
UpdateProductInputSample.java

PHP

use Google\ApiCore\ApiException;
use Google\Protobuf\FieldMask;
use Google\Shopping\Merchant\Products\V1\Availability;
use Google\Shopping\Merchant\Products\V1\Condition;
use Google\Shopping\Merchant\Products\V1\ProductAttributes;
use Google\Shopping\Merchant\Products\V1\Client\ProductInputsServiceClient;
use Google\Shopping\Merchant\Products\V1\ProductInput;
use Google\Shopping\Merchant\Products\V1\UpdateProductInputRequest;
use Google\Shopping\Type\CustomAttribute;

/**
 * This class demonstrates how to update a product input.
 */
class UpdateProductInputSample
{
    // An ID assigned to a product by Google. In the format
    // contentLanguage~feedLabel~offerId
    // Please ensure this product ID exists for the update to succeed.
    private const PRODUCT_ID = "online~en~label~sku123";

    // Identifies the data source that will own the product input.
    // Please ensure this data source ID exists.
    private const DATASOURCE_ID = "<INSERT_DATASOURCE_ID>";

    /**
     * Helper function to construct the full product input resource name.
     *
     * @param string $accountId The merchant account ID.
     * @param string $productInputId The product input ID (e.g., "online~en~label~sku123").
     * @return string The full product input resource name.
     */
    private static function getProductInputName(string $accountId, string $productInputId): string
    {
        return sprintf("accounts/%s/productInputs/%s", $accountId, $productInputId);
    }

    /**
     * Helper function to construct the full data source resource name.
     *
     * @param string $accountId The merchant account ID.
     * @param string $dataSourceId The data source ID.
     * @return string The full data source resource name.
     */
    private static function getDataSourceName(string $accountId, string $dataSourceId): string
    {
        return sprintf("accounts/%s/dataSources/%s", $accountId, $dataSourceId);
    }

    /**
     * Updates an existing product input in your Merchant Center account.
     *
     * @param array $config The configuration array containing the account ID.
     * @param string $productId The ID of the product input to update.
     * @param string $dataSourceId The ID of the data source.
     */
    public static function updateProductInput(
        array $config,
        string $productId,
        string $dataSourceId
    ): void {
        // Gets the OAuth credentials to make the request.
        $credentials = Authentication::useServiceAccountOrTokenFile();

        // Creates options config containing credentials for the client to use.
        $options = ['credentials' => $credentials];

        // Creates a ProductInputsServiceClient.
        $productInputsServiceClient = new ProductInputsServiceClient($options);

        // Construct the full resource name of the product input to be updated.
        $name = self::getProductInputName($config['accountId'], $productId);

        // Define the FieldMask to specify which fields to update.
        // Only 'attributes' and 'custom_attributes' can be specified in the
        // FieldMask for product input updates.
        $fieldMask = new FieldMask([
            'paths' => [
                "product_attributes.title",
                "product_attributes.description",
                "product_attributes.link",
                "product_attributes.image_link",
                "product_attributes.availability",
                "product_attributes.condition",
                "product_attributes.gtin",
                "custom_attributes.mycustomattribute" // Path for a specific custom attribute
            ]
        ]);

        // Calls the API and handles any network failures or errors.
        try {
            // Define the new attributes for the product.
            $attributes = new ProductAttributes([
                'title' => 'A Tale of Two Cities 3',
                'description' => 'A classic novel about the French Revolution',
                'link' => 'https://exampleWebsite.com/tale-of-two-cities.html',
                'image_link' => 'https://exampleWebsite.com/tale-of-two-cities.jpg',
                'availability' => Availability::IN_STOCK,
                'condition' => Condition::PBNEW,
                'gtins' => ['9780007350896'] // GTIN is a repeated field.
            ]);

            // Construct the full data source name.
            // This specifies the data source context for the update.
            $dataSource = self::getDataSourceName($config['accountId'], $dataSourceId);

            // Create the ProductInput object with the desired updates.
            // The 'name' field must match the product input being updated.
            $productInput = new ProductInput([
                'name' => $name,
                'product_attributes' => $attributes,
                'custom_attributes' => [ // Provide the list of custom attributes.
                    new CustomAttribute([
                        'name' => 'mycustomattribute',
                        'value' => 'Example value'
                    ])
                ]
            ]);

            // Create the UpdateProductInputRequest.
            $request = new UpdateProductInputRequest([
                'update_mask' => $fieldMask,
                'data_source' => $dataSource,
                'product_input' => $productInput
            ]);

            print "Sending update ProductInput request\n";
            // Make the API call to update the product input.
            $response = $productInputsServiceClient->updateProductInput($request);

            print "Updated ProductInput Name below\n";
            // The name of the updated product input.
            // The last part of the product name is the product ID (e.g., contentLanguage~feedLabel~offerId).
            print $response->getName() . "\n";
            print "Updated Product below\n";
            // Print the full updated product input object.
            print_r($response);

        } catch (ApiException $e) {
            printf("ApiException caught: %s\n", $e->getMessage());
        }
    }

    /**
     * Executes the UpdateProductInput sample.
     */
    public function callSample(): void
    {
        $config = Config::generateConfig();
        $productId = self::PRODUCT_ID;
        $dataSourceId = self::DATASOURCE_ID;

        self::updateProductInput($config, $productId, $dataSourceId);
    }
}

// Run the script.
$sample = new UpdateProductInputSample();
$sample->callSample();
UpdateProductInputSample.php

Python

"""A module to update a product input."""

from examples.authentication import configuration
from examples.authentication import generate_user_credentials
from google.protobuf import field_mask_pb2
from google.shopping.merchant_products_v1 import Availability
from google.shopping.merchant_products_v1 import Condition
from google.shopping.merchant_products_v1 import ProductAttributes
from google.shopping.merchant_products_v1 import ProductInput
from google.shopping.merchant_products_v1 import ProductInputsServiceClient
from google.shopping.merchant_products_v1 import UpdateProductInputRequest
from google.shopping.type import CustomAttribute


# Fetches the Merchant Center account ID from the authentication examples.
# This ID is needed to construct resource names for the API.
_ACCOUNT_ID = configuration.Configuration().read_merchant_info()


def update_product_input(account_id: str, product_id: str, data_source_id: str):
  """Updates an existing product input for a specific account.

  Args:
    account_id: The Merchant Center account ID.
    product_id: The ID of the product input to update. This ID is assigned by
      Google and has the format `contentLanguage~feedLabel~offerId`.
    data_source_id: The ID of the data source that owns the product input.
  """

  # Obtains OAuth credentials for authentication.
  credentials = generate_user_credentials.main()

  # Creates a ProductInputsServiceClient instance.
  client = ProductInputsServiceClient(credentials=credentials)

  # Constructs the full resource name for the product input.
  # Format: accounts/{account}/productInputs/{productinput}
  name = f"accounts/{account_id}/productInputs/{product_id}"

  # Defines the FieldMask to specify which fields of the product input
  # are being updated. Only 'attributes' and 'custom_attributes' can be updated.
  field_mask = field_mask_pb2.FieldMask(
      paths=[
          "product_attributes.title",
          "product_attributes.description",
          "product_attributes.link",
          "product_attributes.image_link",
          "product_attributes.availability",
          "product_attributes.condition",
          "product_attributes.gtins",
          "custom_attributes.mycustomattribute",
      ]
  )

  # Prepares the new attribute values for the product.
  attributes = ProductAttributes(
      title="A Tale of Two Cities updated",
      description="A classic novel about the French Revolution",
      link="https://exampleWebsite.com/tale-of-two-cities.html",
      image_link="https://exampleWebsite.com/tale-of-two-cities.jpg",
      availability=Availability.IN_STOCK,
      condition=Condition.NEW,
      gtins=["9780007350896"],  # GTIN is a repeated field.
  )

  # Constructs the full resource name for the data source.
  # The data source can be primary or supplemental.
  # Format: accounts/{account}/dataSources/{datasource}
  data_source = f"accounts/{account_id}/dataSources/{data_source_id}"

  # Prepares the ProductInput object with the updated information.
  product_input_data = ProductInput(
      name=name,
      product_attributes=attributes,
      custom_attributes=[
          CustomAttribute(
              name="mycustomattribute", value="Example value"
          )
      ],
  )

  # Creates the UpdateProductInputRequest.
  request = UpdateProductInputRequest(
      update_mask=field_mask,
      data_source=data_source,
      product_input=product_input_data,
  )

  # Sends the update request to the API.
  try:
    print("Sending update ProductInput request")
    response = client.update_product_input(request=request)
    print("Updated ProductInput Name below")
    # The response includes the name of the updated product input.
    # The last part of the product name is the product ID assigned by Google.
    print(response.name)
    print("Updated Product below")
    print(response)
  except RuntimeError as e:
    # Catches and prints any errors that occur during the API call.
    print(e)


if __name__ == "__main__":
  # The ID of the product to be updated.
  # This ID is assigned by Google and typically follows the format:
  # contentLanguage~feedLabel~offerId
  # Replace with an actual product ID from your Merchant Center account.
  product_id_to_update = "online~en~label~sku123"

  # The ID of the data source that will own the updated product input.
  # Replace with an actual data source ID from your Merchant Center account.
  data_source_id_for_update = "<INSERT_DATA_SOURCE_ID>"

  update_product_input(
      _ACCOUNT_ID, product_id_to_update, data_source_id_for_update
  )
update_product_input_sample.py

cURL

curl --location --request PATCH 'https://merchantapi.googleapis.com/products/v1/accounts/{ACCOUNT_ID}/productInputs/en~US~SKU12345?updateMask=productAttributes.title,productAttributes.description&dataSource=accounts/{ACCOUNT_ID}/dataSources/{DATASOURCE_ID}' \
--header 'Authorization: Bearer <API_TOKEN>' \
--header 'Content-Type: application/json' \
--data '{
   "productAttributes": {
       "title": "A Tale of Two Cities",
       "description": "A classic novel about the French Revolution"
   }
}'

Aktualizowanie za pomocą atrybutów niestandardowych

W ramach jednego wywołania możesz aktualizować zarówno atrybuty standardowe, jak i niestandardowe. Aby zaktualizować atrybut niestandardowy, dodaj przed jego nazwą znak customAttributes w updateMask.

Ten przykład wykonuje kilka działań w ramach jednego żądania:

• Bezpośrednio aktualizuje standardowy atrybut title.
• Aktualizuje istniejący atrybut niestandardowy (myCustomAttrToBeUpdated).
• Wstawia nowy atrybut niestandardowy (myCustomAttrToBeInserted).
• Usuwa istniejący atrybut niestandardowy (myCustomAttrToBeDeleted).

PATCH https://merchantapi.googleapis.com/products/v1/accounts/{ACCOUNT_ID}/productInputs/en~US~SKU12345?updateMask=productAttributes.title,customAttributes.myCustomAttrToBeInserted,customAttributes.myCustomAttrToBeUpdated,customAttributes.myCustomAttrToBeDeleted&dataSource=accounts/{ACCOUNT_ID}/dataSources/{DATASOURCE_ID}

{
  "productAttributes": {
    "title": "ProductTitle Updated"
  },
  "customAttributes": [
    {
      "name": "description",
      "value": "A newly updated description."
    },
    {
      "name": "myCustomAttrToBeUpdated",
      "value": "myCustomAttrToBeUpdated updated value"
    },
    {
      "name": "myCustomAttrToBeInserted",
      "value": "new from update"
    }
  ]
}

Żądanie zakończone pomyślnie zwraca zaktualizowany obiekt ProductInput odzwierciedlający wszystkie określone zmiany.

Aktualizacje atrybutów niestandardowych

Możesz użyć pola customAttributes, aby zaktualizować atrybuty, które zostały przez Ciebie zdefiniowane. Nie są one mapowane na standardową specyfikację i będą przechowywane jako atrybuty niestandardowe w przypadku produktu końcowego.

Jak przetwarzane są aktualizacje produktów

Gdy wyślesz patchprośbęProductInput, aktualizacja zostanie zastosowana do konkretnych danych przed zastosowaniem jakichkolwiek reguł. Dzięki temu wstawianie i aktualizowanie produktów działa w spójny sposób.

Aktualizacja jest przetwarzana w ten sposób:

1. Aktualizowanie danych wejściowych: Twoja prośba patch modyfikuje konkretne ProductInput powiązane z podanym przez Ciebie źródłem danych.

2. Przetwarzanie i scalanie: po zaktualizowaniu danych wejściowych rozpoczyna się przetwarzanie:

   • Reguły plików danych i dodatkowe źródła danych: reguły skonfigurowane w podstawowym źródle produktu łączą ProductInput z podstawowych i dodatkowych źródeł. Te reguły mogą zmieniać atrybuty lub tworzyć nowe. Więcej informacji o konfigurowaniu reguł znajdziesz w artykule https://support.google.com/merchants/answer/14994083.
   • Inne źródła danych: dane z innych źródeł (np. automatyczne ulepszenia) są również łączone z danymi wejściowymi z podstawowego źródła danych.
   • Weryfikacja: scalone dane są weryfikowane pod kątem zgodności ze specyfikacją danych produktów i zasadami Zakupów Google.

3. Produkt końcowy: wynikiem tego potoku jest końcowy, przetworzony zasób Product, który można zwrócić za pomocą products.get lub products.list. Jest to również wersja produktu, która jest wyświetlana w Merchant Center i kwalifikuje się do wyświetlania w różnych miejscach docelowych.

Ze względu na ten wieloetapowy proces występuje opóźnienie, zwykle wynoszące kilka minut, między wysłaniem prośby o aktualizację a odzwierciedleniem zmian w końcowym zasobie Product, który można pobrać za pomocą products.get.

Przykład: aktualizowanie produktu za pomocą jednego podstawowego źródła danych

Jest to najczęstszy przypadek użycia. Produkt istnieje w jednym podstawowym źródle danych i chcesz zaktualizować niektóre jego atrybuty.

1. Stan początkowy: produkt en~US~SKU12345 istnieje w podstawowym źródle danych z atrybutami title: "Classic T-Shirt" i price: 15.99 USD.
2. Prośba o aktualizację: wysyłasz patch prośbę o zaktualizowanie price do 14.99 USD i ustawiasz availability na out of stock.
3. Przetwarzanie:
   • Zaktualizowano ProductInput dla SKU12345.
4. Produkt końcowy: ostateczna wersja Product ma teraz title: "Classic T-Shirt",price: 14.99 USD i availability: "out of stock".

Przykład: aktualizowanie produktu za pomocą dodatkowych danych i reguł

Ten przykład pokazuje, jak reguły pliku danych mogą wpływać na aktualizację, powodując zastosowanie niektórych zmian, a inne zostaną zastąpione.

1. Stan początkowy:
   • Główne dane wejściowe: en~US~SKU12345 ma title: "Great T-Shirt" i description: "A great short-sleeve t-shirt.".
   • Dane wejściowe dodatkowe: ten sam produkt ma wpis w dodatkowym źródle danych z wartościami title: "Awesome T-Shirt" i description: "An awesome short-sleeve t-shirt.".
   • Reguła pliku danych: reguła jest ustawiona tak, aby pobierać title z dodatkowego źródła danych. Nie ma reguły dla description.
   • Wynik: ostatecznie przetworzony plik Product zawiera title: "Awesome T-Shirt" i description: "A great short-sleeve t-shirt.".
2. Prośba o aktualizację: wysyłasz patch prośbę o zaktualizowanie podstawowego źródła danych, ustawiając title na "Fantastic T-Shirt" i description na "A fantastic short-sleeve t-shirt.".
3. Przetwarzanie:
   • W podstawowym źródle danych ProductInput zostaje zaktualizowany i zawiera title: "Fantastic T-Shirt" oraz description: "A fantastic short-sleeve t-shirt.".
   • Uruchamia się potok przetwarzania.
   • W przypadku atrybutu title reguła pliku danych określa, że wartość ze źródła danych dodatkowych (Awesome T-Shirt) ma pierwszeństwo przed Twoją aktualizacją.
   • W przypadku description nie ma reguły zastępującej, więc używana jest zaktualizowana wartość z głównego źródła danych (A fantastic short-sleeve t-shirt.).
4. Produkt końcowy: tytuł końcowego Product pozostaje Awesome T-Shirt (Twoja aktualizacja została zastąpiona), ale jego opis to teraz A fantastic short-sleeve t-shirt. (Twoja aktualizacja została zastosowana).

Wybieranie między aktualizacjami a dodatkowymi źródłami danych

Dane produktów możesz modyfikować za pomocą productinputs.patch lub przez wstawianie danych do dodatkowych źródeł danych. Najlepszy wybór zależy od strategii zarządzania danymi.

Aby uniknąć nieprzewidywalnych wyników, zalecamy, aby nie używać zarówno productinputs.patch, jak i dodatkowych źródeł danych do zarządzania tymi samymi danymi produktów dla tego samego produktu.

Oto szczegółowe porównanie:

Funkcja	productinputs.patch (Aktualizacje)	Dodatkowe źródła danych
Najlepsze zastosowania	Szybkie, częste, częściowe zmiany w istniejących danych (np. cena, dostępność).	Nakładanie na siebie logicznie oddzielonych danych, zarządzanie różnymi atrybutami przez różne systemy lub złożone zastąpienia oparte na regułach.
Mechanizm	Modyfikuje istniejący ProductInput w miejscu.	Tworzy nowy, oddzielny ProductInput w dodatkowym źródle danych.
Szczegółowość danych	Działa na określonych polach pojedynczego ProductInput.	Działa na całym ProductInput w dodatkowym źródle.
Trwałość	Zmiany są zachowywane, dopóki ten sam plik ProductInput nie zostanie zastąpiony pełnym plikiem insert lub innym plikiem patch.	Trwałość jest kontrolowana przez reguły pliku danych. Może zastępować dane podstawowe bez ograniczeń czasowych, jeśli reguły nadają mu wyższy priorytet.
Interakcja z regułami	Można go używać bez reguł pliku danych, ponieważ aktualizuje istniejące źródło danych i ProductInput.	Wymaga wyraźnego skonfigurowania reguły w podstawowym źródle, aby połączyć dodatkowe źródło.
Konfiguracja źródła danych	Działa na istniejącym źródle danych. Nie potrzebujesz nowych źródeł.	Wymaga utworzenia oddzielnych dodatkowych źródeł danych i zarządzania nimi oraz połączenia ich za pomocą reguł plików danych.