yentu\manipulators\AbstractDatabaseManipulator

Complexity

Total Complexity

32

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	6

Test Coverage

Coverage

78.72%

Importance

Changes

0

44 Methods

Rating	Name	Duplication	Size	Complexity
	_addSchema()	0	1	?
	_dropSchema()	0	1	?
	_addTable()	0	1	?
	_dropTable()	0	1	?
	_changeTableName()	0	1	?
	_addColumn()	0	1	?
	_changeColumnNulls()	0	1	?
	_changeColumnName()	0	1	?
	_changeColumnDefault()	0	1	?
	_dropColumn()	0	1	?
	_addPrimaryKey()	0	1	?
	_dropPrimaryKey()	0	1	?
	_addUniqueKey()	0	1	?
	_dropUniqueKey()	0	1	?
	_addAutoPrimaryKey()	0	1	?
	_dropAutoPrimaryKey()	0	1	?
	_addForeignKey()	0	1	?
	_dropForeignKey()	0	1	?
	_addIndex()	0	1	?
	_dropIndex()	0	1	?
	_addView()	0	1	?
	_dropView()	0	1	?
	_changeViewDefinition()	0	1	?
A	_changeForeignKeyOnDelete()	0	5	1
A	_changeForeignKeyOnUpdate()	0	5	1
A	_executeQuery()	0	4	1
A	_reverseQuery()	0	4	1
	convertTypes()	0	1	?
A	getVersion()	0	5	2
A	__construct()	0	6	1
A	__get()	0	6	2
A	setDumpQuery()	0	4	1
A	setDisableQuery()	0	4	1
A	__call()	0	12	2
A	query()	0	16	4
A	disconnect()	0	4	1
A	getDefaultSchema()	0	4	1
A	getAssertor()	0	7	2
A	getDescription()	0	7	2
A	setVersion()	0	4	1
A	getLastSession()	0	5	2
A	getSessionVersions()	0	13	2
A	createHistory()	0	20	2
A	__clone()	0	6	2

<?php

namespace yentu\manipulators;

use ntentan\atiaa\DriverFactory;
use clearice\ConsoleIO;
use yentu\Yentu;
use yentu\DatabaseAssertor;
use yentu\SchemaDescription;
use yentu\Parameters;

abstract class AbstractDatabaseManipulator
{

    const CONVERT_TO_DRIVER = 'driver';
    const CONVERT_TO_YENTU = 'yentu';

    private $schemaDescription;
    private $assertor;
    private $connection;
    private $dumpQuery;
    private $disableQuery;
    protected $defaultSchema;
    private $io;

    public function __construct(Yentu $yentu, DriverFactory $driverFactory, ConsoleIO $io)

The parameter $yentu is not used and could be removed.

    {
        $this->connection = $driverFactory->createDriver();
        $this->connection->connect();
        $this->io = $io;
    }

    public function __get($name)
    {
        if ($name === 'description') {
            return $this->getDescription();
        }
    }

    public function setDumpQuery($dumpQuery)
    {
        $this->dumpQuery = $dumpQuery;
    }

    public function setDisableQuery($disableQuery)
    {
        $this->disableQuery = $disableQuery;
    }

    public function __call($name, $arguments)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (preg_match("/^(add|drop|change|executeQuery|reverseQuery)/", $name)) {
            $details = Parameters::wrap($arguments[0]);
            $this->description->$name($details);

The property description does not seem to exist. Did you mean schemaDescription?

            $name = "_$name";
            new \ReflectionMethod($this, $name);
            return $this->$name($details);
        } else {
            throw new \Exception("Failed to execute method '$name'");
        }
    }

    public function query($query, $bind = false)

