How to Use Magento 2 Data Patch to Create Product Attributes?

• What is Magento Data Patch?

• Why Use Data Patch to Create Programmatic Product Attributes?

• How to Use Magento 2 Data Patch to Create Product Attributes?

• Best Practices for Writing Magento 2 Data Patches

• FAQs

• Summary

What is Magento Data Patch?

Magento Data Patch is a class that handles data changes in a module. Magento introduced this method in version 2.3. It replaces the older install and upgrade scripts.

A data patch includes instructions to insert or change data in the database. It runs one time only during the setup:upgrade command. Developers use it to add product attributes, create CMS content, or update values.

Patches follow a defined structure. You must place them in the Setup\Patch\Data folder of your module. Magento tracks patch execution in a dedicated database table. It prevents repeat runs. You can manage patch order by setting dependencies.

Why Use Data Patch to Create Programmatic Product Attributes?

Reason	Explanation
Version Control	Data patches live inside your module. You can track every patch with Git. It helps teams avoid conflicts. Developers can review each change. Teams get full control over attribute updates. It reduces risk during deployments.
One-Time Execution	Magento runs each data patch one time. It stores the patch record in a database table. It avoids duplicate executions. You prevent data conflicts. The patch system ensures stable and clean updates. You don’t need manual tracking.
Consistent Across Environments	You can apply the same patch in every environment. No manual steps needed in staging or production. It keeps data structure consistent. It removes human error. The system stays uniform across development, testing, and live sites.
Ideal for CI/CD Pipelines	CI/CD tools can run patches during Magento deployment. You don’t need to use the admin panel. It saves setup time. It improves deployment reliability. Developers can automate more tasks. The whole release cycle becomes faster.
Supports Dependencies	You can define patch dependencies inside the class. Magento runs them in the correct order. It ensures related data updates run as expected. It prevents logic conflicts. You get more control over execution flow.
Cleaner Codebase	Data patches live inside the module code. You keep logic and configuration in one place. It improves code readability. Developers can understand the setup faster, which reduces confusion during maintenance.
Rollback and Testing Compatible	Developers can remove and apply patches during testing. It supports faster debugging. It helps manage test environments better. You can change data without affecting other areas. Teams get full control over data structure during development.

How to Use Magento 2 Data Patch to Create Product Attributes?

Step 1: Create the Data Patch File

Go to your Magento module directory. Navigate to:

{Vendor}/{Extension}/Setup/Patch/Data/

Create a file named:

CreateCustomProductAttr.php

Step 2: Add the Data Patch Code

Use the following code inside your CreateCustomProductAttr.php file:

<?php

namespace Vendor\Extension\Setup\Patch\Data;

use Magento\Eav\Setup\EavSetup;

use Magento\Eav\Setup\EavSetupFactory;

use Magento\Framework\Setup\ModuleDataSetupInterface;

use Magento\Framework\Setup\Patch\DataPatchInterface;

class CreateCustomProductAttr implements DataPatchInterface

{

`private $moduleDataSetup;`

`private $eavSetupFactory;`

`public function __construct(`

    `ModuleDataSetupInterface $moduleDataSetup,`

    `EavSetupFactory $eavSetupFactory`

`) {`

    `$this->moduleDataSetup = $moduleDataSetup;`

    `$this->eavSetupFactory = $eavSetupFactory;`

`}`

`/**`

 `* {@inheritdoc}`

 `*/`

`public function apply()`

`{`

    `/** @var EavSetup $eavSetup */`

    `$eavSetup = $this->eavSetupFactory->create(['setup' => $this->moduleDataSetup]);`

    `$eavSetup->addAttribute('catalog_product', 'attribute_code', [`

        `'type' => 'int',`

        `'backend' => '',`

        `'frontend' => '',`

        `'label' => 'attribute label',`

        `'input' => 'boolean',`

        `'class' => '',`

        `'source' => \Magento\Eav\Model\Entity\Attribute\Source\Boolean::class,`

        `'global' => \Magento\Eav\Model\Entity\Attribute\ScopedAttributeInterface::SCOPE_GLOBAL,`

        `'visible' => true,`

        `'required' => false,`

        `'user_defined' => false,`

        `'default' => '',`

        `'searchable' => false,`

        `'filterable' => false,`

        `'comparable' => false,`

        `'visible_on_front' => false,`

        `'used_in_product_listing' => false,`

        `'unique' => false,`

