AbstractDatabaseManipulator::query() - Code Metrics - Inspection of "Fixed broken schema test constraints" - ntentan/yentu - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b22ee8...514d16 )

by James Ekow Abaka

created 2018-06-16 17:41 UTC

AbstractDatabaseManipulator::query() A

↳ Parent: AbstractDatabaseManipulator

Complexity

Conditions	4
Paths	8

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	4.0218

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	8
nop	2
dl	0
loc	16
ccs	8
cts	9
cp	0.8889
crap	4.0218
rs	9.2
c	0
b	0
f	0

<?php

namespace yentu\manipulators;

use clearice\io\Io;
use ntentan\atiaa\DriverFactory;
use yentu\Yentu;
use yentu\DatabaseAssertor;
use yentu\SchemaDescription;
use yentu\exceptions\DatabaseManipulatorException;
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, Io $io)

    {
        $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)

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

            $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)

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

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

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

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
        } catch (\ntentan\atiaa\exceptions\DatabaseDriverException $e) {
            throw new DatabaseManipulatorException($e->getMessage());
        }
    }

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

    public function getDefaultSchema()

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

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

        }
        return $this->assertor;
    }

    abstract protected function _addSchema($name);


    abstract protected function _dropSchema($name);


    abstract protected function _addTable($details);


    abstract protected function _dropTable($details);


    abstract protected function _changeTableName($details);


    abstract protected function _addColumn($details);


    abstract protected function _changeColumnNulls($details);


    abstract protected function _changeColumnName($details);


    abstract protected function _changeColumnDefault($details);


    abstract protected function _dropColumn($details);


    abstract protected function _addPrimaryKey($details);


    abstract protected function _dropPrimaryKey($details);


    abstract protected function _addUniqueKey($details);


    abstract protected function _dropUniqueKey($details);


    abstract protected function _addAutoPrimaryKey($details);


    abstract protected function _dropAutoPrimaryKey($details);


    abstract protected function _addForeignKey($details);


    abstract protected function _dropForeignKey($details);


    abstract protected function _addIndex($details);


    abstract protected function _dropIndex($details);


    abstract protected function _addView($details);


    abstract protected function _dropView($details);


    abstract protected function _changeViewDefinition($details);


    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)

    {
        
    }

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


    /**
     * 
     * @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));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function getVersion()

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

    public function getLastSession()

    {
        $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)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        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(Io::OUTPUT_LEVEL_0);
            $this->addTable(array('schema' => '', 'name' => 'yentu_history'));


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

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

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

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

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

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

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

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

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

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

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

}


1		<?php
2
3		namespace yentu\manipulators;
4
5		use clearice\io\Io;
6		use ntentan\atiaa\DriverFactory;
7		use yentu\Yentu;
8		use yentu\DatabaseAssertor;
9		use yentu\SchemaDescription;
10		use yentu\exceptions\DatabaseManipulatorException;
11		use yentu\Parameters;
12
13		abstract class AbstractDatabaseManipulator
14		{
15
16		const CONVERT_TO_DRIVER = 'driver';
17		const CONVERT_TO_YENTU = 'yentu';
18
19		private $schemaDescription;
20		private $assertor;
21		private $connection;
22		private $dumpQuery;
23		private $disableQuery;
24		protected $defaultSchema;
25		private $io;
26
27	33	public function __construct(Yentu $yentu, DriverFactory $driverFactory, Io $io)
		0 ignored issues – show Unused Code introduced 2017-09-23 16:38 UTC by Report Bug Copy Issue Report The parameter `$yentu` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
28		{
29	33	$this->connection = $driverFactory->createDriver();
30	33	$this->connection->connect();
31	33	$this->io = $io;
32	33	}
33
34	33	public function __get($name)
35		{
36	33	if ($name === 'description') {
37	33	return $this->getDescription();
38		}
39		}

ntentan / yentu

Push — master ( b22ee8...514d16 )

AbstractDatabaseManipulator::query() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like