The return type could not be reliably inferred; please add a @return annotation.

    {
        try {
            if ($this->dumpQuery) {
                echo "$query\n";
            }

            $this->io->output("\n    > Running Query [$query]", ConsoleIO::OUTPUT_LEVEL_3);

            if ($this->disableQuery !== true) {
                return $this->connection->query($query, $bind);

$bind is of type boolean, but the function expects a false|array<integer,*>.

            }
        } catch (\ntentan\atiaa\exceptions\DatabaseDriverException $e) {
            throw new exceptions\DatabaseManipulatorException($e->getMessage());
        }
    }

    public function disconnect()
    {
        $this->connection->disconnect();
    }

    public function getDefaultSchema()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->connection->getDefaultSchema();
    }

    public function getAssertor()
    {
        if (!is_object($this->assertor)) {
            $this->assertor = new DatabaseAssertor($this->description);

The property description does not seem to exist. Did you mean schemaDescription?

        }
        return $this->assertor;
    }

    abstract protected function _addSchema($name);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropSchema($name);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addTable($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropTable($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _changeTableName($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addColumn($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _changeColumnNulls($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _changeColumnName($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _changeColumnDefault($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropColumn($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addPrimaryKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropPrimaryKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addUniqueKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropUniqueKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addAutoPrimaryKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropAutoPrimaryKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addForeignKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropForeignKey($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addIndex($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropIndex($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _addView($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _dropView($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    abstract protected function _changeViewDefinition($details);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    protected function _changeForeignKeyOnDelete($details)
    {
        $this->_dropForeignKey($details['from']);
        $this->_addForeignKey($details['to']);
    }

    protected function _changeForeignKeyOnUpdate($details)
    {
        $this->_dropForeignKey($details['from']);
        $this->_addForeignKey($details['to']);
    }

    protected function _executeQuery($details)
    {
        $this->query($details['query'], $details['bind'] ?? []);
    }

    protected function _reverseQuery($details)

The parameter $details is not used and could be removed.

    {
        
    }

    abstract public function convertTypes($type, $direction, $length);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    /**
     * 
     * @return SchemaDescription
     */
    public function getDescription()
    {
        if (!is_object($this->schemaDescription)) {
            $this->schemaDescription = SchemaDescription::wrap($this->connection->describe(), $this);
        }
        return $this->schemaDescription;
    }

    public function setVersion($version)
    {
        $this->query('INSERT INTO yentu_history(version) values (?)', array($version));

array($version) is of type array<integer,?,{"0":"?"}>, but the function expects a boolean.

    }

    public function getVersion()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $version = $this->query("SELECT MAX(version) as version FROM yentu_history");
        return isset($version[0]) ? $version[0]['version'] : null;
    }

    public function getLastSession()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $session = $this->query("SELECT session FROM yentu_history ORDER BY id DESC LIMIT 1");
        return isset($session[0]['session']) ? $session[0]['session'] : null;
    }

    public function getSessionVersions($session)
    {
        $sessionVersions = array();
        $versions = $this->query(
            "SELECT DISTINCT version FROM yentu_history WHERE session = ?", array($session)

array($session) is of type array<integer,?,{"0":"?"}>, but the function expects a boolean.

        );

        foreach ($versions as $version) {
            $sessionVersions[] = $version['version'];
        }

        return $sessionVersions;
    }

    public function createHistory()
    {
        try {
            $this->connection->describeTable('yentu_history');
        } catch (\ntentan\atiaa\exceptions\TableNotFoundException $e) {
            $this->io->pushOutputLevel(ConsoleIO::OUTPUT_LEVEL_0);
            $this->addTable(array('schema' => '', 'name' => 'yentu_history'));

The method addTable() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addTable()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'session', 'type' => 'string'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => false, 'length' => null, 'table' => 'yentu_history', 'name' => 'version', 'type' => 'string'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'method', 'type' => 'string'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'arguments', 'type' => 'text'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'migration', 'type' => 'string'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'default_schema', 'type' => 'string'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addColumn(array('default' => null, 'schema' => '', 'nulls' => true, 'length' => null, 'table' => 'yentu_history', 'name' => 'id', 'type' => 'integer'));

The method addColumn() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addColumn()?

            $this->addPrimaryKey(array('schema' => '', 'table' => 'yentu_history', 'name' => 'yentu_history_pk', 'columns' => array('id')));

The method addPrimaryKey() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addPrimaryKey()?

            $this->addAutoPrimaryKey(array('schema' => '', 'table' => 'yentu_history', 'column' => 'id'));

The method addAutoPrimaryKey() does not exist on yentu\manipulators\AbstractDatabaseManipulator. Did you maybe mean _addAutoPrimaryKey()?

            $this->io->popOutputLevel();
        }
    }

    public function __clone()
    {
        if (is_object($this->schemaDescription)) {
            $this->schemaDescription = clone $this->schemaDescription;
        }
    }

}