Reflector::sortedTables() - Code Metrics - Inspection of "Adding methods beforeSync and afterSync" - cycle/database - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 2.x (#105)

by Maxim
created 2023-03-09 13:36 UTC
Reflector::sortedTables() A

↳ Parent: Reflector
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	2
Importance

Changes
Metric	Value
cc	2
eloc	5
nc	2
nop	0
dl	0
loc	10
ccs	5
cts	5
cp	1
crap	2
rs	10
c	0
b	0
f	0
<?php

/**
 * This file is part of Cycle ORM package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cycle\Database\Schema;

use Cycle\Database\Driver\Driver;
use Cycle\Database\Driver\DriverInterface;
use Cycle\Database\Driver\HandlerInterface;
use Throwable;

/**
 * Saves multiple linked tables at once but treating their cross dependency.
 * Attention, not every DBMS support transactional schema manipulations!
 */
final class Reflector
{
    public const STATE_NEW = 1;
    public const STATE_PASSED = 2;

    /** @var AbstractTable[] */
    private array $tables = [];

    private array $dependencies = [];

    /** @var DriverInterface[] */
    private array $drivers = [];

    private array $states = [];
    private array $stack = [];

    /**
     * Add table to the collection.
     */
    public function addTable(AbstractTable $table): void
    {
        $this->tables[$table->getFullName()] = $table;
        $this->dependencies[$table->getFullName()] = $table->getDependencies();

        $this->collectDrivers();
    }

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

    /**
     * Return sorted stack.
     *
     * @return AbstractTable[]
     */
    public function sortedTables(): array
    {
        $items = array_keys($this->tables);
        $this->states = $this->stack = [];

        foreach ($items as $item) {
            $this->sort($item, $this->dependencies[$item]);
        }

        return $this->stack;
    }

    /**
     * Synchronize tables.
     *
     * @throws Throwable
     */
    public function run(): void
    {
        $hasChanges = false;
        foreach ($this->tables as $table) {
            if (
                $table->getStatus() === AbstractTable::STATUS_DECLARED_DROPPED
                || $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->dropForeignKeys();

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

            foreach ($this->sortedTables() as $table) {
                $handler = $table->getDriver()->getSchemaHandler();
                if (\method_exists($handler, 'beforeSync')) {
                    $handler->beforeSync($this->tables);
                }
            }

            //Other changes [NEW TABLES WILL BE CREATED HERE!]
            foreach ($this->commitChanges() as $table) {
                $table->save(HandlerInterface::CREATE_FOREIGN_KEYS, true);
            }

            foreach ($this->sortedTables() as $table) {
                $handler = $table->getDriver()->getSchemaHandler();

                if (\method_exists($handler, 'afterSync')) {
                    $handler->afterSync($this->tables);
                }
            }
        } catch (Throwable $e) {
            $this->rollbackTransaction();
            throw $e;
        }

        $this->commitTransaction();
    }

    /**
     * Drop all removed table references.
     */
    protected function dropForeignKeys(): void
    {
        foreach ($this->sortedTables() as $table) {
            if ($table->exists()) {
                $table->save(HandlerInterface::DROP_FOREIGN_KEYS, false);
            }
        }
    }

    /**
     * Drop all removed table indexes.
     */
    protected function dropIndexes(): void
    {
        foreach ($this->sortedTables() as $table) {
            if ($table->exists()) {
                $table->save(HandlerInterface::DROP_INDEXES, false);
            }
        }
    }

    /***
     * @return AbstractTable[] Created or updated tables.
     */
    protected function commitChanges(): array
    {
        $updated = [];
        foreach ($this->sortedTables() as $table) {
            if ($table->getStatus() === AbstractTable::STATUS_DECLARED_DROPPED) {
                $table->save(HandlerInterface::DO_DROP);
                continue;
            }

            $updated[] = $table;
            $table->save(
                HandlerInterface::DO_ALL
                ^ HandlerInterface::DROP_FOREIGN_KEYS
                ^ HandlerInterface::DROP_INDEXES
                ^ HandlerInterface::CREATE_FOREIGN_KEYS
            );
        }

        return $updated;
    }

    /**
     * Begin mass transaction.
     */
    protected function beginTransaction(): void
    {
        foreach ($this->drivers as $driver) {
            if ($driver instanceof Driver) {
                // do not cache statements for this transaction
                $driver->beginTransaction(null, false);
                         beginTransaction(null, false);
            } else {
                $driver->beginTransaction(null);
            }
        }
    }

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

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

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

    /**
     * @psalm-param non-empty-string $key
     */
    private function sort(string $key, array $dependencies): void
    {
        if (isset($this->states[$key])) {
            return;
        }

        $this->states[$key] = self::STATE_NEW;
        foreach ($dependencies as $dependency) {
            if (isset($this->dependencies[$dependency])) {
                $this->sort($dependency, $this->dependencies[$dependency]);
            }
        }

        $this->stack[] = $this->tables[$key];
        $this->states[$key] = self::STATE_PASSED;
    }
}

cycle / database

Pull Request — 2.x (#105)

Reflector::sortedTables() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
