ConnectionPDO::__sleep() - Code Metrics - Inspection of "Fixes for Quoter" - yiisoft/db - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#355)

by Def

created 2022-08-28 14:27 UTC

ConnectionPDO::__sleep() A

↳ Parent: ConnectionPDO

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	6
c	0
b	0
f	0
dl	0
loc	11
rs	10
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Driver\PDO;

use PDO;
use PDOException;
use Psr\Log\LogLevel;
use Yiisoft\Db\Cache\QueryCache;
use Yiisoft\Db\Cache\SchemaCache;
use Yiisoft\Db\Connection\Connection;
use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidCallException;
use Yiisoft\Db\Exception\InvalidConfigException;
use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
use Yiisoft\Db\Schema\QuoterInterface;
use Yiisoft\Db\Schema\SchemaInterface;

use function array_keys;
use function is_string;

abstract class ConnectionPDO extends Connection implements ConnectionPDOInterface
{
    protected ?PDO $pdo = null;
    protected string $serverVersion = '';

    protected ?bool $emulatePrepare = null;

    protected ?QueryBuilderInterface $queryBuilder = null;
    protected ?QuoterInterface $quoter = null;
    protected ?SchemaInterface $schema = null;

    public function __construct(
        protected PDODriverInterface $driver,
        protected QueryCache $queryCache,
        protected SchemaCache $schemaCache
    ) {
        parent::__construct($queryCache);
    }

    /**
     * Reset the connection after cloning.
     */
    public function __clone()
    {
        $this->transaction = null;
        $this->pdo = null;
    }

    /**
     * Close the connection before serializing.
     *
     * @return array
     */
    public function __sleep(): array
    {
        $fields = (array) $this;

        unset(
            $fields["\000*\000" . 'pdo'],
            $fields["\000*\000" . 'transaction'],
            $fields["\000*\000" . 'schema']
        );

        return array_keys($fields);
    }

    public function open(): void
    {
        if (!empty($this->pdo)) {
            return;
        }

        if (empty($this->driver->getDsn())) {
            throw new InvalidConfigException('Connection::dsn cannot be empty.');
        }

        $token = 'Opening DB connection: ' . $this->driver->getDsn();

        try {
            $this->logger?->log(LogLevel::INFO, $token);
            $this->profiler?->begin($token, [__METHOD__]);
            $this->initConnection();
            $this->profiler?->end($token, [__METHOD__]);
        } catch (PDOException $e) {
            $this->profiler?->end($token, [__METHOD__]);
            $this->logger?->log(LogLevel::ERROR, $token);

            throw new Exception($e->getMessage(), (array) $e->errorInfo, $e);
        }
    }

    public function close(): void
    {
        if ($this->pdo !== null) {
            $this->logger?->log(
                LogLevel::DEBUG,
                'Closing DB connection: ' . $this->driver->getDsn() . ' ' . __METHOD__,
            );

            $this->pdo = null;
            $this->transaction = null;
        }
    }

    public function getCacheKey(): array
    {
        return [$this->driver->getDsn(), $this->driver->getUsername()];
    }

    public function getDriver(): PDODriverInterface
    {
        return $this->driver;
    }

    public function getEmulatePrepare(): ?bool
    {
        return $this->emulatePrepare;
    }

    public function getPDO(): ?PDO
    {
        return $this->pdo;
    }

    /**
     * Input variables $sql and $forRead needs for future implementation of Connection + Pool
     *
     * @param string|null $sql
     * @param bool|null $forRead
     *
     * @throws Exception
     * @throws InvalidConfigException
     *
     * @return PDO
     */
    public function getActivePDO(?string $sql = '', ?bool $forRead = null): PDO
    {
        $this->open();
        $pdo = $this->getPDO();

        if ($pdo === null) {
            throw new Exception('PDO cannot be initialized.');
        }

        return $pdo;
    }

    public function getLastInsertID(?string $sequenceName = null): string
    {
        if ($this->isActive() && $this->pdo) {
            return $this->pdo->lastInsertID($sequenceName === null
                ? null : $this->getQuoter()->quoteTableName($sequenceName));
        }

        throw new InvalidCallException('DB Connection is not active.');
    }

    public function getName(): string
    {
        return $this->driver->getDriverName();
    }

    /**
     * @throws Exception
     */
    public function getServerVersion(): string
    {
        if ($this->serverVersion === '') {
            /** @var mixed */
            $version = $this->getActivePDO()->getAttribute(PDO::ATTR_SERVER_VERSION);
            $this->serverVersion = is_string($version) ? $version : 'Version could not be determined.';
        }

        return $this->serverVersion;
    }

    public function isActive(): bool
    {
        return $this->pdo !== null;
    }

    public function setEmulatePrepare(bool $value): void
    {
        $this->emulatePrepare = $value;
    }

