Yiisoft\Db\Connection\AbstractConnection

Complexity

Total Complexity

25

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	queryCacheEnable()	0	3	1
A	cache()	0	11	1
A	getTableSchema()	0	3	1
A	isSavepointEnabled()	0	3	1
A	setEnableSavepoint()	0	3	1
A	getTransaction()	0	3	3
A	transaction()	0	19	4
A	noCache()	0	9	1
A	__construct()	0	2	1
A	beginTransaction()	0	16	3
A	rollbackTransactionOnLevel()	0	10	4
A	setTablePrefix()	0	3	1
A	createBatchQueryResult()	0	3	1
A	notProfiler()	0	3	1
A	getTablePrefix()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Connection;

use Closure;
use Exception;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LogLevel;
use Throwable;
use Yiisoft\Cache\Dependency\Dependency;
use Yiisoft\Db\Cache\QueryCache;
use Yiisoft\Db\Query\BatchQueryResult;
use Yiisoft\Db\Query\BatchQueryResultInterface;
use Yiisoft\Db\Query\QueryInterface;
use Yiisoft\Db\Schema\TableSchemaInterface;
use Yiisoft\Db\Transaction\TransactionInterface;
use Yiisoft\Profiler\ProfilerAwareInterface;
use Yiisoft\Profiler\ProfilerAwareTrait;

/**
 * The AbstractConnection class represents a connection to a database. It provides methods for interacting with the
 * database, such as executing SQL queries and performing data manipulation.
 */
abstract class AbstractConnection implements ConnectionInterface, LoggerAwareInterface, ProfilerAwareInterface
{
    use LoggerAwareTrait;
    use ProfilerAwareTrait;

    protected TransactionInterface|null $transaction = null;
    private bool $enableSavepoint = true;
    private int $serverRetryInterval = 600;

The private property $serverRetryInterval is not used, and could be removed.

    private string $tablePrefix = '';

    public function __construct(private QueryCache $queryCache)
    {
    }

    public function beginTransaction(string $isolationLevel = null): TransactionInterface
    {
        $this->open();
        $this->transaction = $this->getTransaction();

        if ($this->transaction === null) {
            $this->transaction = $this->createTransaction();
        }

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

        $this->transaction->begin($isolationLevel);

        return $this->transaction;
    }

    public function cache(Closure $closure, int $duration = null, Dependency $dependency = null): mixed
    {
        $this->queryCache->setInfo(
            [$duration ?? $this->queryCache->getDuration(), $dependency]
        );

        /** @psalm-var mixed $result */
        $result = $closure($this);
        $this->queryCache->removeLastInfo();

        return $result;
    }

    public function createBatchQueryResult(QueryInterface $query, bool $each = false): BatchQueryResultInterface
    {
        return new BatchQueryResult($query, $each);
    }

    public function getTablePrefix(): string
    {
        return $this->tablePrefix;
    }

    public function getTableSchema(string $name, bool $refresh = false): TableSchemaInterface|null
    {
        return $this->getSchema()->getTableSchema($name, $refresh);
    }

    public function getTransaction(): TransactionInterface|null
    {
        return $this->transaction && $this->transaction->isActive() ? $this->transaction : null;
    }

    public function isSavepointEnabled(): bool
    {
        return $this->enableSavepoint;
    }

    public function noCache(Closure $closure): mixed
    {
        $queryCache = $this->queryCache;
        $queryCache->setInfo(false);
        /** @psalm-var mixed $result */
        $result = $closure($this);
        $queryCache->removeLastInfo();

        return $result;
    }

    public function notProfiler(): void
    {
        $this->profiler = null;
    }

    public function queryCacheEnable(bool $value): void
    {
        $this->queryCache->setEnable($value);
    }

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

    public function setTablePrefix(string $value): void
    {
        $this->tablePrefix = $value;
    }

    public function transaction(Closure $closure, string $isolationLevel = null): mixed
    {
        $transaction = $this->beginTransaction($isolationLevel);
        $level = $transaction->getLevel();

        try {
            /** @psalm-var mixed $result */
            $result = $closure($this);

            if ($transaction->isActive() && $transaction->getLevel() === $level) {
                $transaction->commit();
            }
        } catch (Throwable $e) {
            $this->rollbackTransactionOnLevel($transaction, $level);

            throw $e;
        }

        return $result;
    }

    /**
     * Rolls back given {@see TransactionInterface} object if it's still active and level match. In some cases rollback
     * can fail, so this method is fail-safe. Exceptions thrown from rollback will be caught and just logged with
     * {@see logger->log()}.
     *
     * @param TransactionInterface $transaction TransactionInterface object given from {@see beginTransaction()}.
     * @param int $level TransactionInterface level just after {@see beginTransaction()} call.
     */
    private function rollbackTransactionOnLevel(TransactionInterface $transaction, int $level): void
    {
        if ($transaction->isActive() && $transaction->getLevel() === $level) {
            /**
             * @link https://github.com/yiisoft/yii2/pull/13347
             */
            try {
                $transaction->rollBack();
            } catch (Exception $e) {
                $this->logger?->log(LogLevel::ERROR, (string) $e, [__METHOD__]);
                /** hide this exception to be able to continue throwing original exception outside */
            }
        }
    }
}