        `'apply_to' => '',`

    `]);`

`}`

`/**`

 `* {@inheritdoc}`

 `*/`

`public static function getDependencies()`

`{`

    `return [];`

`}`

`/**`

 `* {@inheritdoc}`

 `*/`

`public function getAliases()`

`{`

    `return [];`

`}`

}

Step 3: Update Namespace and Attribute Settings

Replace Vendor and Extension with your actual module’s folder names. Change 'attribute_code' and 'attribute label' to your custom values.

You can change the 'type', 'input', 'label', or 'source' to match your attribute needs. Adjust other values like required, visible, or user_defined as per your business logic.

Step 4: Run Setup Upgrade Command

Open your terminal. Navigate to your Magento root directory. Run the following command:

php bin/magento setup:upgrade

Step 5: Confirm Addition of Attribute

Log in to the Magento Admin panel. Go to Stores > Attributes > Product.

Search for your new attribute by its label or code. Check the attribute configuration. Assign it to the required attribute set if needed.

You have created a custom product attribute using a Magento 2 data patch.

Best Practices for Writing Magento 2 Data Patches

1. Use Clear and Descriptive Class Names

• Choose class names that explain the patch’s purpose.

• Avoid vague or generic names such as Patch1 or UpdateData.

• Make identification easy by using meaningful names.

• Apply CamelCase for better readability.

• Keep naming consistent throughout your module.

2. Follow Magento’s Patch Interface Requirements

• Use the DataPatchInterface in your class.

• Include all required methods: apply(), getDependencies(), and getAliases().

• Return empty arrays for dependencies and aliases if none exist.

• It ensures Magento tracks your patch.

• Skipping these methods can cause errors.

3. Limit Patch Scope to One Task

• Write patches that perform a single, focused task.

• Avoid mixing unrelated changes in one patch.

• This approach simplifies debugging and Magento maintenance.

• Smaller patches make rollbacks easier to manage.

• Keeping patches modular gives you better control.

4. Use Dependency Injection

• Inject required classes like ModuleDataSetupInterface and EavSetupFactory through the constructor.

• Do not create manual instances inside the patch.

• Following Magento’s design patterns improves code structure.

• Testing and future updates become easier.

• This practice ensures clean and maintainable code.

5. Handle Attribute Properties

• Define all relevant attribute properties.

• Set visibility, scope, input type, and default values without leaving fields empty.

• Align attribute settings with your business requirements.

• Doing so prevents unexpected behavior in the frontend and backend.

6. Test Your Patch in Different Environments

• Run your patch on local, staging, and production setups.

• Verify attribute creation and configuration on each environment.

• Check for errors during the setup:upgrade command.

• Ensure data remains consistent across environments.

• Document any environment-specific differences.

7. Document Your Patch Code

• Add comments that explain key logic inside your patch.

• Use PHPDoc style for methods and properties.

• Describe the patch’s purpose and its impact.

• Keep documentation updated with any code changes.

• Well-written docs help other developers understand your work better.

FAQs

1. What is a Magento 2 Data Patch and why is it used?

A Magento 2 Data Patch is a class that handles data changes within a module. It runs once during the setup:upgrade command to insert or change data. Magento introduced this method to replace older install and upgrade scripts. This approach provides better control and cleaner updates.

2. How does Magento ensure that a Data Patch runs only once?

Magento records each executed data patch in a dedicated database table. The system checks this record before running the patch. As a result, it prevents duplicate executions. This method avoids data conflicts and keeps updates stable.

3. Where should I place my Data Patch file in a Magento module?

Place the patch file inside the module's Setup/Patch/Data folder. E.g., the path looks like this: Vendor/Extension/Setup/Patch/Data/CreateCustomProductAttr.php. Following this structure helps Magento recognize and execute the patch.

4. Can I customize the product attribute created by a Data Patch?

Yes, you can change the Magento attribute code, label, input type, data type, visibility, and scope. Change these settings in the attribute array inside the patch class's apply() method. Customizing attributes allows you to meet your specific business needs.

Summary

Magento 2 data patch delivers precise control over data updates in your store. It helps developers add product attributes and manage data changes without errors. Key benefits are:

• Runs patches once to prevent repeated updates.

• Tracks every data change inside your code repository.

• Applies data across development and production.

• Executes patches in the right order to avoid conflicts.

• Keeps data update logic inside the module for better maintenance.

Consider managed Magento hosting to improve your store’s speed and security.