TableDiff.php

Go to the documentation of this file.

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

use Magento\Framework\Setup\Declaration\Schema\Dto\Column;
use Magento\Framework\Setup\Declaration\Schema\Dto\Constraint;
use Magento\Framework\Setup\Declaration\Schema\Dto\ElementInterface;
use Magento\Framework\Setup\Declaration\Schema\Dto\Index;
use Magento\Framework\Setup\Declaration\Schema\Dto\Table;
use Magento\Framework\Setup\Declaration\Schema\Operations\ModifyColumn;

class TableDiff
{
    const COLUMN_DIFF_TYPE = "columns";

    const CONSTRAINT_DIFF_TYPE = "constraints";

    const INDEX_DIFF_TYPE = "indexes";

    private $diffManager;

    public function __construct(DiffManager $diffManager)
    {
        $this->diffManager = $diffManager;
    }

    private function excludeAutoIndexes(Table $table, array $indexes)
    {
        foreach ($table->getReferenceConstraints() as $constraint) {
            unset($indexes[$constraint->getName()]);
        }

        return $indexes;
    }

    private function turnOffForeignKeys(Table $declaredTable, Table $generatedTable, Diff $diff)
    {
        $changes = $diff->getChange($generatedTable->getName(), ModifyColumn::OPERATION_NAME);

        foreach ($changes as $elementHistory) {
            if ($elementHistory->getNew() instanceof Column) {
                $column = $elementHistory->getNew();
                $references = $generatedTable->getReferenceConstraints();
                $declaredReferences = $this->getElementsListByNameWithoutPrefix(
                    $declaredTable->getReferenceConstraints()
                );

                foreach ($references as $reference) {
                    if ($reference->getColumn()->getName() === $column->getName() &&
                        isset($declaredReferences[$reference->getNameWithoutPrefix()])
                    ) {
                        $diff = $this->diffManager->registerRemoval($diff, [$reference]);
                        $diff = $this->diffManager
                            ->registerCreation(
                                $diff,
                                $declaredReferences[$reference->getNameWithoutPrefix()]
                            );
                    }
                }
            }
        }

        return $diff;
    }

    private function getElementsListByNameWithoutPrefix(array $elements)
    {
        $elementsList = [];
        foreach ($elements as $element) {
            $elementsList[$element->getNameWithoutPrefix()] = $element;
        }

        return $elementsList;
    }

    public function diff(
        ElementInterface $declaredTable,
        ElementInterface $generatedTable,
        Diff $diff
    ) {
        if ($declaredTable->getResource() !== $generatedTable->getResource()) {
            $this->diffManager->registerRecreation($declaredTable, $generatedTable, $diff);
            return $diff;
        }

        if ($this->diffManager->shouldBeModified($declaredTable, $generatedTable)) {
            $this->diffManager->registerTableModification($declaredTable, $generatedTable, $diff);
        }

        return $this->calculateDiff($declaredTable, $generatedTable, $diff);
    }

    private function calculateDiff(ElementInterface $declaredTable, ElementInterface $generatedTable, Diff $diff)
    {
        $types = [self::COLUMN_DIFF_TYPE, self::CONSTRAINT_DIFF_TYPE, self::INDEX_DIFF_TYPE];
        //We do inspection for each element type
        foreach ($types as $elementType) {
            $generatedElements = $generatedTable->getElementsByType($elementType);
            $declaredElements = $declaredTable->getElementsByType($elementType);

            if ($elementType === self::INDEX_DIFF_TYPE) {
                $generatedElements = $this->excludeAutoIndexes($generatedTable, $generatedElements);
                $declaredElements = $this->excludeAutoIndexes($declaredTable, $declaredElements);
            }

            if (in_array($elementType, [self::CONSTRAINT_DIFF_TYPE, self::INDEX_DIFF_TYPE], true)) {
                $generatedElements = $this->getElementsListByNameWithoutPrefix($generatedElements);
                $declaredElements = $this->getElementsListByNameWithoutPrefix($declaredElements);
            }

            foreach ($declaredElements as $elementName => $element) {
                //If it is new for generated (generated from db) elements - we need to create it
                if (!isset($generatedElements[$elementName])) {
                    $diff = $this->diffManager->registerCreation($diff, $element);
                } elseif ($this->diffManager->shouldBeModified(
                    $element,
                    $generatedElements[$elementName]
                )) {
                    $diff = $this->diffManager
                        ->registerModification($diff, $element, $generatedElements[$elementName]);
                }
                //Unset processed elements from generated from db schema
                //All other unprocessed elements will be added as removed ones
                unset($generatedElements[$elementName]);
            }

            //Elements that should be removed
            if ($this->diffManager->shouldBeRemoved($generatedElements)) {
                $diff = $this->diffManager->registerRemoval($diff, $generatedElements);
            }
        }

        $diff = $this->turnOffForeignKeys($declaredTable, $generatedTable, $diff);

        return $diff;
    }
}