Spiral\Database\Helpers\SynchronizationPool

Complexity

Total Complexity

28

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getTables()	0	4	1
A	sortedTables()	0	12	2
B	run()	0	36	5
A	beginTransaction()	0	6	2
A	commitTransaction()	0	6	2
A	rollbackTransaction()	0	6	2
A	collectDrivers()	0	8	3
A	dropForeigns()	0	8	3
A	dropIndexes()	0	9	3
A	runChanges()	0	9	2
A	resetSchemas()	0	6	2

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

namespace Spiral\Database\Helpers;

use Psr\Log\LoggerInterface;
use Spiral\Core\Component;
use Spiral\Database\Entities\AbstractHandler as Behaviour;
use Spiral\Database\Entities\Driver;
use Spiral\Database\Schemas\Prototypes\AbstractTable;
use Spiral\Support\DFSSorter;

/**
 * Saves multiple linked tables at once but treating their cross dependency.
 *
 * Attention, not every DBMS support transactional schema manipulations!
 */
class SynchronizationPool extends Component
{
    /**
     * @var AbstractTable[]
     */
    private $tables = [];

    /**
     * @var Driver[]
     */
    private $drivers = [];

    /**
     * @param AbstractTable[] $tables
     */
    public function __construct(array $tables)
    {
        $this->tables = $tables;

        $this->collectDrivers();
    }

    /**
     * @return AbstractTable[]
     */
    public function getTables()
    {
        return $this->tables;
    }

    /**
     * List of tables sorted in order of cross dependency.
     *
     * @return AbstractTable[]
     */
    public function sortedTables(): array
    {
        /*
         * Tables has to be sorted using topological graph to execute operations in a valid order.
         */
        $sorter = new DFSSorter();
        foreach ($this->tables as $table) {
            $sorter->addItem($table->getName(), $table, $table->getDependencies());
        }

        return $sorter->sort();
    }

    /**
     * Synchronize tables.
     *
     * @param LoggerInterface|null $logger
     *
     * @throws \Exception
     * @throws \Throwable
     */
    public function run(LoggerInterface $logger = null)
    {
        $hasChanges = false;
        foreach ($this->tables as $table) {
            if ($table->getComparator()->hasChanges()) {
                $hasChanges = true;
                break;
            }
        }

        if (!$hasChanges) {
            //Nothing to do
            return;
        }

        $this->beginTransaction();

        try {
            //Drop not-needed foreign keys and alter everything else
            $this->dropForeigns($logger);

It seems like $logger defined by parameter $logger on line 79 can be null; however, Spiral\Database\Helpers\SynchronizationPool::dropForeigns() does not accept null, maybe add an additional type check?

            //Drop not-needed indexes
            $this->dropIndexes($logger);

It seems like $logger defined by parameter $logger on line 79 can be null; however, Spiral\Database\Helpers\SynchronizationPool::dropIndexes() does not accept null, maybe add an additional type check?

            //Other changes [NEW TABLES WILL BE CREATED HERE!]
            $this->runChanges($logger);

It seems like $logger defined by parameter $logger on line 79 can be null; however, Spiral\Database\Helpers\SynchronizationPool::runChanges() does not accept null, maybe add an additional type check?

            //Finishing with new foreign keys
            $this->resetSchemas($logger);

It seems like $logger defined by parameter $logger on line 79 can be null; however, Spiral\Database\Helpers\SynchronizationPool::resetSchemas() does not accept null, maybe add an additional type check?

        } catch (\Throwable $e) {
            $this->rollbackTransaction();
            throw $e;
        }

        $this->commitTransaction();
    }

    /**
     * Begin mass transaction.
     */
    protected function beginTransaction()
    {
        foreach ($this->drivers as $driver) {
            $driver->beginTransaction();
        }
    }

    /**
     * Commit mass transaction.
     */
    protected function commitTransaction()
    {
        foreach ($this->drivers as $driver) {
            $driver->commitTransaction();
        }
    }

    /**
     * Roll back mass transaction.
     */
    protected function rollbackTransaction()
    {
        foreach ($this->drivers as $driver) {
            $driver->rollbackTransaction();
        }
    }

    /**
     * Collecting all involved drivers.
     */
    private function collectDrivers()
    {
        foreach ($this->tables as $table) {
            if (!in_array($table->getDriver(), $this->drivers, true)) {
                $this->drivers[] = $table->getDriver();
            }
        }
    }

    /**
     * @param LoggerInterface $logger
     */
    private function dropForeigns(LoggerInterface $logger)
    {
        foreach ($this->sortedTables() as $table) {
            if ($table->exists()) {
                $table->save(Behaviour::DROP_FOREIGNS, $logger, false);
            }
        }
    }

    /**
     * @param LoggerInterface $logger
     */
    private function dropIndexes(LoggerInterface $logger)
    {
        foreach ($this->sortedTables() as $table) {
            if ($table->exists()) {
                $table->save(Behaviour::DROP_INDEXES, $logger, false);
            }
        }

    }

    /**
     * @param LoggerInterface $logger
     */
    private function runChanges(LoggerInterface $logger)
    {
        foreach ($this->sortedTables() as $table) {
            $table->save(
                Behaviour::DO_ALL ^ Behaviour::DROP_FOREIGNS ^ Behaviour::DROP_INDEXES ^ Behaviour::CREATE_FOREIGNS,
                $logger
            );
        }
    }

    /**
     * @param LoggerInterface $logger
     */
    private function resetSchemas(LoggerInterface $logger)
    {
        foreach ($this->sortedTables() as $table) {
            $table->save(Behaviour::CREATE_FOREIGNS, $logger, true);
        }
    }
}