AgelxNash\Modx\Evo\Database\AbstractDatabase

Complexity

Total Complexity

76

Size/Duplication

Total Lines	492
Duplicated Lines	0 %

Test Coverage

Coverage

96.34%

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	connect()	0	16	2
A	truncate()	0	5	2
A	makeArray()	0	11	4
A	save()	0	15	4
A	disconnect()	0	8	1
A	isResult()	0	3	1
A	getFullTableName()	0	9	2
A	getLastErrorNo()	0	3	1
A	getColumnNames()	0	6	2
A	getDriver()	0	3	1
A	delete()	0	9	2
A	getValue()	0	8	2
A	selectDb()	0	9	1
A	optimize()	0	8	3
A	fieldName()	0	3	1
A	getRecordCount()	0	3	1
B	query()	0	29	4
A	getTableMetaData()	0	10	2
A	getTableName()	0	9	3
A	setDriver()	0	16	3
A	getVersion()	0	3	1
A	numFields()	0	3	1
A	getAffectedRows()	0	3	1
A	getInsertId()	0	4	1
A	select()	0	9	1
A	alterTable()	0	5	2
B	escape()	0	19	5
A	update()	0	11	3
A	getLastError()	0	3	1
A	getColumn()	0	7	2
C	insert()	0	49	13
A	setCharset()	0	3	1
A	getRow()	0	7	2

<?php namespace AgelxNash\Modx\Evo\Database;

abstract class AbstractDatabase implements Interfaces\DatabaseInterface, Interfaces\DebugInterface
{
    use Traits\DebugTrait,
        Traits\SupportTrait,
        Traits\ConfigTrait;

    /**
     * @var Interfaces\DriverInterface
     */
    protected $driver;

    /**
     * @var int
     */
    protected $safeLoopCount = 1000;

    /**
     * {@inheritDoc}
     */
    public function getLastError()
    {
        return $this->getDriver()->getLastError();
    }

    /**
     * {@inheritDoc}
     */
    public function getLastErrorNo()
    {
        return (string)$this->getDriver()->getLastErrorNo();
    }

    /**
     * {@inheritDoc}
     */
    public function connect()
    {
        $tStart = microtime(true);

        $out = $this->getDriver()->getConnect();

        $totalTime = microtime(true) - $tStart;
        if ($this->isDebug()) {
            $this->setConnectionTime($totalTime);
        }
        $this->setCharset(
            $this->getConfig('charset'),
            $this->getConfig('method')
        );

        return $out;
    }

    /**
     * {@inheritDoc}
     */
    public function disconnect()
    {
        $this->getDriver()->disconnect();

        $this->setConnectionTime(0);
        $this->flushExecutedQuery();

        return $this;

The expression return $this returns the type AgelxNash\Modx\Evo\Database\AbstractDatabase which is incompatible with the return type mandated by AgelxNash\Modx\Evo\Database\Interfaces\ProxyInterface::disconnect() of AgelxNash\Modx\Evo\Database\Interfaces\DriverInterface.

    }

    /**
     * {@inheritDoc}
     */
    public function isResult($result)
    {
        return $this->getDriver()->isResult($result);
    }

    /**
     * {@inheritDoc}
     */
    public function numFields($result)
    {
        return $this->getDriver()->numFields($result);
    }

    /**
     * {@inheritDoc}
     */
    public function fieldName($result, $col = 0)
    {
        return $this->getDriver()->fieldName($result, $col);
    }

    /**
     * {@inheritDoc}
     */
    public function setCharset($charset, $method = null)
    {
        return $this->getDriver()->setCharset($charset, $method);
    }

    /**
     * {@inheritDoc}
     */
    public function selectDb($name)
    {
        $tStart = microtime(true);

        $result = $this->getDriver()->selectDb($name);

        $this->addQueriesTime(microtime(true) - $tStart);

        return $result;
    }

    /**
     * {@inheritDoc}
     * @throws Exceptions\TooManyLoopsException
     */
    public function escape($data, $safeCount = 0)
    {
        $safeCount++;
        if ($this->safeLoopCount < $safeCount) {
            throw new Exceptions\TooManyLoopsException("Too many loops '{$safeCount}'");
        }
        if (\is_array($data)) {
            if (\count($data) === 0) {
                $data = '';
            } else {
                foreach ($data as $i => $v) {
                    $data[$i] = $this->escape($v, $safeCount);
                }
            }
        } else {
            $data = $this->getDriver()->escape($data);
        }

        return $data;
    }

