Abstract Class Yiisoft\Db\Driver\Pdo\AbstractPdoConnection

                public function __clone()
{
    $this->transaction = null;
    $this->pdo = null;
}

            

                public function __construct(
    protected PdoDriverInterface $driver,
    protected SchemaCache $schemaCache,
    protected ?ColumnFactoryInterface $columnFactory = null,
) {}

            

                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 beginTransaction(?string $isolationLevel = null): TransactionInterface
{
    $transaction = parent::beginTransaction($isolationLevel);
    if ($this->logger !== null && $transaction instanceof LoggerAwareInterface) {
        $transaction->setLogger($this->logger);
    }
    return $transaction;
}

            

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

            

                public function getActivePdo(): PDO
{
    $this->open();
    $pdo = $this->getPdo();
    if ($pdo === null) {
        throw new Exception('PDO cannot be initialized.');
    }
    return $pdo;
}

            

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

            

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

            

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

            

                public function getLastInsertId(?string $sequenceName = null): string
{
    if ($this->pdo !== null) {
        return $this->pdo->lastInsertID($sequenceName ?? null);
    }
    throw new InvalidCallException('DB Connection is not active.');
}

            

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

            

                public function getServerInfo(): ServerInfoInterface
{
    return $this->serverInfo ??= new PdoServerInfo($this);
}

            

                protected function initConnection(): void
{
    if ($this->getEmulatePrepare() !== null) {
        $this->driver->attributes([PDO::ATTR_EMULATE_PREPARES => $this->getEmulatePrepare()]);
    }
    $this->pdo = $this->driver->createConnection();
}

            

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

            

                public function open(): void
{
    if ($this->pdo instanceof PDO) {
        return;
    }
    if ($this->driver->getDsn() === '') {
        throw new InvalidConfigException('Connection::dsn cannot be empty.');
    }
    $token = 'Opening DB connection: ' . $this->driver->getDsn();
    $connectionContext = new ConnectionContext(__METHOD__);
    try {
        $this->logger?->log(LogLevel::INFO, $token, ['type' => LogType::CONNECTION]);
        $this->profiler?->begin($token, $connectionContext);
        $this->initConnection();
        $this->profiler?->end($token, $connectionContext);
    } catch (PDOException $e) {
        $this->profiler?->end($token, $connectionContext->setException($e));
        $this->logger?->log(LogLevel::ERROR, $token, ['type' => LogType::CONNECTION]);
        throw new Exception($e->getMessage(), (array) $e->errorInfo, $e);
    }
}

            

                public function quoteValue(mixed $value): mixed
{
    if (is_string($value) === false) {
        return $value;
    }
    return $this->getActivePdo()->quote($value);
}

            

                protected 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 (Throwable $e) {
            $this->logger?->log(LogLevel::ERROR, (string) $e, [__METHOD__, 'type' => LogType::TRANSACTION]);
            /** hide this exception to be able to continue throwing original exception outside */
        }
    }
}

            

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

            

                public function setTablePrefix(string $value): void
{
    parent::setTablePrefix($value);
    if ($this->quoter !== null && method_exists($this->quoter, 'setTablePrefix')) {
        $this->quoter->setTablePrefix($value);
    }
}