Class yii\mongodb\file\Collection

                public function aggregate($pipeline, $pipelineOperator = [])
{
    $args = func_get_args();
    $token = $this->composeLogToken('aggregate', $args);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = call_user_func_array([$this->mongoCollection, 'aggregate'], $args);
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        return $result['result'];
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function batchInsert($rows, $options = [])
{
    $token = $this->composeLogToken('batchInsert', [$rows]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $options = array_merge(['w' => 1], $options);
        $this->tryResultError($this->mongoCollection->batchInsert($rows, $options));
        Yii::endProfile($token, __METHOD__);
        return $rows;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function buildAndCondition($operator, $operands)
{
    $operator = $this->normalizeConditionKeyword($operator);
    $parts = [];
    foreach ($operands as $operand) {
        $parts[] = $this->buildCondition($operand);
    }
    return [$operator => $parts];
}

            

                public function buildBetweenCondition($operator, $operands)
{
    if (!isset($operands[0], $operands[1], $operands[2])) {
        throw new InvalidParamException("Operator '$operator' requires three operands.");
    }
    list($column, $value1, $value2) = $operands;
    if (strncmp('NOT', $operator, 3) === 0) {
        return [
            $column => [
                '$lt' => $value1,
                '$gt' => $value2,
            ]
        ];
    } else {
        return [
            $column => [
                '$gte' => $value1,
                '$lte' => $value2,
            ]
        ];
    }
}

            

                public function buildCondition($condition)
{
    static $builders = [
        'NOT' => 'buildNotCondition',
        'AND' => 'buildAndCondition',
        'OR' => 'buildOrCondition',
        'BETWEEN' => 'buildBetweenCondition',
        'NOT BETWEEN' => 'buildBetweenCondition',
        'IN' => 'buildInCondition',
        'NOT IN' => 'buildInCondition',
        'REGEX' => 'buildRegexCondition',
        'LIKE' => 'buildLikeCondition',
    ];
    if (!is_array($condition)) {
        throw new InvalidParamException('Condition should be an array.');
    } elseif (empty($condition)) {
        return [];
    }
    if (isset($condition[0])) { // operator format: operator, operand 1, operand 2, ...
        $operator = strtoupper($condition[0]);
        if (isset($builders[$operator])) {
            $method = $builders[$operator];
        } else {
            $operator = $condition[0];
            $method = 'buildSimpleCondition';
        }
        array_shift($condition);
        return $this->$method($operator, $condition);
    } else {
        // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
        return $this->buildHashCondition($condition);
    }
}

            

                public function buildHashCondition($condition)
{
    $result = [];
    foreach ($condition as $name => $value) {
        if (strncmp('$', $name, 1) === 0) {
            // Native Mongo condition:
            $result[$name] = $value;
        } else {
            if (is_array($value)) {
                if (ArrayHelper::isIndexed($value)) {
                    // Quick IN condition:
                    $result = array_merge($result, $this->buildInCondition('IN', [$name, $value]));
                } else {
                    // Mongo complex condition:
                    $result[$name] = $value;
                }
            } else {
                // Direct match:
                if ($name == '_id') {
                    $value = $this->ensureMongoId($value);
                }
                $result[$name] = $value;
            }
        }
    }
    return $result;
}

            

                public function buildInCondition($operator, $operands)
{
    if (!isset($operands[0], $operands[1])) {
        throw new InvalidParamException("Operator '$operator' requires two operands.");
    }
    list($column, $values) = $operands;
    $values = (array) $values;
    $operator = $this->normalizeConditionKeyword($operator);
    if (!is_array($column)) {
        $columns = [$column];
        $values = [$column => $values];
    } elseif (count($column) > 1) {
        return $this->buildCompositeInCondition($operator, $column, $values);
    } else {
        $columns = $column;
        $values = [$column[0] => $values];
    }
    $result = [];
    foreach ($columns as $column) {
        if ($column == '_id') {
            $inValues = $this->ensureMongoId($values[$column]);
        } else {
            $inValues = $values[$column];
        }
        $inValues = array_values($inValues);
        if (count($inValues) === 1 && $operator === '$in') {
            $result[$column] = $inValues[0];
        } else {
            $result[$column][$operator] = $inValues;
        }
    }
    return $result;
}

            

                public function buildLikeCondition($operator, $operands)
{
    if (!isset($operands[0], $operands[1])) {
        throw new InvalidParamException("Operator '$operator' requires two operands.");
    }
    list($column, $value) = $operands;
    if (!($value instanceof \MongoRegex)) {
        $value = new \MongoRegex('/' . preg_quote($value) . '/i');
    }
    return [$column => $value];
}

            

                public function buildNotCondition($operator, $operands)
{
    if (!isset($operands[0], $operands[1])) {
        throw new InvalidParamException("Operator '$operator' requires two operands.");
    }
    list($name, $value) = $operands;
    $result = [];
    if (is_array($value)) {
        $result[$name] = ['$not' => $this->buildCondition($value)];
    } else {
        if ($name == '_id') {
            $value = $this->ensureMongoId($value);
        }
        $result[$name] = ['$ne' => $value];
    }
    return $result;
}

            

                public function buildOrCondition($operator, $operands)
{
    $operator = $this->normalizeConditionKeyword($operator);
    $parts = [];
    foreach ($operands as $operand) {
        $parts[] = $this->buildCondition($operand);
    }
    return [$operator => $parts];
}

            

                public function buildRegexCondition($operator, $operands)
{
    if (!isset($operands[0], $operands[1])) {
        throw new InvalidParamException("Operator '$operator' requires two operands.");
    }
    list($column, $value) = $operands;
    if (!($value instanceof \MongoRegex)) {
        $value = new \MongoRegex($value);
    }
    return [$column => $value];
}

            

                public function buildSimpleCondition($operator, $operands)
{
    if (count($operands) !== 2) {
        throw new InvalidParamException("Operator '$operator' requires two operands.");
    }
    list($column, $value) = $operands;
    if (strncmp('$', $operator, 1) !== 0) {
        static $operatorMap = [
            '>' => '$gt',
            '<' => '$lt',
            '>=' => '$gte',
            '<=' => '$lte',
            '!=' => '$ne',
            '<>' => '$ne',
            '=' => '$eq',
            '==' => '$eq',
        ];
        if (isset($operatorMap[$operator])) {
            $operator = $operatorMap[$operator];
        } else {
            throw new InvalidParamException("Unsupported operator '{$operator}'");
        }
    }
    return [$column => [$operator => $value]];
}

            

                protected function composeLogToken($command, $arguments = [])
{
    $parts = [];
    foreach ($arguments as $argument) {
        $parts[] = is_scalar($argument) ? $argument : $this->encodeLogData($argument);
    }
    return $this->getFullName() . '.' . $command . '(' . implode(', ', $parts) . ')';
}

            

                public function createIndex($columns, $options = [])
{
    $columns = (array)$columns;
    $keys = $this->normalizeIndexKeys($columns);
    $token = $this->composeLogToken('createIndex', [$keys, $options]);
    $options = array_merge(['w' => 1], $options);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        if (method_exists($this->mongoCollection, 'createIndex')) {
            $result = $this->mongoCollection->createIndex($keys, $options);
        } else {
            $result = $this->mongoCollection->ensureIndex($keys, $options);
        }
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        return true;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function distinct($column, $condition = [])
{
    $condition = $this->buildCondition($condition);
    $token = $this->composeLogToken('distinct', [$column, $condition]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        // See https://bugs.php.net/bug.php?id=68858
        if (empty($condition)) {
            $result = $this->mongoCollection->distinct($column);
        } else {
            $result = $this->mongoCollection->distinct($column, $condition);
        }
        Yii::endProfile($token, __METHOD__);
        return $result;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function drop()
{
    $token = $this->composeLogToken('drop');
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $this->mongoCollection->drop();
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        return true;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function dropAllIndexes()
{
    $token = $this->composeLogToken('dropIndexes');
    Yii::info($token, __METHOD__);
    try {
        $result = $this->mongoCollection->deleteIndexes();
        $this->tryResultError($result);
        return $result['nIndexesWas'];
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function dropIndex($columns)
{
    $columns = (array)$columns;
    $keys = $this->normalizeIndexKeys($columns);
    $token = $this->composeLogToken('dropIndex', [$keys]);
    Yii::info($token, __METHOD__);
    try {
        $result = $this->mongoCollection->deleteIndex($keys);
        $this->tryResultError($result);
        return true;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                protected function encodeLogData($data)
{
    return json_encode($this->processLogData($data));
}

            

                protected function ensureMongoId($rawId)
{
    if (is_array($rawId)) {
        $result = [];
        foreach ($rawId as $key => $value) {
            $result[$key] = $this->ensureMongoId($value);
        }
        return $result;
    } elseif (is_object($rawId)) {
        if ($rawId instanceof \MongoId) {
            return $rawId;
        } else {
            $rawId = (string) $rawId;
        }
    }
    try {
        $mongoId = new \MongoId($rawId);
    } catch (\MongoException $e) {
        // invalid id format
        $mongoId = $rawId;
    }
    return $mongoId;
}

            

                public function find($condition = [], $fields = [])
{
    return $this->mongoCollection->find($this->buildCondition($condition), $fields);
}

            

                public function findAndModify($condition, $update, $fields = [], $options = [])
{
    $condition = $this->buildCondition($condition);
    $token = $this->composeLogToken('findAndModify', [$condition, $update, $fields, $options]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $this->mongoCollection->findAndModify($condition, $update, $fields, $options);
        Yii::endProfile($token, __METHOD__);
        return $result;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function findOne($condition = [], $fields = [])
{
    return $this->mongoCollection->findOne($this->buildCondition($condition), $fields);
}

            

                public function fullTextSearch($search, $condition = [], $fields = [], $options = [])
{
    $command = [
        'search' => $search
    ];
    if (!empty($condition)) {
        $command['filter'] = $this->buildCondition($condition);
    }
    if (!empty($fields)) {
        $command['project'] = $fields;
    }
    if (!empty($options)) {
        $command = array_merge($command, $options);
    }
    $token = $this->composeLogToken('text', $command);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $command = array_merge(['text' => $this->getName()], $command);
        $result = $this->mongoCollection->db->command($command);
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        return $result['results'];
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function getFullName()
{
    return $this->mongoCollection->__toString();
}

            

                public function getLastError()
{
    return $this->mongoCollection->db->lastError();
}

            

                public function getName()
{
    return $this->mongoCollection->getName();
}

            

                public function group($keys, $initial, $reduce, $options = [])
{
    if (!($reduce instanceof \MongoCode)) {
        $reduce = new \MongoCode((string) $reduce);
    }
    if (array_key_exists('condition', $options)) {
        $options['condition'] = $this->buildCondition($options['condition']);
    }
    if (array_key_exists('finalize', $options)) {
        if (!($options['finalize'] instanceof \MongoCode)) {
            $options['finalize'] = new \MongoCode((string) $options['finalize']);
        }
    }
    $token = $this->composeLogToken('group', [$keys, $initial, $reduce, $options]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        // Avoid possible E_DEPRECATED for $options:
        if (empty($options)) {
            $result = $this->mongoCollection->group($keys, $initial, $reduce);
        } else {
            $result = $this->mongoCollection->group($keys, $initial, $reduce, $options);
        }
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        if (array_key_exists('retval', $result)) {
            return $result['retval'];
        } else {
            return [];
        }
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function insert($data, $options = [])
{
    $token = $this->composeLogToken('insert', [$data]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $options = array_merge(['w' => 1], $options);
        $this->tryResultError($this->mongoCollection->insert($data, $options));
        Yii::endProfile($token, __METHOD__);
        return is_array($data) ? $data['_id'] : $data->_id;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function mapReduce($map, $reduce, $out, $condition = [], $options = [])
{
    if (!($map instanceof \MongoCode)) {
        $map = new \MongoCode((string) $map);
    }
    if (!($reduce instanceof \MongoCode)) {
        $reduce = new \MongoCode((string) $reduce);
    }
    $command = [
        'mapReduce' => $this->getName(),
        'map' => $map,
        'reduce' => $reduce,
        'out' => $out
    ];
    if (!empty($condition)) {
        $command['query'] = $this->buildCondition($condition);
    }
    if (array_key_exists('finalize', $options)) {
        if (!($options['finalize'] instanceof \MongoCode)) {
            $options['finalize'] = new \MongoCode((string) $options['finalize']);
        }
    }
    if (!empty($options)) {
        $command = array_merge($command, $options);
    }
    $token = $this->composeLogToken('mapReduce', [$map, $reduce, $out]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $command = array_merge(['mapReduce' => $this->getName()], $command);
        $result = $this->mongoCollection->db->command($command);
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        return array_key_exists('results', $result) ? $result['results'] : $result['result'];
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                protected function normalizeConditionKeyword($key)
{
    static $map = [
        'AND' => '$and',
        'OR' => '$or',
        'IN' => '$in',
        'NOT IN' => '$nin',
    ];
    $matchKey = strtoupper($key);
    if (array_key_exists($matchKey, $map)) {
        return $map[$matchKey];
    } else {
        return $key;
    }
}

            

                protected function normalizeIndexKeys($columns)
{
    $keys = [];
    foreach ($columns as $key => $value) {
        if (is_numeric($key)) {
            $keys[$value] = \MongoCollection::ASCENDING;
        } else {
            $keys[$key] = $value;
        }
    }
    return $keys;
}

            

                protected function processLogData($data)
{
    if (is_object($data)) {
        if ($data instanceof \MongoId ||
            $data instanceof \MongoRegex ||
            $data instanceof \MongoDate ||
            $data instanceof \MongoInt32 ||
            $data instanceof \MongoInt64 ||
            $data instanceof \MongoTimestamp
        ) {
            $data = get_class($data) . '(' . $data->__toString() . ')';
        } elseif ($data instanceof \MongoCode) {
            $data = 'MongoCode( ' . $data->__toString() . ' )';
        } elseif ($data instanceof \MongoBinData) {
            $data = 'MongoBinData(...)';
        } elseif ($data instanceof \MongoDBRef) {
            $data = 'MongoDBRef(...)';
        } elseif ($data instanceof \MongoMinKey || $data instanceof \MongoMaxKey) {
            $data = get_class($data);
        } else {
            $result = [];
            foreach ($data as $name => $value) {
                $result[$name] = $value;
            }
            $data = $result;
        }
        if ($data === []) {
            return new \stdClass();
        }
    }
    if (is_array($data)) {
        foreach ($data as $key => $value) {
            if (is_array($value) || is_object($value)) {
                $data[$key] = $this->processLogData($value);
            }
        }
    }
    return $data;
}

            

                public function save($data, $options = [])
{
    $token = $this->composeLogToken('save', [$data]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $options = array_merge(['w' => 1], $options);
        $this->tryResultError($this->mongoCollection->save($data, $options));
        Yii::endProfile($token, __METHOD__);
        return is_array($data) ? $data['_id'] : $data->_id;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                protected function tryLastError()
{
    $this->tryResultError($this->getLastError());
}

            

                protected function tryResultError($result)
{
    if (is_array($result)) {
        if (!empty($result['errmsg'])) {
            $errorMessage = $result['errmsg'];
        } elseif (!empty($result['err'])) {
            $errorMessage = $result['err'];
        }
        if (isset($errorMessage)) {
            if (array_key_exists('code', $result)) {
                $errorCode = (int) $result['code'];
            } elseif (array_key_exists('ok', $result)) {
                $errorCode = (int) $result['ok'];
            } else {
                $errorCode = 0;
            }
            throw new Exception($errorMessage, $errorCode);
        }
    } elseif (!$result) {
        throw new Exception('Unknown error, use "w=1" option to enable error tracking');
    }
}

            

                public function update($condition, $newData, $options = [])
{
    $condition = $this->buildCondition($condition);
    $options = array_merge(['w' => 1, 'multiple' => true], $options);
    if ($options['multiple']) {
        $keys = array_keys($newData);
        if (!empty($keys) && strncmp('$', $keys[0], 1) !== 0) {
            $newData = ['$set' => $newData];
        }
    }
    $token = $this->composeLogToken('update', [$condition, $newData, $options]);
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $this->mongoCollection->update($condition, $newData, $options);
        $this->tryResultError($result);
        Yii::endProfile($token, __METHOD__);
        if (is_array($result) && array_key_exists('n', $result)) {
            return $result['n'];
        } else {
            return true;
        }
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}