Cycle\Database\Driver\MySQL\MySQLHandler

Complexity

Total Complexity

27

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Test Coverage

Coverage

94.34%

Importance

Changes	1
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	dropIndex()	0	4	1
A	getTableNames()	0	12	4
A	isForeignKeyExists()	0	12	2
A	alterColumn()	0	8	1
A	dropForeignKey()	0	4	1
A	assertValid()	0	11	3
A	hasTable()	0	8	1
A	beforeSync()	0	6	4
A	createStatement()	0	5	2
A	afterSync()	0	6	5
A	alterIndex()	0	6	1
A	eraseTable()	0	4	1
A	getSchema()	0	3	1

<?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;

The type Cycle\Database\Schema\AbstractColumn was not found. Maybe you did not declare it correctly or list all dependencies?

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 ?? '');

It seems like $this->driver can also be of type null; however, parameter $driver of Cycle\Database\Driver\MySQL\Schema\MySQLTable::__construct() does only seem to accept Cycle\Database\Driver\DriverInterface, maybe add an additional type check?

    }

    public function getTableNames(string $prefix = ''): array
    {
        $result = [];
        foreach ($this->driver->query('SHOW TABLES')->fetchAll(PDO::FETCH_NUM) as $row) {

The method query() does not exist on null.

            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]

The method getSource() does not exist on Cycle\Database\Driver\DriverInterface. It seems like you code against a sub-type of Cycle\Database\Driver\DriverInterface such as Cycle\Database\Driver\Driver.

        )->fetchColumn();
    }

    public function eraseTable(AbstractTable $table): void
    {
        $this->driver->execute(
            "TRUNCATE TABLE {$this->driver->identifier($table->getFullName())}"

The method identifier() does not exist on Cycle\Database\Driver\DriverInterface. It seems like you code against a sub-type of Cycle\Database\Driver\DriverInterface such as Cycle\Database\Driver\Driver.

        );
    }

    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)}"

It seems like $this->driver can also be of type null; however, parameter $driver of Cycle\Database\Schema\AbstractIndex::sqlStatement() does only seem to accept Cycle\Database\Driver\DriverInterface, maybe add an additional type check?

        );
    }

    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()}";

The method getEngine() does not exist on Cycle\Database\Schema\AbstractTable. Since you implemented __call, consider adding a @method annotation.

    }

    /**
     * @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);
                }
            }
        }
    }
}