OperationsExecutor.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Setup\Declaration\Schema;

use Magento\Framework\App\ResourceConnection;
use Magento\Framework\Setup\Declaration\Schema\DataSavior\DataSaviorInterface;
use Magento\Framework\Setup\Declaration\Schema\Db\DbSchemaWriterInterface;
use Magento\Framework\Setup\Declaration\Schema\Db\StatementAggregatorFactory;
use Magento\Framework\Setup\Declaration\Schema\Db\StatementFactory;
use Magento\Framework\Setup\Declaration\Schema\Diff\DiffInterface;
use Magento\Framework\Setup\Declaration\Schema\Dto\ElementInterface;
use Magento\Framework\Setup\Declaration\Schema\Operations\AddColumn;
use Magento\Framework\Setup\Declaration\Schema\Operations\CreateTable;
use Magento\Framework\Setup\Declaration\Schema\Operations\ReCreateTable;

class OperationsExecutor
{
    const KEY_SAFE_MODE = 'safe-mode';
    const KEY_DATA_RESTORE = 'data-restore';

    private $operations;

    private $sharding;

    private $resourceConnection;

    private $statementFactory;

    private $dbSchemaWriter;

    private $statementAggregatorFactory;

    private $dataSaviorsCollection;

    private $dryRunLogger;

    public function __construct(
        array $operations,
        array $dataSaviorsCollection,
        Sharding $sharding,
        ResourceConnection $resourceConnection,
        StatementFactory $statementFactory,
        DbSchemaWriterInterface $dbSchemaWriter,
        StatementAggregatorFactory $statementAggregatorFactory,
        DryRunLogger $dryRunLogger
    ) {
        $this->operations = $operations;
        $this->sharding = $sharding;
        $this->resourceConnection = $resourceConnection;
        $this->statementFactory = $statementFactory;
        $this->dbSchemaWriter = $dbSchemaWriter;
        $this->statementAggregatorFactory = $statementAggregatorFactory;
        $this->dataSaviorsCollection = $dataSaviorsCollection;
        $this->dryRunLogger = $dryRunLogger;
    }

    public function getDestructiveOperations()
    {
        $operations = [];

        foreach ($this->operations as $operation) {
            if ($operation->isOperationDestructive()) {
                $operations[$operation->getOperationName()] = $operation->getOperationName();
            }
        }

        return $operations;
    }

    private function startSetupForAllConnections()
    {
        foreach ($this->sharding->getResources() as $resource) {
            $this->resourceConnection->getConnection($resource)
                ->startSetup();
            $this->resourceConnection->getConnection($resource)
                ->query('SET UNIQUE_CHECKS=0');
        }
    }

    private function endSetupForAllConnections()
    {
        foreach ($this->sharding->getResources() as $resource) {
            $this->resourceConnection->getConnection($resource)
                ->endSetup();
        }
    }

    private function operationIsOppositeToDestructive(OperationInterface $operation)
    {
        return $operation instanceof AddColumn ||
            $operation instanceof CreateTable ||
            $operation instanceof ReCreateTable;
    }

    public function execute(DiffInterface $diff, array $requestData)
    {
        $this->startSetupForAllConnections();
        $tableHistories = $diff->getAll();
        $dryRun = isset($requestData[DryRunLogger::INPUT_KEY_DRY_RUN_MODE]) &&
            $requestData[DryRunLogger::INPUT_KEY_DRY_RUN_MODE];

        if ($dryRun) {
            $this->dryRunLogger->prepareToDryRun();
        }

        if (is_array($tableHistories)) {
            foreach ($tableHistories as $tableHistory) {
                $destructiveElements = [];
                $oppositeToDestructiveElements = [];
                $statementAggregator = $this->statementAggregatorFactory->create();

                foreach ($this->operations as $operation) {
                    if (isset($tableHistory[$operation->getOperationName()])) {
                        foreach ($tableHistory[$operation->getOperationName()] as $elementHistory) {
                            $statementAggregator->addStatements($operation->doOperation($elementHistory));

                            if ($operation->isOperationDestructive()) {
                                $destructiveElements[] = $elementHistory->getOld();
                            } elseif ($this->operationIsOppositeToDestructive($operation)) {
                                $oppositeToDestructiveElements[] = $elementHistory->getNew();
                            }
                        }
                    }
                }

                $this->doDump($destructiveElements, $requestData);
                $this->dbSchemaWriter->compile($statementAggregator, $dryRun);
                $this->doRestore($oppositeToDestructiveElements, $requestData);
            }
        }

        $this->endSetupForAllConnections();
    }

    private function doRestore(array $elements, array $requestData)
    {
        $restoreMode = isset($requestData[self::KEY_DATA_RESTORE]) && $requestData[self::KEY_DATA_RESTORE];

        if ($restoreMode) {
            foreach ($elements as $element) {
                foreach ($this->dataSaviorsCollection as $dataSavior) {
                    if ($dataSavior->isAcceptable($element)) {
                        $dataSavior->restore($element);
                        break;
                    }
                }
            }
        }
    }

    private function doDump(array $elements, array $requestData)
    {
        $safeMode = isset($requestData[self::KEY_SAFE_MODE]) && $requestData[self::KEY_SAFE_MODE];

        if ($safeMode) {
            foreach ($elements as $element) {
                foreach ($this->dataSaviorsCollection as $dataSavior) {
                    if ($dataSavior->isAcceptable($element)) {
                        $dataSavior->dump($element);
                        break;
                    }
                }
            }
        }
    }
}