    /**
     * @param string|array $sql
     * {@inheritDoc}
     */
    public function query($sql)
    {
        $tStart = microtime(true);
        if (\is_array($sql)) {
            $sql = implode("\n", $sql);
        }
        $this->setLastQuery($sql);

        $result = $this->getDriver()->query(
            $this->getLastQuery()
        );

        if ($result === false) {
            $this->checkLastError($this->getLastQuery());
        } else {
            $tend = microtime(true);
            $totalTime = $tend - $tStart;
            $this->addQueriesTime($totalTime);
            if ($this->isDebug()) {
                $this->collectQuery(
                    $result,
                    $this->getLastQuery(),
                    $totalTime
                );
            }

            return $result;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function getRecordCount($result)
    {
        return $this->getDriver()->getRecordCount($result);
    }

    /**
     * {@inheritDoc}
     */
    public function getRow($result, $mode = 'assoc')
    {
        if (\is_scalar($result)) {
            $result = $this->query($result);
        }

        return $this->getDriver()->getRow($result, $mode);
    }

    /**
     * {@inheritDoc}
     */
    public function getVersion()
    {
        return $this->getDriver()->getVersion();
    }

    /**
     * {@inheritDoc}
     */
    public function getInsertId()
    {
        return $this->convertValue(
            $this->getDriver()->getInsertId()
        );
    }

    /**
     * {@inheritDoc}
     */
    public function getAffectedRows()
    {
        return $this->getDriver()->getAffectedRows();
    }

    /**
     * {@inheritDoc}
     */
    public function getColumn($name, $result)
    {
        if (\is_scalar($result)) {
            $result = $this->query($result);
        }

        return $this->getDriver()->getColumn($name, $result);
    }

    /**
     * {@inheritDoc}
     */
    public function getColumnNames($result)
    {
        if (\is_scalar($result)) {
            $result = $this->query($result);
        }
        return $this->getDriver()->getColumnNames($result);
    }

    /**
     * {@inheritDoc}
     */
    public function getValue($result)
    {
        if (\is_scalar($result)) {
            $result = $this->query($result);
        }

        return $this->convertValue(
            $this->getDriver()->getValue($result)
        );
    }

    /**
     * {@inheritDoc}
     */
    public function getTableMetaData($table)
    {
        $metadata = [];
        if (! empty($table)) {
            $sql = 'SHOW FIELDS FROM ' . $table;
            $result = $this->query($sql);
            $metadata = $this->getDriver()->getTableMetaData($result);
        }

        return $metadata;
    }

    /**
     * {@inheritDoc}
     */
    public function getDriver()
    {
        return $this->driver;
    }

    /**
     * {@inheritDoc}
     */
    public function setDriver($driver)
    {
        if (! \in_array(Interfaces\DriverInterface::class, class_implements($driver), true)) {
            throw new Exceptions\DriverException(
                $driver . ' should implements the ' . Interfaces\DriverInterface::class
            );
        }

        if (is_scalar($driver)) {
            $this->driver = new $driver($this->getConfig());
        } else {
            $this->driver = $driver;
            $this->config = array_merge($this->config, $driver->getConfig());
        }

        return $this->driver;
    }

    /**
     * {@inheritDoc}
     */
    public function makeArray($result, $index = false)
    {
        $rsArray = [];
        $iterator = 0;
        while ($row = $this->getRow($result)) {
            $returnIndex = $index !== false && isset($row[$index]) ? $row[$index] : $iterator;
            $rsArray[$returnIndex] = $row;
            $iterator++;
        }

        return $rsArray;
    }

    /**
     * {@inheritDoc}
     */
    public function delete($table, $where = '', $orderBy = '', $limit = '')
    {
        $table = $this->prepareFrom($table);
        $where = $this->prepareWhere($where);
        $orderBy = $this->prepareOrder($orderBy);
        $limit = $this->prepareLimit($limit);

        $result = $this->query("DELETE FROM {$table} {$where} {$orderBy} {$limit}");
        return $this->isResult($result) ? true : $result;
    }

    /**
     * {@inheritDoc}
     */
    public function select($fields, $tables, $where = '', $orderBy = '', $limit = '')
    {
        $fields = $this->prepareFields($fields);
        $tables = $this->prepareFrom($tables, true);
        $where = $this->prepareWhere($where);
        $orderBy = $this->prepareOrder($orderBy);
        $limit = $this->prepareLimit($limit);

        return $this->query("SELECT {$fields} FROM {$tables} {$where} {$orderBy} {$limit}");
    }

    /**
     * {@inheritDoc}
     */
    public function update($values, $table, $where = '')
    {
        $table = $this->prepareFrom($table);
        $values = $this->prepareValuesSet($values);
        if (mb_strtoupper(mb_substr($values, 0, 4)) !== 'SET ') {
            $values = 'SET ' . $values;
        }
        $where = $this->prepareWhere($where);

        $result = $this->query("UPDATE {$table} {$values} {$where}");
        return $this->isResult($result) ? true : $result;
    }

    /**
     * {@inheritDoc}
     */
    public function insert(
        $fields,
        $table,
        $fromFields = '*',
        $fromTable = '',
        $where = '',
        $limit = ''
    ) {
        $table = $this->prepareFrom($table);

        $useFields = null;
        $lid = null;

        if (\is_array($fields)) {
            $useFields = empty($fromTable) ?
                $this->prepareValues($fields) :
                $this->prepareFields($fields, true);
        } else {
            $useFields = $fields;
        }

        if (empty($useFields) || ! \is_scalar($useFields) || ($useFields === '*' && ! empty($fromTable))) {
            throw (new Exceptions\InvalidFieldException('Invalid insert fields'))
                ->setData($fields);
        }

        if (empty($fromTable)) {
            $this->query("INSERT INTO {$table} {$useFields}");
        } else {
            if (empty($fromFields) || $fromFields === '*') {
                $fromFields = $this->prepareFields($fields, true);
            } else {
                $fromFields = $this->prepareFields($fromFields, true);
            }

            $where = $this->prepareWhere($where);
            $limit = $this->prepareLimit($limit);

            $lid = $this->query(
                "INSERT INTO {$table} ({$useFields}) SELECT {$fromFields} FROM {$fromTable} {$where} {$limit}"
            );
            $lid = $this->isResult($lid) ? true : $lid;
        }

        if ($lid === null && ($lid = $this->getInsertId()) === false) {
            throw new Exceptions\GetDataException("Couldn't get last insert key!");
        }

        return $this->convertValue($lid);
    }

    /**
     * {@inheritDoc}
     */
    public function save($fields, $table, $where = '')
    {
        if ($where === '') {
            $mode = 'insert';
        } else {
            $result = $this->select('*', $table, $where);

            if ($this->getRecordCount($result) === 0) {
                $mode = 'insert';
            } else {
                $mode = 'update';
            }
        }

        return ($mode === 'insert') ? $this->insert($fields, $table) : $this->update($fields, $table, $where);
    }

    /**
     * {@inheritDoc}
     */
    public function optimize($table)
    {
        $result = $this->query('OPTIMIZE TABLE ' . $table);
        if ($result !== false) {
            $result = $this->alterTable($table);
        }

        return $this->isResult($result) ? true : $result;
    }

    /**
     * {@inheritDoc}
     */
    public function alterTable($table)
    {
        $result = $this->query('ALTER TABLE ' . $table);

        return $this->isResult($result) ? true : $result;
    }

    /**
     * {@inheritDoc}
     */
    public function truncate($table)
    {
        $result = $this->query('TRUNCATE ' . $table);

        return $this->isResult($result) ? $this->getValue($result) : $result;
    }

    /**
     * {@inheritDoc}
     */
    public function getTableName($table, $escape = true)
    {
        if (empty($table)) {
            throw new Exceptions\TableNotDefinedException($table);
        }

        $out = $this->getConfig('prefix') . $table;

        return $escape ? '`' . $out . '`' : $out;
    }

    /**
     * {@inheritDoc}
     */
    public function getFullTableName($table)
    {
        if (empty($table)) {
            throw new Exceptions\TableNotDefinedException($table);
        }

        return implode('.', [
            '`' . $this->getConfig('database') . '`',
            $this->getTableName($table)
        ]);
    }
}