Class yii\mongodb\file\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)
{
    if (!empty($this->emulateExecution)) {
        return null;
    }
    $this->prepare();
    $collection = $this->getCollection($db);
    $pipelines = [];
    if ($this->where !== null) {
        $pipelines[] = ['$match' => $this->where];
    }
    $pipelines[] = [
        '$group' => [
            '_id' => '1',
            'total' => [
                '$' . $operator => '$' . $column
            ],
        ]
    ];
    $result = $collection->aggregate($pipelines);
    if (array_key_exists(0, $result)) {
        return $result[0]['total'];
    }
    return null;
}

            

                public function all($db = null)
{
    if (!empty($this->emulateExecution)) {
        return [];
    }
    $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('/^(<>|>=|>|<=|<|=)/', (string)$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)
{
    if (!empty($this->emulateExecution)) {
        return 0;
    }
    return $this->aggregate($q, 'avg', $db);
}

            

                public function batch($batchSize = 100, $db = null)
{
    return Yii::createObject([
        'class' => BatchQueryResult::className(),
        'query' => $this,
        'batchSize' => $batchSize,
        'db' => $db,
        'each' => false,
    ]);
}

            

                public function buildCursor($db = null)
{
    $this->prepare();
    $options = $this->options;
    if (!empty($this->orderBy)) {
        $options['sort'] = $this->orderBy;
    }
    $options['limit'] = $this->limit;
    $options['skip'] = $this->offset;
    $cursor = $this->getCollection($db)->find($this->composeCondition(), $this->select, $options);
    return $cursor;
}

            

                public function column($db = null)
{
    if (!empty($this->emulateExecution)) {
        return [];
    }
    $originSelect = (array)$this->select;
    if (!isset($originSelect['_id']) && array_search('_id', $originSelect, true) === false) {
        $this->select['_id'] = false;
    }
    if (is_string($this->indexBy) && $originSelect && count($originSelect) === 1) {
        $this->select[] = $this->indexBy;
    }
    $cursor = $this->buildCursor($db);
    $rows = $this->fetchRows($cursor, true);
    if (empty($rows)) {
        return [];
    }
    $results = [];
    foreach ($rows as $row) {
        $value = reset($row);
        if ($this->indexBy === null) {
            $results[] = $value;
        } else {
            if ($this->indexBy instanceof \Closure) {
                $results[call_user_func($this->indexBy, $row)] = $value;
            } else {
                $results[$row[$this->indexBy]] = $value;
            }
        }
    }
    return $results;
}

            

                public function count($q = '*', $db = null)
{
    if (!empty($this->emulateExecution)) {
        return 0;
    }
    $this->prepare();
    $collection = $this->getCollection($db);
    return $collection->count($this->where, $this->options);
}

            

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

            

                public function each($batchSize = 100, $db = null)
{
    return Yii::createObject([
        'class' => BatchQueryResult::className(),
        'query' => $this,
        'batchSize' => $batchSize,
        'db' => $db,
        'each' => true,
    ]);
}

            

                public function exists($db = null)
{
    if (!empty($this->emulateExecution)) {
        return false;
    }
    $cursor = $this->buildCursor($db);
    foreach ($cursor as $row) {
        return true;
    }
    return false;
}

            

                protected function fetchRows($cursor, $all = true, $indexBy = null)
{
    $token = 'fetch cursor id = ' . $cursor->getId();
    Yii::info($token, __METHOD__);
    try {
        Yii::beginProfile($token, __METHOD__);
        $result = $this->fetchRowsInternal($cursor, $all);
        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)
{
    $result = [];
    if ($all) {
        foreach ($cursor as $row) {
            $result[] = $row;
        }
    } else {
        if ($row = current($cursor->toArray())) {
            $result = $row;
        } else {
            $result = false;
        }
    }
    return $result;
}

            

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

            

                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)
{
    if (!empty($this->emulateExecution)) {
        return null;
    }
    $this->prepare();
    $collection = $this->getCollection($db);
    if (!empty($this->orderBy)) {
        $options['sort'] = $this->orderBy;
    }
    $options['fields'] = $this->select;
    return $collection->findAndModify($this->composeCondition(), $update, $options);
}

            

                public function one($db = null)
{
    if (!empty($this->emulateExecution)) {
        return false;
    }
    $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) {
        $result[ArrayHelper::getValue($row, $this->indexBy)] = $row;
    }
    return $result;
}

            

                public function prepare()
{
    return $this;
}

            

                public function scalar($db = null)
{
    if (!empty($this->emulateExecution)) {
        return null;
    }
    $originSelect = (array)$this->select;
    if (!isset($originSelect['_id']) && array_search('_id', $originSelect, true) === false) {
        $this->select['_id'] = false;
    }
    $cursor = $this->buildCursor($db);
    $row = $this->fetchRows($cursor, false);
    if (empty($row)) {
        return false;
    }
    return reset($row);
}

            

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

            

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