MySQLHandler::afterSync() - 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
MySQLHandler::afterSync() A

↳ Parent: MySQLHandler
Complexity

Conditions	5
Paths	4
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	30
Importance

Changes
Metric	Value
cc	5
eloc	4
nc	4
nop	1
dl	0
loc	6
ccs	0
cts	0
cp	0
crap	30
rs	9.6111
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\Driver\MySQL;

use PDO;
use Cycle\Database\Driver\Handler;
use Cycle\Database\Driver\MySQL\Exception\MySQLException;
use Cycle\Database\Driver\MySQL\Schema\MySQLTable;
use Cycle\Database\Exception\HandlerException;
use Cycle\Database\Exception\StatementException;
use Cycle\Database\Exception\SchemaException;
use Cycle\Database\Schema\AbstractColumn;
filter:
    dependency_paths: ["lib/*"]
use Cycle\Database\Schema\AbstractForeignKey;
use Cycle\Database\Schema\AbstractIndex;
use Cycle\Database\Schema\AbstractTable;

class MySQLHandler extends Handler
{
    /**
     * @psalm-param non-empty-string $table
     */
    public function getSchema(string $table, string $prefix = null): AbstractTable
    {
        return new MySQLTable($this->driver, $table, $prefix ?? '');
        return new MySQLTable(/** @scrutinizer ignore-type */ $this->driver, $table, $prefix ?? '');
    }

    public function getTableNames(string $prefix = ''): array
    {
        $result = [];
        foreach ($this->driver->query('SHOW TABLES')->fetchAll(PDO::FETCH_NUM) as $row) {
        foreach ($this->driver->/** @scrutinizer ignore-call */ query('SHOW TABLES')->fetchAll(PDO::FETCH_NUM) as $row) {
            if ($prefix !== '' && !str_starts_with($row[0], $prefix)) {
                continue;
            }

            $result[] = $row[0];
        }

        return $result;
    }

    /**
     * @psalm-param non-empty-string $table
     */
    public function hasTable(string $table): bool
    {
        $query = 'SELECT COUNT(*) FROM `information_schema`.`tables` WHERE `table_schema` = ? AND `table_name` = ?';

        return (bool)$this->driver->query(
            $query,
            [$this->driver->getSource(), $table]
            [$this->driver->/** @scrutinizer ignore-call */ getSource(), $table]
        )->fetchColumn();
    }

    public function eraseTable(AbstractTable $table): void
    {
        $this->driver->execute(
            "TRUNCATE TABLE {$this->driver->identifier($table->getFullName())}"
            "TRUNCATE TABLE {$this->driver->/** @scrutinizer ignore-call */ identifier($table->getFullName())}"
        );
    }

    public function alterColumn(
        AbstractTable $table,
        AbstractColumn $initial,
        AbstractColumn $column
    ): void {
        $this->run(
            "ALTER TABLE {$this->identify($table)}
                    CHANGE {$this->identify($initial)} {$column->sqlStatement($this->driver)}"
        );
    }

    public function dropIndex(AbstractTable $table, AbstractIndex $index): void
    {
        $this->run(
            "DROP INDEX {$this->identify($index)} ON {$this->identify($table)}"
        );
    }

    public function alterIndex(AbstractTable $table, AbstractIndex $initial, AbstractIndex $index): void
    {
        $this->run(
            "ALTER TABLE {$this->identify($table)}
                    DROP INDEX  {$this->identify($initial)},
                    ADD {$index->sqlStatement($this->driver, false)}"
                    ADD {$index->sqlStatement(/** @scrutinizer ignore-type */ $this->driver, false)}"
        );
    }

    public function dropForeignKey(AbstractTable $table, AbstractForeignKey $foreignKey): void
    {
        $this->run(
            "ALTER TABLE {$this->identify($table)} DROP FOREIGN KEY {$this->identify($foreignKey)}"
        );
    }

    public function isForeignKeyExists(AbstractTable $table, AbstractForeignKey $foreignKey): bool
    {
        try {
            $count = $this->driver->query(
                'SELECT count(`constraint_name`) as count FROM `information_schema`.`key_column_usage`
                WHERE `constraint_name` = ? AND `table_schema` = ? AND `table_name` = ?',
                [$foreignKey->getName(), $this->driver->getSource(), $table->getName()]
            )->fetchAll();

            return (int) $count[0]['count'] === 1;
        } catch (StatementException $e) {
            throw new HandlerException($e);
        }
    }

    /**
     * Get statement needed to create table.
     *
     * @throws SchemaException
     */
    protected function createStatement(AbstractTable $table): string
    {
        $table instanceof MySQLTable or throw new SchemaException('MySQLHandler can process only MySQL tables');

        return parent::createStatement($table) . " ENGINE {$table->getEngine()}";
        return parent::createStatement($table) . " ENGINE {$table->/** @scrutinizer ignore-call */ getEngine()}";
    }

    /**
     * @throws MySQLException
     */
    protected function assertValid(AbstractColumn $column): void
    {
        if (
            $column->getDefaultValue() !== null
            && \in_array(
                $column->getAbstractType(),
                ['text', 'tinyText', 'longText', 'blob', 'tinyBlob', 'longBlob']
            )
        ) {
            throw new MySQLException(
                "Column {$column} of type text/blob can not have non empty default value"
            );
        }
    }

    /**
     * @param AbstractTable[] $tables
     */
    public function beforeSync(array $tables): void
    {
        foreach ($tables as $table) {
            foreach ($table->getForeignKeys() as $foreignKey) {
                if ($this->isForeignKeyExists($table, $foreignKey)) {
                    $this->dropForeignKey($table, $foreignKey);
                }
            }
        }
    }

    /**
     * @param AbstractTable[] $tables
     */
    public function afterSync(array $tables): void
    {
        foreach ($tables as $table) {
            foreach ($table->getForeignKeys() as $foreignKey) {
                if ($table->exists() && !$this->isForeignKeyExists($table, $foreignKey)) {
                    $this->createForeignKey($table, $foreignKey);
                }
            }
        }
    }
}

cycle / database

Pull Request — 2.x (#105)

MySQLHandler::afterSync() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