    abstract protected function initConnection(): void;
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Db\Driver\PDO;
6
7			use PDO;
8			use PDOException;
9			use Psr\Log\LogLevel;
10			use Yiisoft\Db\Cache\QueryCache;
11			use Yiisoft\Db\Cache\SchemaCache;
12			use Yiisoft\Db\Connection\Connection;
13			use Yiisoft\Db\Exception\Exception;
14			use Yiisoft\Db\Exception\InvalidCallException;
15			use Yiisoft\Db\Exception\InvalidConfigException;
16			use Yiisoft\Db\QueryBuilder\QueryBuilderInterface;
17			use Yiisoft\Db\Schema\QuoterInterface;
18			use Yiisoft\Db\Schema\SchemaInterface;
19
20			use function array_keys;
21			use function is_string;
22
23			abstract class ConnectionPDO extends Connection implements ConnectionPDOInterface
24			{
25			protected ?PDO $pdo = null;
26			protected string $serverVersion = '';
27
28			protected ?bool $emulatePrepare = null;
29
30			protected ?QueryBuilderInterface $queryBuilder = null;
31			protected ?QuoterInterface $quoter = null;
32			protected ?SchemaInterface $schema = null;
33
34			public function __construct(
35			protected PDODriverInterface $driver,
36			protected QueryCache $queryCache,
37			protected SchemaCache $schemaCache
38			) {
39			parent::__construct($queryCache);
40			}
41
42			/**
43			* Reset the connection after cloning.
44			*/
45			public function __clone()
46			{
47			$this->transaction = null;
48			$this->pdo = null;
49			}
50
51			/**
52			* Close the connection before serializing.
53			*
54			* @return array
55			*/
56			public function __sleep(): array
57			{
58			$fields = (array) $this;
59
60			unset(
61			$fields["\000*\000" . 'pdo'],
62			$fields["\000*\000" . 'transaction'],
63			$fields["\000*\000" . 'schema']
64			);
65
66			return array_keys($fields);
67			}
68
69			public function open(): void
70			{
71			if (!empty($this->pdo)) {
72			return;
73			}
74
75			if (empty($this->driver->getDsn())) {
76			throw new InvalidConfigException('Connection::dsn cannot be empty.');
77			}
78
79			$token = 'Opening DB connection: ' . $this->driver->getDsn();
80
81			try {
82			$this->logger?->log(LogLevel::INFO, $token);
83			$this->profiler?->begin($token, [__METHOD__]);
84			$this->initConnection();
85			$this->profiler?->end($token, [__METHOD__]);
86			} catch (PDOException $e) {
87			$this->profiler?->end($token, [__METHOD__]);
88			$this->logger?->log(LogLevel::ERROR, $token);
89
90			throw new Exception($e->getMessage(), (array) $e->errorInfo, $e);
91			}
92			}
93
94			public function close(): void
95			{
96			if ($this->pdo !== null) {
97			$this->logger?->log(
98			LogLevel::DEBUG,
99			'Closing DB connection: ' . $this->driver->getDsn() . ' ' . __METHOD__,
100			);
101
102			$this->pdo = null;
103			$this->transaction = null;
104			}
105			}
106
107			public function getCacheKey(): array
108			{
109			return [$this->driver->getDsn(), $this->driver->getUsername()];
110			}
111
112			public function getDriver(): PDODriverInterface
113			{
114			return $this->driver;
115			}
116
117			public function getEmulatePrepare(): ?bool
118			{
119			return $this->emulatePrepare;
120			}
121
122			public function getPDO(): ?PDO
123			{
124			return $this->pdo;
125			}
126
127			/**
128			* Input variables $sql and $forRead needs for future implementation of Connection + Pool
129			*
130			* @param string\|null $sql
131			* @param bool\|null $forRead
132			*
133			* @throws Exception
134			* @throws InvalidConfigException
135			*
136			* @return PDO
137			*/
138			public function getActivePDO(?string $sql = '', ?bool $forRead = null): PDO
139			{
140			$this->open();
141			$pdo = $this->getPDO();
142
143			if ($pdo === null) {
144			throw new Exception('PDO cannot be initialized.');
145			}
146
147			return $pdo;
148			}
149
150			public function getLastInsertID(?string $sequenceName = null): string
151			{
152			if ($this->isActive() && $this->pdo) {
153			return $this->pdo->lastInsertID($sequenceName === null
154			? null : $this->getQuoter()->quoteTableName($sequenceName));
155			}
156
157			throw new InvalidCallException('DB Connection is not active.');
158			}
159
160			public function getName(): string
161			{
162			return $this->driver->getDriverName();
163			}
164
165			/**
166			* @throws Exception
167			*/
168			public function getServerVersion(): string
169			{
170			if ($this->serverVersion === '') {
171			/** @var mixed */
172			$version = $this->getActivePDO()->getAttribute(PDO::ATTR_SERVER_VERSION);
173			$this->serverVersion = is_string($version) ? $version : 'Version could not be determined.';
174			}
175
176			return $this->serverVersion;
177			}
178
179			public function isActive(): bool
180			{
181			return $this->pdo !== null;
182			}
183
184			public function setEmulatePrepare(bool $value): void
185			{
186			$this->emulatePrepare = $value;
187			}
188
189			abstract protected function initConnection(): void;
190			}
191

yiisoft / db

Pull Request — master (#355)

ConnectionPDO::__sleep() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like