Class yii\elasticsearch\QueryBuilder

                public function __construct($connection, $config = [])
{
    $this->db = $connection;
    parent::__construct($config);
}

            

                public function build($query)
{
    $parts = [];
    if ($query->storedFields !== null) {
        $parts['stored_fields'] = $query->storedFields;
    }
    if ($query->scriptFields !== null) {
        $parts['script_fields'] = $query->scriptFields;
    }
    if ($query->runtimeMappings !== null) {
        $parts['runtime_mappings'] = $query->runtimeMappings;
    }
    if ($query->fields !== null) {
        $parts['fields'] = $query->fields;
    }
    if ($query->source !== null) {
        $parts['_source'] = $query->source;
    }
    if ($query->limit !== null && $query->limit >= 0) {
        $parts['size'] = $query->limit;
    }
    if ($query->offset > 0) {
        $parts['from'] = (int)$query->offset;
    }
    if (isset($query->minScore)) {
        $parts['min_score'] = (float)$query->minScore;
    }
    if (isset($query->explain)) {
        $parts['explain'] = $query->explain;
    }
    // combine query with where
    $conditionals = [];
    $whereQuery = $this->buildQueryFromWhere($query->where);
    if ($whereQuery) {
        $conditionals[] = $whereQuery;
    }
    if ($query->query) {
        $conditionals[] = $query->query;
    }
    if (count($conditionals) === 2) {
        $parts['query'] = ['bool' => ['must' => $conditionals]];
    } elseif (count($conditionals) === 1) {
        $parts['query'] = reset($conditionals);
    }
    if (!empty($query->highlight)) {
        $parts['highlight'] = $query->highlight;
    }
    if (!empty($query->aggregations)) {
        $parts['aggregations'] = $query->aggregations;
    }
    if (!empty($query->stats)) {
        $parts['stats'] = $query->stats;
    }
    if (!empty($query->suggest)) {
        $parts['suggest'] = $query->suggest;
    }
    if (!empty($query->postFilter)) {
        $parts['post_filter'] = $query->postFilter;
    }
    if (!empty($query->collapse)) {
        $parts['collapse'] = $query->collapse;
    }
    $sort = $this->buildOrderBy($query->orderBy);
    if (!empty($sort)) {
        $parts['sort'] = $sort;
    }
    $options = $query->options;
    if ($query->timeout !== null) {
        $options['timeout'] = $query->timeout;
    }
    return [
        'queryParts' => $parts,
        'index' => $query->index,
        'type' => $query->type,
        'options' => $options,
    ];
}

            

                protected function buildCompositeInCondition($operator, $columns, $values)
{
    throw new NotSupportedException('composite in is not supported by Elasticsearch.');
}

            

                public function buildCondition($condition)
{
    static $builders = [
        'not' => 'buildNotCondition',
        'and' => 'buildBoolCondition',
        'or' => 'buildBoolCondition',
        'between' => 'buildBetweenCondition',
        'not between' => 'buildBetweenCondition',
        'in' => 'buildInCondition',
        'not in' => 'buildInCondition',
        'like' => 'buildLikeCondition',
        'not like' => 'buildLikeCondition',
        'or like' => 'buildLikeCondition',
        'or not like' => 'buildLikeCondition',
        'lt' => 'buildHalfBoundedRangeCondition',
        '<' => 'buildHalfBoundedRangeCondition',
        'lte' => 'buildHalfBoundedRangeCondition',
        '<=' => 'buildHalfBoundedRangeCondition',
        'gt' => 'buildHalfBoundedRangeCondition',
        '>' => 'buildHalfBoundedRangeCondition',
        'gte' => 'buildHalfBoundedRangeCondition',
        '>=' => 'buildHalfBoundedRangeCondition',
        'match' => 'buildMatchCondition',
        'match_phrase' => 'buildMatchCondition',
    ];
    if (empty($condition)) {
        return [];
    }
    if (!is_array($condition)) {
        throw new NotSupportedException('String conditions in where() are not supported by Elasticsearch.');
    }
    if (isset($condition[0])) { // operator format: operator, operand 1, operand 2, ...
        $operator = strtolower($condition[0]);
        if (isset($builders[$operator])) {
            $method = $builders[$operator];
            array_shift($condition);
            return $this->$method($operator, $condition);
        } else {
            throw new InvalidArgumentException('Found unknown operator in query: ' . $operator);
        }
    } else { // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
        return $this->buildHashCondition($condition);
    }
}

            

                public function buildOrderBy($columns)
{
    if (empty($columns)) {
        return [];
    }
    $orders = [];
    foreach ($columns as $name => $direction) {
        if (is_string($direction)) {
            $column = $direction;
            $direction = SORT_ASC;
        } else {
            $column = $name;
        }
        if ($this->db->dslVersion < 7) {
            if ($column == '_id') {
                $column = '_uid';
            }
        }
        // allow Elasticsearch extended syntax as described in https://www.elastic.co/guide/en/elasticsearch/guide/master/_sorting.html
        if (is_array($direction)) {
            $orders[] = [$column => $direction];
        } else {
            $orders[] = [$column => ($direction === SORT_DESC ? 'desc' : 'asc')];
        }
    }
    return $orders;
}

            

                public function buildQueryFromWhere($condition) {
    $where = $this->buildCondition($condition);
    if ($where) {
        $query = [
            'constant_score' => [
                'filter' => $where,
            ],
        ];
        return $query;
    } else {
        return null;
    }
}