Yiisoft\Db\Sqlite\PDO\ConnectionPDOSqlite

Complexity

Total Complexity

40

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__sleep()	0	13	1
A	close()	0	27	5
B	open()	0	34	6
A	getSlavePdo()	0	10	3
A	getQuoter()	0	7	2
A	getDriverName()	0	3	1
A	getMasterPdo()	0	4	1
A	getServerVersion()	0	9	3
A	getSchema()	0	7	2
A	createTransaction()	0	3	1
A	getPDO()	0	3	1
A	isActive()	0	3	1
A	createCommand()	0	17	4
A	initConnection()	0	7	3
A	getDriver()	0	3	1
A	__clone()	0	9	2
A	__construct()	0	6	1
A	getQueryBuilder()	0	11	2

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Sqlite\PDO;

use PDO;
use PDOException;
use Psr\Log\LogLevel;
use Yiisoft\Db\Cache\QueryCache;
use Yiisoft\Db\Cache\SchemaCache;
use Yiisoft\Db\Command\CommandInterface;

The type Yiisoft\Db\Command\CommandInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Connection\Connection;
use Yiisoft\Db\Connection\ConnectionPDOInterface;

The type Yiisoft\Db\Connection\ConnectionPDOInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Driver\PDODriver;

The type Yiisoft\Db\Driver\PDODriver was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidConfigException;
use Yiisoft\Db\Query\QueryBuilderInterface;

The type Yiisoft\Db\Query\QueryBuilderInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Schema\Quoter;

The type Yiisoft\Db\Schema\Quoter was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Schema\QuoterInterface;

The type Yiisoft\Db\Schema\QuoterInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Db\Schema\SchemaInterface;
use Yiisoft\Db\Transaction\TransactionInterface;

The type Yiisoft\Db\Transaction\TransactionInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use function constant;
use function strncmp;

/**
 * Database connection class prefilled for MYSQL Server.
 */
final class ConnectionPDOSqlite extends Connection implements ConnectionPDOInterface
{
    private ?PDO $pdo = null;
    private ?QueryBuilderInterface $queryBuilder = null;
    private ?QuoterInterface $quoter = null;
    private ?SchemaInterface $schema = null;
    private string $serverVersion = '';

    public function __construct(
        private PDODriver $driver,
        private QueryCache $queryCache,
        private SchemaCache $schemaCache
    ) {
        parent::__construct($queryCache);

The call to Yiisoft\Db\Connection\Connection::__construct() has too few arguments starting with queryCache.

$queryCache of type Yiisoft\Db\Cache\QueryCache is incompatible with the type string expected by parameter $dsn of Yiisoft\Db\Connection\Connection::__construct().

    }

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

        if (strncmp($this->driver->getDsn(), 'sqlite::memory:', 15) !== 0) {
            /** reset PDO connection, unless its sqlite in-memory, which can only have one connection */
            $this->pdo = null;
        }
    }

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

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

        return array_keys($fields);
    }

    public function createCommand(?string $sql = null, array $params = []): CommandInterface
    {
        $command = new CommandPDOSqlite($this, $this->queryCache);

        if ($sql !== null) {
            $command->setSql($sql);
        }

        if ($this->logger !== null) {
            $command->setLogger($this->logger);
        }

        if ($this->profiler !== null) {
            $command->setProfiler($this->profiler);
        }

        return $command->bindValues($params);

The expression return $command->bindValues($params) returns the type Yiisoft\Db\Sqlite\PDO\CommandPDOSqlite which is incompatible with the type-hinted return Yiisoft\Db\Command\CommandInterface.

    }

    public function createTransaction(): TransactionInterface
    {
        return new TransactionPDOSqlite($this);
    }

    public function close(): void
    {
        if (!empty($this->master)) {
            /** @var ConnectionPDOSqlite */
            $db = $this->master;

            if ($this->pdo === $db->getPDO()) {
                $this->pdo = null;
            }

            $db->close();
            $this->master = null;
        }

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

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

        if (!empty($this->slave)) {
            $this->slave->close();
            $this->slave = null;
        }
    }

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

    public function getDriverName(): string
    {
        return 'sqlite';
    }

    public function getMasterPdo(): PDO|null
    {
        $this->open();
        return $this->pdo;

The expression return $this->pdo also could return the type null which is incompatible with the return type mandated by Yiisoft\Db\Connection\Connection::getMasterPdo() of PDO.

    }

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

    public function getQueryBuilder(): QueryBuilderInterface
    {
        if ($this->queryBuilder === null) {
            $this->queryBuilder = new QueryBuilderPDOSqlite(
                $this->createCommand(),
                $this->getQuoter(),
                $this->getSchema(),
            );
        }

        return $this->queryBuilder;

The expression return $this->queryBuilder could return the type null which is incompatible with the type-hinted return Yiisoft\Db\Query\QueryBuilderInterface. Consider adding an additional type-check to rule them out.

    }

    public function getQuoter(): QuoterInterface
    {
        if ($this->quoter === null) {
            $this->quoter = new Quoter('`', '`', $this->getTablePrefix());
        }

        return $this->quoter;

The expression return $this->quoter could return the type null which is incompatible with the type-hinted return Yiisoft\Db\Schema\QuoterInterface. Consider adding an additional type-check to rule them out.

    }

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

        return $this->serverVersion;
    }

    public function getSchema(): SchemaInterface
    {
        if ($this->schema === null) {
            $this->schema = new SchemaPDOSqlite($this, $this->schemaCache);
        }

        return $this->schema;

The expression return $this->schema could return the type null which is incompatible with the type-hinted return Yiisoft\Db\Schema\SchemaInterface. Consider adding an additional type-check to rule them out.

    }

    public function getSlavePdo(bool $fallbackToMaster = true): ?PDO
    {
        /** @var ConnectionPDOSqlite|null $db */
        $db = $this->getSlave(false);

        if ($db === null) {
            return $fallbackToMaster ? $this->getMasterPdo() : null;
        }

        return $db->getPDO();
    }

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

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

        if (!empty($this->masters)) {

The property masters is declared private in Yiisoft\Db\Connection\Connection and cannot be accessed from this context.

            /** @var ConnectionPDOSqlite|null */
            $db = $this->getMaster();

            if ($db !== null) {
                $this->pdo = $db->getPDO();
                return;
            }

            throw new InvalidConfigException('None of the master DB servers is available.');
        }

        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);
        }
    }

    /**
     * Initializes the DB connection.
     *
     * This method is invoked right after the DB connection is established.
     *
     * The default implementation turns on `PDO::ATTR_EMULATE_PREPARES`.
     *
     * if {@see emulatePrepare} is true, and sets the database {@see charset} if it is not empty.
     *
     * It then triggers an {@see EVENT_AFTER_OPEN} event.
     */
    private function initConnection(): void
    {
        $this->pdo = $this->driver->createConnection();
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

The method setAttribute() does not exist on null.

        if ($this->getEmulatePrepare() !== null && constant('PDO::ATTR_EMULATE_PREPARES')) {
            $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, $this->getEmulatePrepare());
        }
    }
}