Class yii\elasticsearch\Query

                public function addAgg($name, $type, $options)
{
    return $this->addAggregate($name, [$type => $options]);
}

            

                public function addAggregate($name, $options)
{
    $this->aggregations[$name] = $options;
    return $this;
}

            

                public function addAggregation($name, $type, $options)
{
    return $this->addAggregate($name, [$type => $options]);
}

            

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

            

                public function addOptions($options)
{
    if (!is_array($options)) {
        throw new InvalidArgumentException('Array parameter expected, ' . gettype($options) . ' received.');
    }
    $this->options = array_merge($this->options, $options);
    return $this;
}

            

                public function addSuggester($name, $definition)
{
    $this->suggest[$name] = $definition;
    return $this;
}

            

                public function all($db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    $result = $this->createCommand($db)->search();
    if ($result === false) {
        throw new Exception('Elasticsearch search query failed.');
    }
    if (empty($result['hits']['hits'])) {
        return [];
    }
    $rows = $result['hits']['hits'];
    return $this->populate($rows);
}

            

                public function andWhere($condition)
{
    if ($this->where === null) {
        $this->where = $condition;
    } else if (isset($this->where[0]) && $this->where[0] === 'and') {
        $this->where[] = $condition;
    } else {
        $this->where = ['and', $this->where, $condition];
    }
    return $this;
}

            

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

            

                public function column($field, $db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    $command = $this->createCommand($db);
    $command->queryParts['_source'] = [$field];
    $result = $command->search();
    if ($result === false) {
        throw new Exception('Elasticsearch search query failed.');
    }
    if (empty($result['hits']['hits'])) {
        return [];
    }
    $column = [];
    foreach ($result['hits']['hits'] as $row) {
        if (isset($row['fields'][$field])) {
            $column[] = $row['fields'][$field];
        } elseif (isset($row['_source'][$field])) {
            $column[] = $row['_source'][$field];
        } else {
            $column[] = null;
        }
    }
    return $column;
}

            

                public function count($q = '*', $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    $command = $this->createCommand($db);
    // performing a query with return size of 0, is equal to getting result stats such as count
    // https://www.elastic.co/guide/en/elasticsearch/reference/5.6/breaking_50_search_changes.html#_literal_search_type_literal
    $searchOptions = ['size' => 0];
    // Set track_total_hits to 'true' for ElasticSearch version 6 and up
    // https://www.elastic.co/guide/en/elasticsearch/reference/master/search-your-data.html#track-total-hits
    if ($command->db->dslVersion >= 6) {
        $searchOptions['track_total_hits'] = 'true';
    }
    $result = $command->search($searchOptions);
    // since ES7 totals are returned as array (with count and precision values)
    if (isset($result['hits']['total'])) {
        return is_array($result['hits']['total']) ? (int)$result['hits']['total']['value'] : (int)$result['hits']['total'];
    }
    return 0;
}

            

                public function createCommand($db = null)
{
    if ($db === null) {
        $db = Yii::$app->get('elasticsearch');
    }
    $commandConfig = $db->getQueryBuilder()->build($this);
    return $db->createCommand($commandConfig);
}

            

                public function delete($db = null, $options = [])
{
    if ($this->emulateExecution) {
        return [];
    }
    return $this->createCommand($db)->deleteByQuery($options);
}

            

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

            

                public function exists($db = null)
{
    return self::one($db) !== false;
}

            

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

            

                public function fields($fields)
{
    if (is_array($fields) || $fields === null) {
        $this->fields = $fields;
    } else {
        $this->fields = func_get_args();
    }
    return $this;
}

            

                public function from($index, $type = null)
{
    $this->index = $index;
    $this->type = $type;
    return $this;
}

            

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

            

                public function init()
{
    parent::init();
    // setting the default limit according to Elasticsearch defaults
    // https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-body.html#_parameters_5
    if ($this->limit === null) {
        $this->limit = 10;
    }
}

            

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

            

                public function one($db = null)
{
    if ($this->emulateExecution) {
        return false;
    }
    $result = $this->createCommand($db)->search(['size' => 1]);
    if ($result === false) {
        throw new Exception('Elasticsearch search query failed.');
    }
    if (empty($result['hits']['hits'])) {
        return false;
    }
    $record = reset($result['hits']['hits']);
    return $record;
}

            

                public function options($options)
{
    if (!is_array($options)) {
        throw new InvalidArgumentException('Array parameter expected, ' . gettype($options) . ' received.');
    }
    $this->options = $options;
    return $this;
}

            

                public function orWhere($condition)
{
    if ($this->where === null) {
        $this->where = $condition;
    } else if (isset($this->where[0]) && $this->where[0] === 'or') {
        $this->where[] = $condition;
    } else {
        $this->where = ['or', $this->where, $condition];
    }
    return $this;
}

            

                public function populate($rows)
{
    if ($this->indexBy === null) {
        return $rows;
    }
    $models = [];
    foreach ($rows as $key => $row) {
        if ($this->indexBy !== null) {
            if (is_string($this->indexBy)) {
                $key = isset($row['fields'][$this->indexBy]) ?
                    reset($row['fields'][$this->indexBy]) : $row['_source'][$this->indexBy];
            } else {
                $key = call_user_func($this->indexBy, $row);
            }
        }
        $models[$key] = $row;
    }
    return $models;
}

            

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

            

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

            

                public function runtimeMappings($mappings)
{
    if (is_array($mappings) || $mappings === null) {
        $this->runtimeMappings = $mappings;
    } else {
        $this->runtimeMappings = func_get_args();
    }
    return $this;
}

            

                public function scalar($field, $db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    $record = self::one($db);
    if ($record !== false) {
        if ($field === '_id') {
            return $record['_id'];
        } elseif (isset($record['_source'][$field])) {
            return $record['_source'][$field];
        } elseif (isset($record['fields'][$field])) {
            return count($record['fields'][$field]) == 1 ? reset($record['fields'][$field]) : $record['fields'][$field];
        }
    }
    return null;
}

            

                public function scriptFields($fields)
{
    if (is_array($fields) || $fields === null) {
        $this->scriptFields = $fields;
    } else {
        $this->scriptFields = func_get_args();
    }
    return $this;
}

            

                public function search($db = null, $options = [])
{
    if ($this->emulateExecution) {
        return [
            'hits' => [
                'total' => 0,
                'hits' => [],
            ],
        ];
    }
    $result = $this->createCommand($db)->search($options);
    if ($result === false) {
        throw new Exception('Elasticsearch search query failed.');
    }
    if (!empty($result['hits']['hits']) && $this->indexBy !== null) {
        $rows = [];
        foreach ($result['hits']['hits'] as $key => $row) {
            if (is_string($this->indexBy)) {
                $key = isset($row['fields'][$this->indexBy]) ?
                    $row['fields'][$this->indexBy] : $row['_source'][$this->indexBy];
            } else {
                $key = call_user_func($this->indexBy, $row);
            }
            $rows[$key] = $row;
        }
        $result['hits']['hits'] = $rows;
    }
    return $result;
}

            

                public function source($source)
{
    if (is_array($source) || $source === null  || $source === false) {
        $this->source = $source;
    } else {
        $this->source = func_get_args();
    }
    return $this;
}

            

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

            

                public function storedFields($fields)
{
    if (is_array($fields) || $fields === null) {
        $this->storedFields = $fields;
    } else {
        $this->storedFields = func_get_args();
    }
    return $this;
}

            

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