App\Component\Db\Core

Complexity

Total Complexity

17

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	bindArray()	0	20	7
A	run()	0	29	5
A	getRowset()	0	3	1
A	hydrate()	0	7	2
A	__construct()	0	3	1
A	fromOrm()	0	11	1

<?php

namespace App\Component\Db;

use App\Component\Model\Orm\Orm;
use App\Component\Db\Factory;

class Core
{
    /**
     * connection
     *
     * @var \PDO | boolean
     */
    protected $connection;

    /**
     * logger
     *
     * @var \Monolog\Logger
     */
    protected $logger;

    /**
     * sql
     *
     * @var string
     */
    protected $sql;

    /**
     * statement
     *
     * @var \PDOStatement
     */
    protected $statement;

    /**
     * fetch mode
     *
     * @var int
     */
    protected $fetchMode = \PDO::FETCH_ASSOC;

    /**
     * database name
     *
     * @var string
     */
    protected $database;

    /**
     * rowset result
     *
     * @var array
     */
    protected $rowset;

    /**
     * instanciate
     */
    public function __construct()
    {
        $this->rowset = [];
    }

    /**
     * set connection from Orm instance
     *
     * @param Orm $ormInstance
     * @return Core
     */
    public function fromOrm(Orm &$ormInstance): Core
    {
        $this->database = $ormInstance->getDatabase();
        $container = $ormInstance->getContainer();
        $this->logger = $container->getService(\Monolog\Logger::class);
        $factory = new Factory($container);
        $this->connection = $factory->getConnection(
            $ormInstance->getSlot(),
            $this->database
        );
        return $this;
    }

    /**
     * run query with bind values and types
     *
     * @param string $sql
     * @param array $bindParams
     * @param array $bindTypes
     * @return Core
     */
    public function run(
        string $sql,
        array $bindParams = [],
        array $bindTypes = []
    ): Core {
        $this->sql = $sql;
        try {
            $this->statement = $this->connection->prepare($sql);

It seems like $this->connection->prepare($sql) can also be of type boolean. However, the property $statement is declared as type PDOStatement. Maybe add an additional type check?

            if ($this->statement instanceof \PDOStatement) {
                $this->statement->setFetchMode($this->fetchMode);
                if (!empty($bindParams)) {
                    $this->bindArray(
                        $this->statement,
                        $bindParams,
                        $bindTypes
                    );
                }
            }
        } catch (\PDOException $exc) {
            $this->logger->alert('Prepare failed');
            $this->logger->alert($exc->getMessage());
        }
        try {
            $this->statement->execute();
        } catch (\PDOException $exc) {
            $this->logger->alert('Execute failed');
            $this->logger->alert($exc->getMessage());
        }
        return $this;
    }

    /**
     * hydrate
     *
     * @return Core
     */
    public function hydrate(): Core
    {
        if ($this->statement instanceof \PDOStatement) {

$this->statement is always a sub-type of PDOStatement.

            $this->rowset = $this->statement->fetchAll($this->fetchMode);
            $this->statement->closeCursor();
        }
        return $this;
    }

    /**
     * return run result
     *
     * @return array
     */
    public function getRowset(): array
    {
        return $this->rowset;
    }

    /**
     * bindArray
     *
     * @param \PDOStatement $poStatement
     * @param array $paArray
     * @param array $forcedTypes
     * @return $this
     */
    public function bindArray(\PDOStatement &$poStatement, array &$paArray, array $forcedTypes = [])
    {
        foreach ($paArray as $k => $v) {
            $type = (is_int($v)) ? \PDO::PARAM_INT : \PDO::PARAM_STR;

            if (isset($forcedTypes[$k])) {
                $type = $forcedTypes[$k];
                $v = ($type == \PDO::PARAM_INT) ? (int) $v : $v;
            }
            $value = is_array($v) ? serialize($v) : $v;
            $key =  $k;
            try {
                $poStatement->bindValue($key, $value, $type);
            } catch (\PDOException $exc) {
                $this->logger->alert(
                    'Sql Bind Error [' . $key . ':' . $value . ':' . $type . ']'
                );
            }
        }
        return $this;
    }
}