Często aktualizuj produkty

Podrzędny interfejs API Products 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ąć konieczności ponownego przesyłania całego produktu w przypadku niewielkiej zmiany. Należy jednak regularnie ponownie wstawiać produkty, aby mieć pewność, że wszystkie dane o produktach są zsynchronizowane.

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

Wymagania wstępne

Aby zaktualizować produkt, musisz mieć:

• istniejący produkt, który chcesz zaktualizować. Aby dowiedzieć się, jak tworzyć produkty, przeczytaj przewodnik 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 je znaleźć, przeczytaj przewodnik Zarządzanie źródłami danych interfejsu API na potrzeby przesyłania produktów.

Aktualizowanie konkretnych szczegółów produktu

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

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, ale nie 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ęty parametr updateMask: aktualizowane są wszystkie pola podane w treści żądania. Pola, których nie ma 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"
  }
}

Ten przykład aktualizuje title i availability produktu oraz usuwa jego imageLink. 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"
    }
 }
}

Pomyślne wywołanie zwraca zaktualizowany zasób ProductInput. title i availability są aktualizowane, a imageLink jest usuwany, ponieważ znajdował się w updateMask, ale nie w treści żądania. description i price pozostają bez zmian, ponieważ nie został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 zaktualizować zarówno atrybuty standardowe, jak i niestandardowe. Aby zaktualizować atrybut niestandardowy, dodaj do jego nazwy w updateMask prefiks customAttributes.

Ten przykład wykonuje kilka działań w jednym żądaniu:

• 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"
    }
  ]
}

Pomyślne żądanie zwraca zaktualizowany element ProductInput odzwierciedlający wszystkie określone zmiany.

Informacje o aktualizacjach atrybutów niestandardowych

Za pomocą pola customAttributes możesz aktualizować atrybuty, które zostały zdefiniowane przez Ciebie. Nie są one mapowane na standardową specyfikację i będą przechowywane jako atrybuty niestandardowe w produkcie końcowym.

Jak są przetwarzane aktualizacje produktów

Gdy wysyłasz żądanie patch, aktualizacja jest stosowana do konkretnych danych ProductInput zanim zostaną zastosowane jakiekolwiek reguły. Dzięki temu zachowanie podczas wstawiania i aktualizowania produktów jest spójne.

Oto jak przetwarzana jest aktualizacja:

1. Aktualizuj dane wejściowe: żądanie patch modyfikuje konkretny element ProductInput powiązany z podanym źródłem danych.

2. Przetwarzanie i łączenie: po zaktualizowaniu danych wejściowych rozpoczyna się przetwarzanie:

   • Reguły pliku 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 Konfigurowanie reguł atrybutów.
   • 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: połączone dane są weryfikowane pod kątem specyfikacji danych produktów i zasad Google dotyczących Zakupów.

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 też wersja produktu, która jest wyświetlana w Merchant Center i może się pojawiać w różnych miejscach docelowych.

Ze względu na ten wieloetapowy proces występuje opóźnienie (zwykle kilka minut) między wysłaniem żądania aktualizacji 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 znajduje się w jednym podstawowym źródle danych i chcesz zaktualizować niektóre jego atrybuty.

1. Stan początkowy: w podstawowym źródle danych znajduje się produkt en~US~SKU12345 z atrybutami title: "Classic T-Shirt" i price: 15.99 USD.
2. Żądanie aktualizacji: wysyłasz żądanie patch, aby zaktualizować price do 14.99 USD i ustawić availability na out of stock.
3. Przetwarzanie:
   • Aktualizowany jest element ProductInput dla SKU12345.
4. Produkt końcowy: końcowy element Product ma teraz atrybuty 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 zastąpienie.

1. Stan początkowy:
   • Podstawowe dane wejściowe: en~US~SKU12345 ma title: "Great T-Shirt" i description: "A great short-sleeve t-shirt.".
   • Dodatkowe dane wejściowe: ten sam produkt ma wpis w dodatkowym źródle danych z title: "Awesome T-Shirt" i description: "An awesome short-sleeve t-shirt.".
   • Reguła pliku danych: ustawiona jest reguła, która pobiera title z dodatkowego źródła danych. Nie ma reguły dla description.
   • Wynik: końcowy przetworzony element Product ma title: "Awesome T-Shirt" i description: "A great short-sleeve t-shirt.".
2. Żądanie aktualizacji: wysyłasz żądanie patch, aby zaktualizować podstawowe źródło danych, ustawiając title na "Fantastic T-Shirt" i description na "A fantastic short-sleeve t-shirt.".
3. Przetwarzanie:
   • Element ProductInput w podstawowym źródle danych jest aktualizowany i ma atrybuty title: "Fantastic T-Shirt" i description: "A fantastic short-sleeve t-shirt.".
   • Uruchamia się potok przetwarzania.
   • W przypadku title reguła pliku danych określa, że wartość z dodatkowego źródła danych (Awesome T-Shirt) ma pierwszeństwo, co powoduje zastąpienie aktualizacji.
   • W przypadku description nie ma reguły zastępującej, więc używana jest zaktualizowana wartość z podstawowych danych wejściowych (A fantastic short-sleeve t-shirt.).
4. Produkt końcowy: tytuł końcowego elementu Product's 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 o produktach możesz modyfikować za pomocą productinputs.patch lub przez wstawianie danych do dodatkowych źródeł danych. Najlepszy wybór zależy od Twojej strategii zarządzania danymi.

Aby uniknąć nieprzewidywalnych wyników, zalecamy, aby nie używać jednocześnie productinputs.patch i dodatkowych źródeł danych do zarządzania tymi samymi danymi o produktach w przypadku tego samego produktu.

Oto szczegółowe porównanie:

Funkcja	productinputs.patch (aktualizacje)	Dodatkowe źródła danych
Najlepsze rozwiązanie w przypadku	szybkich, częstych, częściowych zmian w istniejących danych (np. ceny, dostępności).	nakładania na siebie logicznie oddzielonych danych, zarządzania różnymi atrybutami przez różne systemy lub złożonych zastąpień opartych na regułach.
Mechanizm	Modyfikuje istniejący element ProductInput w miejscu.	Tworzy nowy, oddzielny element ProductInput w dodatkowym źródle danych.
Szczegółowość danych	Działa na konkretnych polach pojedynczego elementu ProductInput.	Działa na całym elemencie ProductInput w dodatkowym źródle.
Trwałość	Zmiany są trwałe, dopóki ten sam element ProductInput nie zostanie zastąpiony przez pełne insert lub inne patch.	Trwałość jest kontrolowana przez reguły pliku danych. Może zastępować podstawowe dane na czas nieokreślony, jeśli reguły mają wyższy priorytet.
Interakcja z regułami	Może być używana bez reguł pliku danych, ponieważ aktualizuje istniejące źródło danych i element ProductInput.	Wymaga wyraźnego skonfigurowania reguły w podstawowym źródle, aby połączyć źródło dodatkowe.
Konfiguracja źródła danych	Działa na istniejącym źródle danych. Nie są potrzebne żadne nowe źródła.	Wymaga utworzenia dodatkowych źródeł danych i zarządzania nimi oraz połączenia ich za pomocą reguł pliku danych.