Class yii\mongodb\Connection

                public function close()
{
    if ($this->manager !== null) {
        Yii::debug('Closing MongoDB connection: ' . $this->dsn, __METHOD__);
        $this->manager = null;
        foreach ($this->_databases as $database) {
            $database->clearCollections();
        }
        $this->_databases = [];
    }
}

            

                public function commitTransaction()
{
    $this->transactionReady('commit transaction');
    $this->getSession()->transaction->commit();
}

            

                public function createCommand($document = [], $databaseName = null)
{
    return new Command([
        'db' => $this,
        'databaseName' => $databaseName,
        'document' => $document,
        'globalExecOptions' => $this->globalExecOptions
    ]);
}

            

                public function execOptions($newExecOptions)
{
    if (empty($newExecOptions)) {
        $this->globalExecOptions = [];
    }
    else {
        $this->globalExecOptions = array_replace_recursive($this->globalExecOptions, $newExecOptions);
    }
    return $this;
}

            

                public function getCollection($name, $refresh = false)
{
    if (is_array($name)) {
        list ($dbName, $collectionName) = $name;
        return $this->getDatabase($dbName)->getCollection($collectionName, $refresh);
    }
    return $this->getDatabase()->getCollection($name, $refresh);
}

            

                public function getDatabase($name = null, $refresh = false)
{
    if ($name === null) {
        $name = $this->getDefaultDatabaseName();
    }
    if ($refresh || !array_key_exists($name, $this->_databases)) {
        $this->_databases[$name] = $this->selectDatabase($name);
    }
    return $this->_databases[$name];
}

            

                public function getDefaultDatabaseName()
{
    if ($this->_defaultDatabaseName === null) {
        if (preg_match('/^mongodb:\\/\\/.+\\/([^?&]+)/s', $this->dsn, $matches)) {
            $this->_defaultDatabaseName = $matches[1];
        } else {
            throw new InvalidConfigException("Unable to determine default database name from dsn.");
        }
    }
    return $this->_defaultDatabaseName;
}

            

                public function getFileCollection($prefix = 'fs', $refresh = false)
{
    if (is_array($prefix)) {
        list ($dbName, $collectionPrefix) = $prefix;
        if (!isset($collectionPrefix)) {
            $collectionPrefix = 'fs';
        }
        return $this->getDatabase($dbName)->getFileCollection($collectionPrefix, $refresh);
    }
    return $this->getDatabase()->getFileCollection($prefix, $refresh);
}

            

                public function getInSession()
{
    return array_key_exists('session',$this->globalExecOptions['share']);
}

            

                public function getInTransaction()
{
    return $this->getInSession() && $this->getSession()->getInTransaction();
}

            

                public function getIsActive()
{
    return is_object($this->manager) && $this->manager->getServers() !== [];
}

            

                public function getLogBuilder()
{
    if (!is_object($this->_logBuilder)) {
        $this->_logBuilder = Yii::createObject($this->_logBuilder);
    }
    return $this->_logBuilder;
}

            

                public function getQueryBuilder()
{
    if (!is_object($this->_queryBuilder)) {
        $this->_queryBuilder = Yii::createObject($this->_queryBuilder, [$this]);
    }
    return $this->_queryBuilder;
}

            

                public function getSession()
{
    return $this->getInSession() ? $this->globalExecOptions['share']['session'] : null;
}

            

                protected function initConnection()
{
    $this->trigger(self::EVENT_AFTER_OPEN);
}

            

                public function newSession($sessionOptions = [])
{
    return ClientSession::start($this, $sessionOptions);
}

            

                public function noTransaction(callable $actions)
{
    $lastSession = $this->getSession();
    $this->setSession(null);
    try {
        $result = $actions();
    } finally {
        $this->setSession($lastSession);
    }
    return $result;
}

            

                public function open()
{
    if ($this->manager === null) {
        if (empty($this->dsn)) {
            throw new InvalidConfigException($this->className() . '::dsn cannot be empty.');
        }
        $token = 'Opening MongoDB connection: ' . $this->dsn;
        try {
            Yii::debug($token, __METHOD__);
            Yii::beginProfile($token, __METHOD__);
            $options = $this->options;
            $this->manager = new Manager($this->dsn, $options, $this->driverOptions);
            $this->manager->selectServer($this->manager->getReadPreference());
            $this->initConnection();
            Yii::endProfile($token, __METHOD__);
        } catch (\Exception $e) {
            Yii::endProfile($token, __METHOD__);
            throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
        }
        $this->typeMap = array_merge(
            $this->typeMap,
            [
                'root' => 'array',
                'document' => 'array'
            ]
        );
    }
}

            

                public function registerFileStreamWrapper($force = false)
{
    if ($force || !$this->_fileStreamWrapperRegistered) {
        /* @var $class \yii\mongodb\file\StreamWrapper */
        $class = $this->fileStreamWrapperClass;
        $class::register($this->fileStreamProtocol, $force);
        $this->_fileStreamWrapperRegistered = true;
    }
    return $this->fileStreamProtocol;
}

            

                public function rollBackTransaction()
{
    $this->transactionReady('roll back transaction');
    $this->getSession()->transaction->rollBack();
}

            

                protected function selectDatabase($name)
{
    return Yii::createObject([
        'class' => 'yii\mongodb\Database',
        'name' => $name,
        'connection' => $this,
    ]);
}

            

                public function setDefaultDatabaseName($name)
{
    $this->_defaultDatabaseName = $name;
}

            

                public function setLogBuilder($logBuilder)
{
    $this->_logBuilder = $logBuilder;
}

            

                public function setQueryBuilder($queryBuilder)
{
    $this->_queryBuilder = $queryBuilder;
}

            

                public function setSession($clientSession)
{
    #drop session
    if (empty($clientSession)) {
        unset($this->globalExecOptions['share']['session']);
    }
    else {
        $this->globalExecOptions['share']['session'] = $clientSession;
    }
    return $this;
}

            

                public function startSession($sessionOptions = [])
{
    if ($this->getInSession()) {
        $this->getSession()->end();
    }
    $newSession = $this->newSession($sessionOptions);
    $this->setSession($newSession);
    return $newSession;
}

            

                public function startSessionOnce($sessionOptions = [])
{
    if ($this->getInSession()) {   
        return $this->getSession();
    }
    return $this->startSession($sessionOptions);
}

            

                public function startTransaction($transactionOptions = [], $sessionOptions = [])
{
    $session = $this->startSession($sessionOptions,true);
    $session->getTransaction()->start($transactionOptions);
    return $session;
}

            

                public function startTransactionOnce($transactionOptions = [], $sessionOptions = [])
{
    if ($this->getInTransaction()) {
        return $this->getSession();
    }
    return $this->startTransaction($transactionOptions,$sessionOptions);
}

            

                public function transaction(callable $actions, $transactionOptions = [], $sessionOptions = [])
{
    $session = $this->startTransaction($transactionOptions, $sessionOptions);
    $success = false;
    try {
        $result = call_user_func($actions, $session);
        if ($session->getTransaction()->getIsActive()) {
            if ($result === false) {
                $session->getTransaction()->rollBack();
            }
            else {
                $session->getTransaction()->commit();
            }
        }
        $success = true;
    } finally {
        if (!$success && $session->getTransaction()->getIsActive()) {
            $session->getTransaction()->rollBack();
        }
    }
}

            

                public function transactionOnce(callable $actions, $transactionOptions = [], $sessionOptions = [])
{
    if ($this->getInTransaction()) {
        $actions();
    }
    else {
        $this->transaction($actions,$transactionOptions,$sessionOptions);
    }
}

            

                public function transactionReady($operation)
{
    if (!$this->getInSession()) {
        throw new Exception('You can\'t ' . $operation . ' because current connection is\'t in a session.');
    }
    if (!$this->getSession()->getInTransaction()) {
        throw new Exception('You can\'t ' . $operation . ' because transaction not started in current session.');
    }
}