Class yii\mongodb\Command

                public function addDelete($condition, $options = [])
{
    $this->document[] = [
        'type' => 'delete',
        'condition' => $this->db->getQueryBuilder()->buildCondition($condition),
        'options' => $options,
    ];
    return $this;
}

            

                public function addInsert($document)
{
    $this->document[] = [
        'type' => 'insert',
        'document' => $document,
    ];
    return $this;
}

            

                public function addUpdate($condition, $document, $options = [])
{
    $options = array_merge(
        [
            'multi' => true,
            'upsert' => false,
        ],
        $options
    );
    if ($options['multi']) {
        $keys = array_keys($document);
        if (!empty($keys) && strncmp('$', $keys[0], 1) !== 0) {
            $document = ['$set' => $document];
        }
    }
    $this->document[] = [
        'type' => 'update',
        'condition' => $this->db->getQueryBuilder()->buildCondition($condition),
        'document' => $document,
        'options' => $options,
    ];
    return $this;
}

            

                public function aggregate($collectionName, $pipelines, $options = [], $execOptions = [])
{
    if (empty($options['cursor'])) {
        $returnCursor = false;
        $options['cursor'] = new \stdClass();
    } else {
        $returnCursor = true;
    }
    $this->document = $this->db->getQueryBuilder()->aggregate($collectionName, $pipelines, $options);
    $cursor = $this->execute($execOptions);
    if ($returnCursor) {
        return $cursor;
    }
    return $cursor->toArray();
}

            

                public function batchInsert($collectionName, $documents, $options = [], $execOptions = [])
{
    $this->document = [];
    foreach ($documents as $key => $document) {
        $this->document[$key] = [
            'type' => 'insert',
            'document' => $document
        ];
    }
    $result = $this->executeBatch($collectionName, $options, $execOptions);
    if ($result['result']->getInsertedCount() < 1) {
        return false;
    }
    return $result['insertedIds'];
}

            

                protected function beginProfile($token, $category)
{
    if ($token !== false && $this->db->enableProfiling) {
        Yii::beginProfile($token, $category);
    }
}

            

                public function count($collectionName, $condition = [], $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->count($collectionName, $condition, $options);
    $result = current($this->execute($execOptions)->toArray());
    return $result['n'];
}

            

                public function createCollection($collectionName, array $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->createCollection($collectionName, $options);
    $result = current($this->execute($execOptions)->toArray());
    return $result['ok'] > 0;
}

            

                public function createIndexes($collectionName, $indexes, $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->createIndexes($this->databaseName, $collectionName, $indexes);
    $result = current($this->execute($execOptions)->toArray());
    return $result['ok'] > 0;
}

            

                public function delete($collectionName, $condition, $options = [], $execOptions = [])
{
    $batchOptions = [];
    foreach (['bypassDocumentValidation'] as $name) {
        if (isset($options[$name])) {
            $batchOptions[$name] = $options[$name];
            unset($options[$name]);
        }
    }
    $this->document = [];
    $this->addDelete($condition, $options);
    $result = $this->executeBatch($collectionName, $batchOptions, $execOptions);
    return $result['result'];
}

            

                public function distinct($collectionName, $fieldName, $condition = [], $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->distinct($collectionName, $fieldName, $condition, $options);
    $cursor = $this->execute($execOptions);
    $result = current($cursor->toArray());
    if (!isset($result['values']) || !is_array($result['values'])) {
        return false;
    }
    return $result['values'];
}

            

                public function dropCollection($collectionName, $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->dropCollection($collectionName);
    $result = current($this->execute($execOptions)->toArray());
    return $result['ok'] > 0;
}

            

                public function dropDatabase($execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->dropDatabase();
    $result = current($this->execute($execOptions)->toArray());
    return $result['ok'] > 0;
}

            

                public function dropIndexes($collectionName, $indexes, $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->dropIndexes($collectionName, $indexes);
    return current($this->execute($execOptions)->toArray());
}

            

                protected function endProfile($token, $category)
{
    if ($token !== false && $this->db->enableProfiling) {
        Yii::endProfile($token, $category);
    }
}

            

                public function execute($execOptions = [])
{
    $this->prepareExecCommandOptions($execOptions);
    $databaseName = $this->databaseName === null ? $this->db->defaultDatabaseName : $this->databaseName;
    $token = $this->log([$databaseName, 'command'], $this->document, __METHOD__);
    try {
        $this->beginProfile($token, __METHOD__);
        $this->db->open();
        $mongoCommand = new \MongoDB\Driver\Command($this->document);
        $cursor = $this->db->manager->executeCommand($databaseName, $mongoCommand, $execOptions);
        $cursor->setTypeMap($this->db->typeMap);
        $this->endProfile($token, __METHOD__);
    } catch (RuntimeException $e) {
        $this->endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), $e->getCode(), $e);
    }
    return $cursor;
}

            

                public function executeBatch($collectionName, $options = [], $execOptions = [])
{
    $this->prepareExecBulkWriteOptions($execOptions);
    $databaseName = $this->databaseName === null ? $this->db->defaultDatabaseName : $this->databaseName;
    $token = $this->log([$databaseName, $collectionName, 'bulkWrite'], $this->document, __METHOD__);
    try {
        $this->beginProfile($token, __METHOD__);
        $batch = new BulkWrite($options);
        $insertedIds = [];
        foreach ($this->document as $key => $operation) {
            switch ($operation['type']) {
                case 'insert':
                    $insertedIds[$key] = $batch->insert($operation['document']);
                    break;
                case 'update':
                    $batch->update($operation['condition'], $operation['document'], $operation['options']);
                    break;
                case 'delete':
                    $batch->delete($operation['condition'], isset($operation['options']) ? $operation['options'] : []);
                    break;
                default:
                    throw new InvalidConfigException("Unsupported batch operation type '{$operation['type']}'");
            }
        }
        $this->db->open();
        $writeResult = $this->db->manager->executeBulkWrite($databaseName . '.' . $collectionName, $batch, $execOptions);
        $this->endProfile($token, __METHOD__);
    } catch (RuntimeException $e) {
        $this->endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), $e->getCode(), $e);
    }
    return [
        'insertedIds' => $insertedIds,
        'result' => $writeResult,
    ];
}

            

                public function explain($collectionName, $query, $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->explain($collectionName, $query);
    $cursor = $this->execute($execOptions);
    return current($cursor->toArray());
}

            

                public function find($collectionName, $condition, $options = [], $execOptions = [])
{
    $queryBuilder = $this->db->getQueryBuilder();
    $this->document = $queryBuilder->buildCondition($condition);
    if (isset($options['projection'])) {
        $options['projection'] = $queryBuilder->buildSelectFields($options['projection']);
    }
    if (isset($options['sort'])) {
        $options['sort'] = $queryBuilder->buildSortFields($options['sort']);
    }
    if (array_key_exists('limit', $options)) {
        if ($options['limit'] === null || !ctype_digit((string) $options['limit'])) {
            unset($options['limit']);
        } else {
            $options['limit'] = (int)$options['limit'];
        }
    }
    if (array_key_exists('skip', $options)) {
        if ($options['skip'] === null || !ctype_digit((string) $options['skip'])) {
            unset($options['skip']);
        } else {
            $options['skip'] = (int)$options['skip'];
        }
    }
    return $this->query($collectionName, $options, $execOptions);
}

            

                public function findAndModify($collectionName, $condition = [], $update = [], $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->findAndModify($collectionName, $condition, $update, $options);
    $cursor = $this->execute($execOptions);
    $result = current($cursor->toArray());
    if (!isset($result['value'])) {
        return null;
    }
    return $result['value'];
}

            

                public function group($collectionName, $keys, $initial, $reduce, $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->group($collectionName, $keys, $initial, $reduce, $options);
    $cursor = $this->execute($execOptions);
    $result = current($cursor->toArray());
    return $result['retval'];
}

            

                public function insert($collectionName, $document, $options = [], $execOptions = [])
{
    $this->document = [];
    $this->addInsert($document);
    $result = $this->executeBatch($collectionName, $options, $execOptions);
    if ($result['result']->getInsertedCount() < 1) {
        return false;
    }
    return reset($result['insertedIds']);
}

            

                public function listCollections($condition = [], $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->listCollections($condition, $options);
    $cursor = $this->execute($execOptions);
    return $cursor->toArray();
}

            

                public function listDatabases($condition = [], $options = [], $execOptions = [])
{
    if ($this->databaseName === null) {
        $this->databaseName = 'admin';
    }
    $this->document = $this->db->getQueryBuilder()->listDatabases($condition, $options);
    $cursor = $this->execute($execOptions);
    $result = current($cursor->toArray());
    if (empty($result['databases'])) {
        return [];
    }
    return $result['databases'];
}

            

                public function listIndexes($collectionName, $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->listIndexes($collectionName, $options);
    try {
        $cursor = $this->execute($execOptions);
    } catch (Exception $e) {
        // The server may return an error if the collection does not exist.
        $notFoundCodes = [
            26, // namespace not found
            60 // database not found
        ];
        if (in_array($e->getCode(), $notFoundCodes, true)) {
            return [];
        }
        throw $e;
    }
    return $cursor->toArray();
}

            

                protected function log($namespace, $data, $category)
{
    if ($this->db->enableLogging) {
        $token = $this->db->getLogBuilder()->generateToken($namespace, $data);
        Yii::info($token, $category);
        return $token;
    }
    return false;
}

            

                public function mapReduce($collectionName, $map, $reduce, $out, $condition = [], $options = [], $execOptions = [])
{
    $this->document = $this->db->getQueryBuilder()->mapReduce($collectionName, $map, $reduce, $out, $condition, $options);
    $cursor = $this->execute($execOptions);
    $result = current($cursor->toArray());
    return array_key_exists('results', $result) ? $result['results'] : $result['result'];
}

            

                public static function prepareManagerOptions(&$options)
{
    //Convert readConcern option
    if (array_key_exists('readConcern', $options) && is_string($options['readConcern'])) {
        $options['readConcern'] = new ReadConcern($options['readConcern']);
    }
    //Convert writeConcern option
    if (array_key_exists('writeConcern', $options)) {
        if (is_string($options['writeConcern']) || is_int($options['writeConcern'])) {
            $options['writeConcern'] = new WriteConcern($options['writeConcern']);
        } elseif (is_array($options['writeConcern'])) {
            $options['writeConcern'] = (new \ReflectionClass('\MongoDB\Driver\WriteConcern'))->newInstanceArgs($options['writeConcern']);
        }
    }
    //Convert readPreference option
    if (array_key_exists('readPreference', $options)) {
        if (is_string($options['readPreference'])) {
            $options['readPreference'] = new ReadPreference($options['readPreference']);
        } elseif (is_array($options['readPreference'])) {
            $options['readPreference'] = (new \ReflectionClass('\MongoDB\Driver\ReadPreference'))->newInstanceArgs($options['readPreference']);
        }
    }
    //Convert session option
    if (array_key_exists('session', $options) && $options['session'] instanceof ClientSession) {
        $options['session'] = $options['session']->mongoSession;
    }
}

            

                public function query($collectionName, $options = [], $execOptions = [])
{
    $this->prepareExecQueryOptions($execOptions);
    $databaseName = $this->databaseName === null ? $this->db->defaultDatabaseName : $this->databaseName;
    $token = $this->log(
        'find',
        array_merge(
            [
                'ns' => $databaseName . '.' . $collectionName,
                'filter' => $this->document,
            ],
            $options
        ),
        __METHOD__
    );
    try {
        $this->beginProfile($token, __METHOD__);
        $query = new \MongoDB\Driver\Query($this->document, $options);
        $this->db->open();
        $cursor = $this->db->manager->executeQuery($databaseName . '.' . $collectionName, $query, $execOptions);
        $cursor->setTypeMap($this->db->typeMap);
        $this->endProfile($token, __METHOD__);
    } catch (RuntimeException $e) {
        $this->endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), $e->getCode(), $e);
    }
    return $cursor;
}

            

                public function update($collectionName, $condition, $document, $options = [], $execOptions = [])
{
    $batchOptions = [];
    foreach (['bypassDocumentValidation'] as $name) {
        if (isset($options[$name])) {
            $batchOptions[$name] = $options[$name];
            unset($options[$name]);
        }
    }
    $this->document = [];
    $this->addUpdate($condition, $document, $options);
    $result = $this->executeBatch($collectionName, $batchOptions, $execOptions);
    return $result['result'];
}