Class yii\db\Connection

                public function __clone()
{
    parent::__clone();
    $this->_master = false;
    $this->_slave = false;
    $this->_schema = null;
    $this->_transaction = null;
    if (strncmp($this->dsn, 'sqlite::memory:', 15) !== 0) {
        // reset PDO connection, unless its sqlite in-memory, which can only have one connection
        $this->pdo = null;
    }
}

            

                public function __sleep()
{
    $fields = (array) $this;
    unset($fields['pdo']);
    unset($fields["\000" . __CLASS__ . "\000" . '_master']);
    unset($fields["\000" . __CLASS__ . "\000" . '_slave']);
    unset($fields["\000" . __CLASS__ . "\000" . '_transaction']);
    unset($fields["\000" . __CLASS__ . "\000" . '_schema']);
    return array_keys($fields);
}

            

                public function beginTransaction($isolationLevel = null)
{
    $this->open();
    if (($transaction = $this->getTransaction()) === null) {
        $transaction = $this->_transaction = new Transaction(['db' => $this]);
    }
    $transaction->begin($isolationLevel);
    return $transaction;
}

            

                public function cache(callable $callable, $duration = null, $dependency = null)
{
    $this->_queryCacheInfo[] = [$duration === null ? $this->queryCacheDuration : $duration, $dependency];
    try {
        $result = call_user_func($callable, $this);
        array_pop($this->_queryCacheInfo);
        return $result;
    } catch (\Exception $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    } catch (\Throwable $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    }
}

            

                public function close()
{
    if ($this->_master) {
        if ($this->pdo === $this->_master->pdo) {
            $this->pdo = null;
        }
        $this->_master->close();
        $this->_master = false;
    }
    if ($this->pdo !== null) {
        Yii::debug('Closing DB connection: ' . $this->dsn, __METHOD__);
        $this->pdo = null;
    }
    if ($this->_slave) {
        $this->_slave->close();
        $this->_slave = false;
    }
    $this->_schema = null;
    $this->_transaction = null;
    $this->_driverName = null;
    $this->_queryCacheInfo = [];
    $this->_quotedTableNames = null;
    $this->_quotedColumnNames = null;
}

            

                public function createCommand($sql = null, $params = [])
{
    $driver = $this->getDriverName();
    $config = ['class' => 'yii\db\Command'];
    if ($this->commandClass !== $config['class']) {
        $config['class'] = $this->commandClass;
    } elseif (isset($this->commandMap[$driver])) {
        $config = !is_array($this->commandMap[$driver]) ? ['class' => $this->commandMap[$driver]] : $this->commandMap[$driver];
    }
    $config['db'] = $this;
    $config['sql'] = $sql;
    /** @var Command $command */
    $command = Yii::createObject($config);
    return $command->bindValues($params);
}

            

                protected function createPdoInstance()
{
    $pdoClass = $this->pdoClass;
    if ($pdoClass === null) {
        $driver = null;
        if ($this->_driverName !== null) {
            $driver = $this->_driverName;
        } elseif (($pos = strpos($this->dsn, ':')) !== false) {
            $driver = strtolower(substr($this->dsn, 0, $pos));
        }
        switch ($driver) {
            case 'mssql':
                $pdoClass = 'yii\db\mssql\PDO';
                break;
            case 'dblib':
                $pdoClass = 'yii\db\mssql\DBLibPDO';
                break;
            case 'sqlsrv':
                $pdoClass = 'yii\db\mssql\SqlsrvPDO';
                break;
            default:
                $pdoClass = 'PDO';
        }
    }
    $dsn = $this->dsn;
    if (strncmp('sqlite:@', $dsn, 8) === 0) {
        $dsn = 'sqlite:' . Yii::getAlias(substr($dsn, 7));
    }
    return new $pdoClass($dsn, $this->username, $this->password, $this->attributes);
}

            

                public function getDriverName()
{
    if ($this->_driverName === null) {
        if (($pos = strpos((string)$this->dsn, ':')) !== false) {
            $this->_driverName = strtolower(substr($this->dsn, 0, $pos));
        } else {
            $this->_driverName = strtolower($this->getSlavePdo(true)->getAttribute(PDO::ATTR_DRIVER_NAME));
        }
    }
    return $this->_driverName;
}

            

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

            

                public function getLastInsertID($sequenceName = '')
{
    return $this->getSchema()->getLastInsertID($sequenceName);
}

            

                public function getMaster()
{
    if ($this->_master === false) {
        $this->_master = $this->shuffleMasters
            ? $this->openFromPool($this->masters, $this->masterConfig)
            : $this->openFromPoolSequentially($this->masters, $this->masterConfig);
    }
    return $this->_master;
}

            

                public function getMasterPdo()
{
    $this->open();
    return $this->pdo;
}

            

                public function getQueryBuilder()
{
    return $this->getSchema()->getQueryBuilder();
}

            

                public function getSchema()
{
    if ($this->_schema !== null) {
        return $this->_schema;
    }
    $driver = $this->getDriverName();
    if (isset($this->schemaMap[$driver])) {
        $config = !is_array($this->schemaMap[$driver]) ? ['class' => $this->schemaMap[$driver]] : $this->schemaMap[$driver];
        $config['db'] = $this;
        $this->_schema = Yii::createObject($config);
        $this->restoreQueryBuilderConfiguration();
        return $this->_schema;
    }
    throw new NotSupportedException("Connection does not support reading schema information for '$driver' DBMS.");
}

            

                public function getServerVersion()
{
    return $this->getSchema()->getServerVersion();
}

            

                public function getSlave($fallbackToMaster = true)
{
    if (!$this->enableSlaves) {
        return $fallbackToMaster ? $this : null;
    }
    if ($this->_slave === false) {
        $this->_slave = $this->openFromPool($this->slaves, $this->slaveConfig);
    }
    return $this->_slave === null && $fallbackToMaster ? $this : $this->_slave;
}

            

                public function getSlavePdo($fallbackToMaster = true)
{
    $db = $this->getSlave(false);
    if ($db === null) {
        return $fallbackToMaster ? $this->getMasterPdo() : null;
    }
    return $db->pdo;
}

            

                public function getTableSchema($name, $refresh = false)
{
    return $this->getSchema()->getTableSchema($name, $refresh);
}

            

                public function getTransaction()
{
    return $this->_transaction && $this->_transaction->getIsActive() ? $this->_transaction : null;
}

            

                protected function initConnection()
{
    $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    if ($this->emulatePrepare !== null && constant('PDO::ATTR_EMULATE_PREPARES')) {
        if ($this->driverName !== 'sqlsrv') {
            $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, $this->emulatePrepare);
        }
    }
    if (PHP_VERSION_ID >= 80100 && $this->getDriverName() === 'sqlite') {
        $this->pdo->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
    }
    if (!$this->isSybase && in_array($this->getDriverName(), ['mssql', 'dblib'], true)) {
        $this->pdo->exec('SET ANSI_NULL_DFLT_ON ON');
    }
    if ($this->charset !== null && in_array($this->getDriverName(), ['pgsql', 'mysql', 'mysqli', 'cubrid'], true)) {
        $this->pdo->exec('SET NAMES ' . $this->pdo->quote($this->charset));
    }
    $this->trigger(self::EVENT_AFTER_OPEN);
}

            

                public function noCache(callable $callable)
{
    $this->_queryCacheInfo[] = false;
    try {
        $result = call_user_func($callable, $this);
        array_pop($this->_queryCacheInfo);
        return $result;
    } catch (\Exception $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    } catch (\Throwable $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    }
}

            

                public function open()
{
    if ($this->pdo !== null) {
        return;
    }
    if (!empty($this->masters)) {
        $db = $this->getMaster();
        if ($db !== null) {
            $this->pdo = $db->pdo;
            return;
        }
        throw new InvalidConfigException('None of the master DB servers is available.');
    }
    if (empty($this->dsn)) {
        throw new InvalidConfigException('Connection::dsn cannot be empty.');
    }
    $token = 'Opening DB connection: ' . $this->dsn;
    $enableProfiling = $this->enableProfiling;
    try {
        if ($this->enableLogging) {
            Yii::info($token, __METHOD__);
        }
        if ($enableProfiling) {
            Yii::beginProfile($token, __METHOD__);
        }
        $this->pdo = $this->createPdoInstance();
        $this->initConnection();
        if ($enableProfiling) {
            Yii::endProfile($token, __METHOD__);
        }
    } catch (\PDOException $e) {
        if ($enableProfiling) {
            Yii::endProfile($token, __METHOD__);
        }
        throw new Exception($e->getMessage(), $e->errorInfo, $e->getCode(), $e);
    }
}

            

                protected function openFromPool(array $pool, array $sharedConfig)
{
    shuffle($pool);
    return $this->openFromPoolSequentially($pool, $sharedConfig);
}

            

                protected function openFromPoolSequentially(array $pool, array $sharedConfig)
{
    if (empty($pool)) {
        return null;
    }
    if (!isset($sharedConfig['class'])) {
        $sharedConfig['class'] = get_class($this);
    }
    $cache = is_string($this->serverStatusCache) ? Yii::$app->get($this->serverStatusCache, false) : $this->serverStatusCache;
    foreach ($pool as $i => $config) {
        $pool[$i] = $config = array_merge($sharedConfig, $config);
        if (empty($config['dsn'])) {
            throw new InvalidConfigException('The "dsn" option must be specified.');
        }
        $key = [__METHOD__, $config['dsn']];
        if ($cache instanceof CacheInterface && $cache->get($key)) {
            // should not try this dead server now
            continue;
        }
        /* @var $db Connection */
        $db = Yii::createObject($config);
        try {
            $db->open();
            return $db;
        } catch (\Exception $e) {
            Yii::warning("Connection ({$config['dsn']}) failed: " . $e->getMessage(), __METHOD__);
            if ($cache instanceof CacheInterface) {
                // mark this server as dead and only retry it after the specified interval
                $cache->set($key, 1, $this->serverRetryInterval);
            }
            // exclude server from retry below
            unset($pool[$i]);
        }
    }
    if ($cache instanceof CacheInterface) {
        // if server status cache is enabled and no server is available
        // ignore the cache and try to connect anyway
        // $pool now only contains servers we did not already try in the loop above
        foreach ($pool as $config) {
            /* @var $db Connection */
            $db = Yii::createObject($config);
            try {
                $db->open();
            } catch (\Exception $e) {
                Yii::warning("Connection ({$config['dsn']}) failed: " . $e->getMessage(), __METHOD__);
                continue;
            }
            // mark this server as available again after successful connection
            $cache->delete([__METHOD__, $config['dsn']]);
            return $db;
        }
    }
    return null;
}

            

                public function quoteColumnName($name)
{
    if (isset($this->_quotedColumnNames[$name])) {
        return $this->_quotedColumnNames[$name];
    }
    return $this->_quotedColumnNames[$name] = $this->getSchema()->quoteColumnName($name);
}

            

                public function quoteSql($sql)
{
    return preg_replace_callback(
        '/(\\{\\{(%?[\w\-\. ]+%?)\\}\\}|\\[\\[([\w\-\. ]+)\\]\\])/',
        function ($matches) {
            if (isset($matches[3])) {
                return $this->quoteColumnName($matches[3]);
            }
            return str_replace('%', $this->tablePrefix, $this->quoteTableName($matches[2]));
        },
        $sql
    );
}

            

                public function quoteTableName($name)
{
    if (isset($this->_quotedTableNames[$name])) {
        return $this->_quotedTableNames[$name];
    }
    return $this->_quotedTableNames[$name] = $this->getSchema()->quoteTableName($name);
}

            

                public function quoteValue($value)
{
    return $this->getSchema()->quoteValue($value);
}

            

                public function setDriverName($driverName)
{
    $this->_driverName = strtolower($driverName);
}

            

                public function setQueryBuilder($value)
{
    Yii::configure($this->getQueryBuilder(), $value);
    $this->_queryBuilderConfigurations[] = $value;
}

            

                public function transaction(callable $callback, $isolationLevel = null)
{
    $transaction = $this->beginTransaction($isolationLevel);
    $level = $transaction->level;
    try {
        $result = call_user_func($callback, $this);
        if ($transaction->isActive && $transaction->level === $level) {
            $transaction->commit();
        }
    } catch (\Exception $e) {
        $this->rollbackTransactionOnLevel($transaction, $level);
        throw $e;
    } catch (\Throwable $e) {
        $this->rollbackTransactionOnLevel($transaction, $level);
        throw $e;
    }
    return $result;
}

            

                public function useMaster(callable $callback)
{
    if ($this->enableSlaves) {
        $this->enableSlaves = false;
        try {
            $result = call_user_func($callback, $this);
        } catch (\Exception $e) {
            $this->enableSlaves = true;
            throw $e;
        } catch (\Throwable $e) {
            $this->enableSlaves = true;
            throw $e;
        }
        // TODO: use "finally" keyword when miminum required PHP version is >= 5.5
        $this->enableSlaves = true;
    } else {
        $result = call_user_func($callback, $this);
    }
    return $result;
}