Class yii\elasticsearch\Command

                public function addAlias($index, $alias, $aliasParameters = [])
{
    return (bool)$this->db->put([$index, '_alias', $alias], [], json_encode((object)$aliasParameters));
}

            

                public function aliasActions(array $actions)
{
    return (bool)$this->db->post(['_aliases'], [], json_encode(['actions' => $actions]));
}

            

                public function aliasExists($alias)
{
    $indexes = $this->getIndexesByAlias($alias);
    return !empty($indexes);
}

            

                public function clearIndexCache($index)
{
    return $this->db->post([$index, '_cache', 'clear']);
}

            

                public function clearScroll($options = [])
{
   return $this->db->delete(['_search', 'scroll'], $options);
}

            

                public function closeIndex($index)
{
    return $this->db->post([$index, '_close']);
}

            

                public function createIndex($index, $configuration = null)
{
    $body = $configuration !== null ? Json::encode($configuration) : null;
    return $this->db->put([$index], [], $body);
}

            

                public function createTemplate($name, $pattern, $settings, $mappings, $order = 0)
{
    $body = Json::encode([
        'template' => $pattern,
        'order' => $order,
        'settings' => (object) $settings,
        'mappings' => (object) $mappings,
    ]);
    return $this->db->put(['_template', $name], [], $body);
}

            

                public function delete($index, $type, $id, $options = [])
{
    return $this->db->delete([$index, $type, $id], $options);
}

            

                public function deleteAllIndexes()
{
    return $this->db->delete(['_all']);
}

            

                public function deleteByQuery($options = [])
{
    if (!isset($this->queryParts['query'])) {
        throw new InvalidCallException('Can not call deleteByQuery when no query is given.');
    }
    $query = [
        'query' => $this->queryParts['query'],
    ];
    if (isset($this->queryParts['filter'])) {
        $query['filter'] = $this->queryParts['filter'];
    }
    $query = Json::encode($query);
    $url = [$this->index !== null ? $this->index : '_all'];
    if ($this->type !== null) {
        $url[] = $this->type;
    }
    $url[] = '_query';
    return $this->db->delete($url, array_merge($this->options, $options), $query);
}

            

                public function deleteIndex($index)
{
    return $this->db->delete([$index]);
}

            

                public function deleteMapping($index, $type)
{
    return $this->db->delete([$index, '_mapping', $type]);
}

            

                public function deleteTemplate($name)
{
    return $this->db->delete(['_template', $name]);
}

            

                public function exists($index, $type, $id)
{
    return $this->db->head([$index, $type, $id]);
}

            

                public function flushIndex($index = '_all')
{
    return $this->db->post([$index, '_flush']);
}

            

                public function get($index, $type, $id, $options = [])
{
    return $this->db->get([$index, $type, $id], $options);
}

            

                public function getAliasInfo()
{
    $aliasInfo = $this->db->get(['_alias', '*']);
    return $aliasInfo ?: [];
}

            

                public function getIndexAliases($index)
{
    $responseData = $this->db->get([$index, '_alias', '*']);
    if (empty($responseData)) {
        return [];
    }
    return $responseData[$index]['aliases'];
}

            

                public function getIndexInfoByAlias($alias)
{
    $responseData = $this->db->get(['_alias', $alias]);
    if (empty($responseData)) {
        return [];
    }
    return $responseData;
}

            

                public function getIndexStatus($index = '_all')
{
    return $this->db->get([$index, '_status']);
}

            

                public function getIndexesByAlias($alias)
{
    return array_keys($this->getIndexInfoByAlias($alias));
}

            

                public function getMapping($index = '_all', $type = null)
{
    $url = [$index, '_mapping'];
    if ($type !== null) {
        $url[] = $type;
    }
    return $this->db->get($url);
}

            

                public function getSource($index, $type, $id)
{
    return $this->db->get([$index, $type, $id]);
}

            

                public function getTemplate($name)
{
    return $this->db->get(['_template', $name]);
}

            

                public function indexExists($index)
{
    return $this->db->head([$index]);
}

            

                public function insert($index, $type, $data, $id = null, $options = [])
{
    if (empty($data)) {
        $body = '{}';
    } else {
        $body = is_array($data) ? Json::encode($data) : $data;
    }
    if ($id !== null) {
        return $this->db->put([$index, $type, $id], $options, $body);
    } else {
        return $this->db->post([$index, $type], $options, $body);
    }
}

            

                public function mget($index, $type, $ids, $options = [])
{
    $body = Json::encode(['ids' => array_values($ids)]);
    return $this->db->get([$index, $type, '_mget'], $options, $body);
}

            

                public function openIndex($index)
{
    return $this->db->post([$index, '_open']);
}

            

                public function refreshIndex($index)
{
    return $this->db->post([$index, '_refresh']);
}

            

                public function removeAlias($index, $alias)
{
    return (bool)$this->db->delete([$index, '_alias', $alias]);
}

            

                public function scroll($options = [])
{
   return $this->db->get(['_search', 'scroll'], $options);
}

            

                public function search($options = [])
{
    $query = $this->queryParts;
    if (empty($query)) {
        $query = '{}';
    }
    if (is_array($query)) {
        $query = Json::encode($query);
    }
    $url = [$this->index !== null ? $this->index : '_all'];
    if ($this->type !== null) {
        $url[] = $this->type;
    }
    $url[] = '_search';
    return $this->db->get($url, array_merge($this->options, $options), $query);
}

            

                public function setMapping($index, $type, $mapping, $options = [])
{
    $body = $mapping !== null ? (is_string($mapping) ? $mapping : Json::encode($mapping)) : null;
    return $this->db->put([$index, '_mapping', $type], $options, $body);
}

            

                public function suggest($suggester, $options = [])
{
    if (empty($suggester)) {
        $suggester = '{}';
    }
    if (is_array($suggester)) {
        $suggester = Json::encode($suggester);
    }
    $url = [
        $this->index !== null ? $this->index : '_all',
        '_suggest'
    ];
    return $this->db->post($url, array_merge($this->options, $options), $suggester);
}

            

                public function typeExists($index, $type)
{
    return $this->db->head([$index, $type]);
}

            

                public function update($index, $type, $id, $data, $options = [])
{
    $body = [
        'doc' => empty($data) ? new \stdClass() : $data,
    ];
    if (isset($options["detect_noop"])) {
        $body["detect_noop"] = $options["detect_noop"];
        unset($options["detect_noop"]);
    }
    return $this->db->post([$index, $type, $id, '_update'], $options, Json::encode($body));
}

            

                public function updateAnalyzers($index, $setting, $options = [])
{
    $this->closeIndex($index);
    $result = $this->updateSettings($index, $setting, $options);
    $this->openIndex($index);
    return $result;
}

            

                public function updateSettings($index, $setting, $options = [])
{
    $body = $setting !== null ? (is_string($setting) ? $setting : Json::encode($setting)) : null;
    return $this->db->put([$index, '_settings'], $options, $body);
}