Class yii\mongodb\file\Collection

                public function __call($name, $params)
{
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter();
    } elseif (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter($value);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    } else {
        throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function aggregate($pipelines, $options = [], $execOptions = [])
{
    return $this->database->createCommand()->aggregate($this->name, $pipelines, $options, $execOptions);
}

            

                public function batchInsert($rows, $options = [], $execOptions = [])
{
    $insertedIds = $this->database->createCommand()->batchInsert($this->name, $rows, $options, $execOptions);
    foreach ($rows as $key => $row) {
        $rows[$key]['_id'] = $insertedIds[$key];
    }
    return $rows;
}

            

                public function canGetProperty($name, $checkVars = true)
{
    return method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name);
}

            

                public function canSetProperty($name, $checkVars = true)
{
    return method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name);
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function count($condition = [], $options = [], $execOptions = [])
{
    return $this->database->createCommand()->count($this->name, $condition, $options, $execOptions);
}

            

                public function createIndex($columns, $options = [], $execOptions = [])
{
    $index = array_merge(['key' => $columns], $options);
    return $this->database->createCommand()->createIndexes($this->name, [$index], $execOptions);
}

            

                public function createIndexes($indexes, $execOptions = [])
{
    return $this->database->createCommand()->createIndexes($this->name, $indexes, $execOptions);
}

            

                public function distinct($column, $condition = [], $options = [], $execOptions = [])
{
    return $this->database->createCommand()->distinct($this->name, $column, $condition, $options, $execOptions);
}

            

                public function documentExists($condition = [])
{
    return static::findOne($condition, ['_id' => 1]) !== null;
}

            

                public function dropAllIndexes($execOptions = [])
{
    $result = $this->database->createCommand()->dropIndexes($this->name, '*', $execOptions);
    return isset($result['nIndexesWas']) ? $result['nIndexesWas'] : 0;
}

            

                public function dropIndex($columns, $execOptions = [])
{
    $existingIndexes = $this->listIndexes();
    $indexKey = $this->database->connection->getQueryBuilder()->buildSortFields($columns);
    foreach ($existingIndexes as $index) {
        if ($index['key'] == $indexKey) {
            $this->database->createCommand()->dropIndexes($this->name, $index['name'], $execOptions);
            return true;
        }
    }
    // Index plugin usage such as 'text' may cause unpredictable index 'key' structure, thus index name should be used
    $indexName = $this->database->connection->getQueryBuilder()->generateIndexName($indexKey);
    foreach ($existingIndexes as $index) {
        if ($index['name'] === $indexName) {
            $this->database->createCommand()->dropIndexes($this->name, $index['name'], $execOptions);
            return true;
        }
    }
    throw new Exception('Index to be dropped does not exist.');
}

            

                public function dropIndexes($indexes, $execOptions = [])
{
    $result = $this->database->createCommand()->dropIndexes($this->name, $indexes, $execOptions);
    return $result['nIndexesWas'];
}

            

                public function findAndModify($condition, $update, $options = [], $execOptions = [])
{
    return $this->database->createCommand()->findAndModify($this->name, $condition, $update, $options, $execOptions);
}

            

                public function findOne($condition = [], $fields = [], $options = [], $execOptions = [])
{
    $options['limit'] = 1;
    $cursor = $this->find($condition, $fields, $options, $execOptions);
    $rows = $cursor->toArray();
    return empty($rows) ? null : current($rows);
}

            

                public function getFullName()
{
    return $this->database->name . '.' . $this->name;
}

            

                public function group($keys, $initial, $reduce, $options = [], $execOptions = [])
{
    return $this->database->createCommand()->group($this->name, $keys, $initial, $reduce, $options, $execOptions);
}

            

                public function hasMethod($name)
{
    return method_exists($this, $name);
}

            

                public function hasProperty($name, $checkVars = true)
{
    return $this->canGetProperty($name, $checkVars) || $this->canSetProperty($name, false);
}

            

                public function init()
{
}

            

                public function insert($data, $options = [], $execOptions = [])
{
    return $this->database->createCommand()->insert($this->name, $data, $options, $execOptions);
}

            

                public function listIndexes($options = [], $execOptions = [])
{
    return $this->database->createCommand()->listIndexes($this->name, $options, $execOptions);
}

            

                public function mapReduce($map, $reduce, $out, $condition = [], $options = [], $execOptions = [])
{
    return $this->database->createCommand()->mapReduce($this->name, $map, $reduce, $out, $condition, $options, $execOptions);
}

            

                public function save($data, $options = [], $execOptions = [])
{
    if (empty($data['_id'])) {
        return $this->insert($data, $options, $execOptions);
    }
    $id = $data['_id'];
    unset($data['_id']);
    $this->update(['_id' => $id], ['$set' => $data], ['upsert' => true], $execOptions);
    return is_object($id) ? $id : new ObjectID($id);
}

            

                public function update($condition, $newData, $options = [], $execOptions = [])
{
    $writeResult = $this->database->createCommand()->update($this->name, $condition, $newData, $options, $execOptions);
    return $writeResult->getModifiedCount() + $writeResult->getUpsertedCount();
}