Hgraca\MicroOrm\DataSource\Pdo\PdoClient

Complexity

Total Complexity

44

Size/Duplication

Total Lines	264
Duplicated Lines	6.06 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

99.13%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	select()	0	10	3
A	insert()	0	6	1
A	update()	8	8	2
A	delete()	8	8	2
A	executeQuery()	0	4	1
A	executeCommand()	0	4	1
A	getLastInsertId()	0	4	1
A	execute()	0	18	2
A	fetchData()	0	8	2
A	createSqlFilter()	0	14	3
B	createColumnFilter()	0	18	5
A	createSqlOrderBy()	0	13	3
A	createInsertSql()	0	8	1
A	createUpdateSql()	0	10	2
C	resolvePdoType()	0	26	7
A	bindParameterList()	0	13	4
A	bindParameter()	0	15	3

<?php
namespace Hgraca\MicroOrm\DataSource\Pdo;

use Hgraca\MicroOrm\DataSource\ClientInterface;
use Hgraca\MicroOrm\DataSource\Exception\BindingMicroOrmException;
use Hgraca\MicroOrm\DataSource\Exception\ExecutionMicroOrmException;
use Hgraca\MicroOrm\DataSource\Exception\TypeResolutionMicroOrmException;
use PDO;
use PDOStatement;

class PdoClient implements ClientInterface
{
    const POSTFIX_FILTER = '_filter';

    /** @var PDO */
    private $pdo;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
    }

    /**
     * @throws BindingMicroOrmException
     * @throws ExecutionMicroOrmException
     */
    public function select(string $table, array $filter = [], array $orderBy = [], string $classFqcn = ''): array
    {
        $sqlSelect = "SELECT * FROM `$table`";
        $sqlFilter = $this->createSqlFilter($filter);
        $sqlOrderBy = $this->createSqlOrderBy($orderBy);

        $sql = $sqlSelect . ($sqlFilter ? ' ' . $sqlFilter : '') . ($sqlOrderBy ? ' ' . $sqlOrderBy : '');

        return $this->executeQuery($sql, $filter, $classFqcn);
    }

    /**
     * @param string $table
     * @param array  $data [$columnName => $value, ...]
     *
     * @return int The nbr of affected rows
     */
    public function insert(string $table, array $data): int
    {
        $sql = $this->createInsertSql($table, $data);

        return $this->executeCommand($sql, [], $data);
    }

    /**
     * @param string $table
     * @param array  $data [$columnName => $value, ...]
     *
     * @return int The nbr of affected rows
     */
    public function update(string $table, array $filter = [], array $data = []): int

This method seems to be duplicated in your project.

    {
        $sqlUpdate = $this->createUpdateSql($table, $data);
        $sqlFilter = $this->createSqlFilter($filter);
        $sql = $sqlUpdate . ($sqlFilter ? ' ' . $sqlFilter : '');

        return $this->executeCommand($sql, $filter, $data);
    }

    /**
     * @return int The nbr of affected rows
     */
    public function delete(string $table, array $filter = []): int

