Hgraca\MicroOrm\DataSource\Pdo\PdoClient

Complexity

Total Complexity

22

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

95.16%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	executeQuery()	0	4	1
A	executeCommand()	0	17	4
A	execute()	0	16	2
A	bindParameterList()	0	13	4
A	bindParameter()	0	15	3
C	resolvePdoType()	0	26	7

<?php

namespace Hgraca\MicroOrm\DataSource\Pdo;

use Exception;
use Hgraca\Helper\ArrayHelper;
use Hgraca\MicroOrm\DataSource\ClientInterface;
use Hgraca\MicroOrm\DataSource\Exception\BindingException;
use Hgraca\MicroOrm\DataSource\Exception\ExecutionException;
use Hgraca\MicroOrm\DataSource\Exception\TypeResolutionException;
use PDO;
use PDOStatement;

final class PdoClient implements ClientInterface
{
    /** @var PDO */
    private $pdo;

    public function __construct(PDO $pdo)
    {
        $this->pdo = $pdo;
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }

    public function executeQuery(string $sql): array
    {
        return $this->execute($sql)->fetchAll(PDO::FETCH_ASSOC);
    }

    public function executeCommand(string $sql, array $bindingsList = [])
    {
        if (!ArrayHelper::isTwoDimensional($bindingsList)) {
            $bindingsList = [$bindingsList];
        }

        try {
            $this->pdo->beginTransaction();
            foreach ($bindingsList as $bindings) {
                $preparedStatement = $this->execute($sql, $bindings, $preparedStatement ?? null);
            }
            $this->pdo->commit();
        } catch (Exception $e) {
            $this->pdo->rollBack();
            throw $e;
        }
    }

    /**
     * @throws ExecutionException
     */
    private function execute(string $sql, array $bindings = [], PDOStatement $preparedStatement = null): PDOStatement
    {
        $preparedStatement = $preparedStatement ?? $this->pdo->prepare($sql);

        $this->bindParameterList($preparedStatement, $bindings);

        if (!$preparedStatement->execute()) {
            throw new ExecutionException(
                "Could not execute query: '$sql'"
                . ' Error code: ' . $preparedStatement->errorCode()
                . ' Error Info: ' . json_encode($preparedStatement->errorInfo())
            );
        }

        return $preparedStatement;
    }

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

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

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

    /**
     * @param mixed $value
     *
     * @throws TypeResolutionException
     */
    private function resolvePdoType($value): int
    {
        $type = gettype($value);
        switch ($type) {
            case 'boolean':

case statements should be defined using a colon.

                $pdoType = PDO::PARAM_BOOL;
                break;
            case 'string':

case statements should be defined using a colon.

            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 TypeResolutionException("Invalid type '$class' for query filter.");
            default:
                throw new TypeResolutionException("Invalid type '$type' for query filter.");
        }

        return $pdoType;
    }
}