Doctrine\DBAL\Driver\WrappedPDOConnection

Complexity

Total Complexity

21

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Test Coverage

Coverage

50%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	fromInstance()	0	9	2
A	exec()	0	6	2
A	errorInfo()	0	3	1
A	__construct()	0	3	1
A	prepare()	0	9	2
A	query()	0	11	2
A	requiresQueryForServerVersion()	0	3	1
A	rollBack()	0	3	1
A	setAttribute()	0	3	1
A	errorCode()	0	3	1
A	quote()	0	3	1
A	commit()	0	3	1
A	getServerVersion()	0	3	1
A	lastInsertId()	0	10	3
A	beginTransaction()	0	3	1

<?php
declare(strict_types=1);

namespace Doctrine\DBAL\Driver;

use Doctrine\DBAL\ParameterType;
use PDO;
use function assert;
use function func_get_args;

final class WrappedPDOConnection implements Connection, ServerInfoAwareConnection
{
    /** @var PDO */
    private $connection;

    private function __construct(PDO $connection)
    {
        $this->connection = $connection;
    }

    public static function fromInstance(PDO $connection) : self
    {
        try {
            $connection->setAttribute(PDO::ATTR_STATEMENT_CLASS, [PDOStatement::class, []]);
            $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

            return new self($connection);
        } catch (\PDOException $exception) {
            throw new PDOException($exception);
        }
    }

    public function setAttribute(int $attribute, $value) : bool
    {
        return $this->connection->setAttribute($attribute, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function prepare($prepareString)
    {
        try {
            $stmt = $this->connection->prepare($prepareString);
            assert($stmt instanceof PDOStatement);

            return $stmt;
        } catch (\PDOException $exception) {
            throw new PDOException($exception);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function query()
    {
        $args = func_get_args();

        try {
            $stmt = $this->connection->query(...$args);

$args is expanded, but the parameter $statement of PDO::query() does not expect variable arguments.

            assert($stmt instanceof PDOStatement);

            return $stmt;
        } catch (\PDOException $exception) {
            throw new PDOException($exception);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function quote($input, $type = ParameterType::STRING)
    {
        return $this->connection->quote($input, $type);
    }

    /**
     * {@inheritdoc}
     */
    public function exec($statement)
    {
        try {
            return $this->connection->exec($statement);
        } catch (\PDOException $exception) {
            throw new PDOException($exception);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function lastInsertId($name = null)
    {
        try {
            if ($name === null) {
                return $this->connection->lastInsertId();
            }

            return $this->connection->lastInsertId($name);
        } catch (\PDOException $exception) {
            throw new PDOException($exception);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function beginTransaction()
    {
        return $this->connection->beginTransaction();
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        return $this->connection->commit();
    }

    /**
     * {@inheritdoc}
     */
    public function rollBack()
    {
        return $this->connection->rollBack();
    }

    /**
     * {@inheritdoc}
     */
    public function errorCode()
    {
        return $this->connection->errorCode();
    }

    /**
     * {@inheritdoc}
     */
    public function errorInfo()
    {
        return $this->connection->errorInfo();
    }

    /**
     * {@inheritdoc}
     */
    public function getServerVersion()
    {
        return $this->connection->getAttribute(PDO::ATTR_SERVER_VERSION);
    }

    /**
     * {@inheritdoc}
     */
    public function requiresQueryForServerVersion()
    {
        return false;
    }
}