Class yii\mongodb\Query

                public function addOptions($options)
{
    if (is_array($this->options)) {
        $this->options = array_merge($this->options, $options);
    } else {
        $this->options = $options;
    }
    return $this;
}

            

                protected function aggregate($column, $operator, $db)
{
    $collection = $this->getCollection($db);
    $pipelines = [];
    if ($this->where !== null) {
        $pipelines[] = ['$match' => $collection->buildCondition($this->where)];
    }
    $pipelines[] = [
        '$group' => [
            '_id' => '1',
            'total' => [
                '$' . $operator => '$' . $column
            ],
        ]
    ];
    $result = $collection->aggregate($pipelines);
    if (array_key_exists(0, $result)) {
        return $result[0]['total'];
    } else {
        return 0;
    }
}

            

                public function all($db = null)
{
    $cursor = $this->buildCursor($db);
    $rows = $this->fetchRows($cursor, true, $this->indexBy);
    return $this->populate($rows);
}

            

                public function andFilterCompare($name, $value, $defaultOperator = '=')
{
    $matches = [];
    if (preg_match('/^(<>|>=|>|<=|<|=)/', $value, $matches)) {
        $op = $matches[1];
        $value = substr($value, strlen($op));
    } else {
        $op = $defaultOperator;
    }
    return $this->andFilterWhere([$op, $name, $value]);
}

            

                public function average($q, $db = null)
{
    return $this->aggregate($q, 'avg', $db);
}

            

                protected function buildCursor($db = null)
{
    $cursor = $this->getCollection($db)->find($this->composeCondition(), $this->composeSelectFields());
    if (!empty($this->orderBy)) {
        $cursor->sort($this->composeSort());
    }
    $cursor->limit($this->limit);
    $cursor->skip($this->offset);
    foreach ($this->options as $key => $value) {
        $cursor->addOption($key, $value);
    }
    return $cursor;
}

            

                public function count($q = '*', $db = null)
{
    $cursor = $this->buildCursor($db);
    $token = 'find.count(' . Json::encode($cursor->info()) . ')';
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $cursor->count();
        Yii::endProfile($token, __METHOD__);
        return $result;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                public function distinct($q, $db = null)
{
    $collection = $this->getCollection($db);
    if ($this->where !== null) {
        $condition = $this->where;
    } else {
        $condition = [];
    }
    $result = $collection->distinct($q, $condition);
    if ($result === false) {
        return [];
    } else {
        return $result;
    }
}

            

                public function exists($db = null)
{
    return $this->one($db) !== null;
}

            

                protected function fetchRows($cursor, $all = true, $indexBy = null)
{
    $token = 'find(' . Json::encode($cursor->info()) . ')';
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $this->fetchRowsInternal($cursor, $all, $indexBy);
        Yii::endProfile($token, __METHOD__);
        return $result;
    } catch (\Exception $e) {
        Yii::endProfile($token, __METHOD__);
        throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
    }
}

            

                protected function fetchRowsInternal($cursor, $all, $indexBy)
{
    $result = [];
    if ($all) {
        foreach ($cursor as $row) {
            $result[] = $row;
        }
    } else {
        if ($row = $cursor->getNext()) {
            $result = $row;
        } else {
            $result = false;
        }
    }
    return $result;
}

            

                public function from($collection)
{
    $this->from = $collection;
    return $this;
}

            

                public function getCollection($db = null)
{
    if ($db === null) {
        $db = Yii::$app->get('mongodb');
    }
    return $db->getCollection($this->from);
}

            

                public function max($q, $db = null)
{
    return $this->aggregate($q, 'max', $db);
}

            

                public function min($q, $db = null)
{
    return $this->aggregate($q, 'min', $db);
}

            

                public function modify($update, $options = [], $db = null)
{
    $collection = $this->getCollection($db);
    if (!empty($this->orderBy)) {
        $options['sort'] = $this->composeSort();
    }
    return $collection->findAndModify($this->composeCondition(), $update, $this->composeSelectFields(), $options);
}

            

                public function one($db = null)
{
    $cursor = $this->buildCursor($db);
    return $this->fetchRows($cursor, false);
}

            

                public function options($options)
{
    $this->options = $options;
    return $this;
}

            

                public function populate($rows)
{
    if ($this->indexBy === null) {
        return $rows;
    }
    $result = [];
    foreach ($rows as $row) {
        if (is_string($this->indexBy)) {
            $key = $row[$this->indexBy];
        } else {
            $key = call_user_func($this->indexBy, $row);
        }
        $result[$key] = $row;
    }
    return $result;
}

            

                public function select(array $fields)
{
    $this->select = $fields;
    return $this;
}

            

                public function sum($q, $db = null)
{
    return $this->aggregate($q, 'sum', $db);
}