This method seems to be duplicated in your project.

    {
        $sqlDelete = "DELETE FROM `$table`";
        $sqlFilter = $this->createSqlFilter($filter);
        $sql = $sqlDelete . ($sqlFilter ? ' ' . $sqlFilter : '');

        return $this->executeCommand($sql, $filter);
    }

    /**
     * @throws BindingMicroOrmException
     * @throws ExecutionMicroOrmException
     *
     * @return array The result list
     */
    public function executeQuery(string $sql, array $filterList = [], string $classFqcn = null): array
    {
        return $this->fetchData($this->execute($sql, $filterList), $classFqcn);
    }

    /**
     * @throws BindingMicroOrmException
     * @throws ExecutionMicroOrmException
     *
     * @return int The nbr of affected rows
     */
    public function executeCommand(string $sql, array $filterList = [], array $dataList = []): int
    {
        return $this->execute($sql, $filterList, $dataList)->rowCount();
    }

    public function getLastInsertId(string $idName = null): string
    {
        return $this->pdo->lastInsertId($idName);
    }

    /**
     * @throws BindingMicroOrmException
     * @throws ExecutionMicroOrmException
     *
     * @return PDOStatement
     */
    private function execute(string $sql, array $filterList = [], array $dataList = []): PDOStatement
    {
        $stmt = $this->pdo->prepare($sql);

        $this->bindParameterList($stmt, $filterList, self::POSTFIX_FILTER);
        $this->bindParameterList($stmt, $dataList);

        $executed = $stmt->execute();
        if (false === $executed) {
            throw new ExecutionMicroOrmException(
                "Could not execute query: '$sql'"
                . " Error code: " . $stmt->errorCode()
                . " Error Info: " . json_encode($stmt->errorInfo())
            );
        }

        return $stmt;
    }

    private function fetchData(PDOStatement $stmt, string $classFqcn = null): array
    {
        if (! empty($classFqcn)) {
            return $stmt->fetchAll(PDO::FETCH_CLASS, $classFqcn);
        }

        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    private function createSqlFilter(array $filterByColumnNames = []): string
    {
        if (empty($filterByColumnNames)) {
            return '';
        }

        $sqlFilter = [];
        foreach ($filterByColumnNames as $columnName => $value) {
            $sqlFilter[] = $this->createColumnFilter($columnName, $value);
        }
        $sqlFilter = 'WHERE ' . implode(' AND ', $sqlFilter);

        return $sqlFilter;
    }

    private function createColumnFilter(string $columnName, $value, string $parameterName = null)
    {
        $parameterName = $parameterName ?? $columnName;

        if (null === $value) {
            return "`$columnName` IS :$parameterName" . self::POSTFIX_FILTER;
        }

        if (is_array($value)) {
            $filter = [];
            foreach ($value as $filterName => $filterValue) {
                $filter[] = $this->createColumnFilter($columnName, $filterValue, $filterName);
            }
            return empty($filter) ? '' : '(' . implode(' OR ', $filter) . ')';
        }

        return "`$columnName`=:$parameterName" . self::POSTFIX_FILTER;
    }

    private function createSqlOrderBy(array $orderBy = []): string
    {
        if (empty($orderBy)) {
            return '';
        }

        $orderByItems = [];
        foreach ($orderBy as $column => $direction) {
            $orderByItems[] = $column . ' ' . $direction;
        }

        return 'ORDER BY ' . implode(', ', $orderByItems);
    }

    private function createInsertSql(string $tableName, array $dataList): string
    {
        $columnNamesArray = array_keys($dataList);
        $columnNamesList = "`" . implode("`, `", $columnNamesArray) . "`";
        $columnPlaceholdersList = ":" . implode(", :", $columnNamesArray);

        return "INSERT INTO `$tableName` ($columnNamesList) VALUES ($columnPlaceholdersList)";
    }

    private function createUpdateSql(string $tableName, array $parameterList): string
    {
        $setColumnsList = [];
        foreach ($parameterList as $columnName => $columnValue) {
            $setColumnsList[] = '`' . $columnName . '`=:' . $columnName;
        }
        $setColumnsList = implode(', ', $setColumnsList);

        return "UPDATE `$tableName` SET $setColumnsList";
    }

    /**
     * @param mixed $value
     *
     * @throws TypeResolutionMicroOrmException
     */
    private function resolvePdoType($value): int
    {
        $type = gettype($value);
        switch ($type) {
            case 'boolean':
                $pdoType = PDO::PARAM_BOOL;
                break;
            case 'string' :

There must be no space before the colon in a CASE statement

            case 'double': // float
                $pdoType = PDO::PARAM_STR;
                break;
            case 'integer':
                $pdoType = PDO::PARAM_INT;
                break;
            case 'NULL':
                $pdoType = PDO::PARAM_NULL;
                break;
            case 'object':
                $class = get_class($value);
                throw new TypeResolutionMicroOrmException("Invalid type '$class' for query filter.");
            default:
                throw new TypeResolutionMicroOrmException("Invalid type '$type' for query filter.");
        }

        return $pdoType;
    }

    /**
     * @throws BindingMicroOrmException
     */
    private function bindParameterList(PDOStatement $stmt, array $parameterList, string $postfix = '')
    {
        foreach ($parameterList as $name => $value) {
            if (is_array($value)) {
                /** @var array $value */
                foreach ($value as $filterName => $filterValue) {
                    $this->bindParameter($stmt, $filterName, $filterValue, $postfix);
                }
            } else {
                $this->bindParameter($stmt, $name, $value, $postfix);
            }
        }
    }

    /**
     * @throws BindingMicroOrmException
     */
    private function bindParameter(PDOStatement $stmt, string $name, $value, string $postfix = '')
    {
        $pdoType = $this->resolvePdoType($value);
        $bound = $stmt->bindValue(
            ':' . $name . $postfix,
            $pdoType === PDO::PARAM_STR ? strval($value) : $value,
            $pdoType
        );

        if (false === $bound) {
            throw new BindingMicroOrmException(
                "Could not bind value: " . json_encode(['name' => $name, 'value' => $value, 'type' => $pdoType])
            );
        }
    }
}