Elasticsearch introduction

Index some documents

集群启动并运行后，您就可以为一些数据建立索引了。 Elasticsearch有多种摄取选项，但最终它们都做同样的事情：将JSON文档放入Elasticsearch索引中。

您可以使用简单的PUT请求直接执行此操作，该请求指定要添加文档的索引，唯一的文档ID，以及请求正文中的一个或多个"field": "value"对：

PUT /customer/_doc/1
{
  "name": "John Doe"
}

该请求（如果尚不存在）将自动创建customer索引，添加ID为1的新文档，并存储name字段并为其建立索引。

由于这是一个新document，因此响应显示该操作的结果是创建了该document的版本1：

{
  "_index" : "customer",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}

可以从群集中的任何节点立即获得新文档。您可以使用指定其文档ID的GET请求检索它：

GET /customer/_doc/1

该响应表明找到了具有指定ID的document，并显示了已建立索引的原始源字段。

{
  "_index" : "customer",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 0,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "name" : "John Doe"
  }
}

如果要索引的文档很多，则可以使用bulk API批量提交它们。 使用批量处理批处理文档操作比单独提交请求要快得多，因为它可以最大程度地减少网络往返次数。

最佳批处理大小取决于许多因素：文档大小和复杂性，索引编制和搜索负载以及群集可用的资源。 一个好的起点是批处理1,000至5,000个文档，总有效负载在5MB至15MB之间。 从那里，您可以尝试找到最佳位置。

要将一些数据导入Elasticsearch，您可以开始搜索和分析：

1. 下载accounts.json示例数据集。 此随机生成的数据集中的文档代表具有以下信息的用户帐户：

   {
       "account_number": 0,
       "balance": 16623,
       "firstname": "Bradshaw",
       "lastname": "Mckenzie",
       "age": 29,
       "gender": "F",
       "address": "244 Columbus Place",
       "employer": "Euron",
       "email": "bradshawmckenzie@euron.com",
       "city": "Hobucken",
       "state": "CO"
   }

2. 使用以下_bulk请求将帐户数据索引到银行索引中：

   curl -H "Content-Type: application/json" -XPOST "localhost:9200/bank/_bulk?pretty&refresh" --data-binary "@accounts.json"
   curl "localhost:9200/_cat/indices?v"

3. 响应表明成功索引了1,000个文档。

   health status index uuid                   pri rep docs.count docs.deleted store.size pri.store.size
   yellow open   bank  l7sSYV2cQXmu6_4rJWVIww   5   1       1000            0    128.6kb        128.6kb

Start searching

将一些数据摄取到Elasticsearch索引后，您可以通过将请求发送到_search端点来进行搜索。要访问全套搜索功能，请使用Elasticsearch Query DSL在请求正文中指定搜索条件。您可以在请求URI中指定要搜索的索引的名称。

例如，以下请求将检索bank索引中按帐号排序的所有文档：

GET /bank/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "account_number": "asc" }
  ]
}

默认情况下，响应的hit部分包括符合搜索条件的前10个文档：

{
  "took" : 63,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
        "value": 1000,
        "relation": "eq"
    },
    "max_score" : null,
    "hits" : [ {
      "_index" : "bank",
      "_type" : "_doc",
      "_id" : "0",
      "sort": [0],
      "_score" : null,
      "_source" : {"account_number":0,"balance":16623,"firstname":"Bradshaw","lastname":"Mckenzie","age":29,"gender":"F","address":"244 Columbus Place","employer":"Euron","email":"bradshawmckenzie@euron.com","city":"Hobucken","state":"CO"}
    }, {
      "_index" : "bank",
      "_type" : "_doc",
      "_id" : "1",
      "sort": [1],
      "_score" : null,
      "_source" : {"account_number":1,"balance":39225,"firstname":"Amber","lastname":"Duke","age":32,"gender":"M","address":"880 Holmes Lane","employer":"Pyrami","email":"amberduke@pyrami.com","city":"Brogan","state":"IL"}
    }, ...
    ]
  }
}

该响应还提供有关搜索请求的以下信息：

• took – Elasticsearch运行查询所需的时间（以毫秒为单位）
• timed_out – 搜索请求是否超时
• _shards – 搜索了多少个分片以及成功，失败或跳过了多少个分片。or were skipped.
• max_score – 找到最相关文件的分数
• hits.total.value - 找到多少个匹配的文档
• hits.sort - 文档的排序位置（不按相关性得分排序时）
• hits._score - 文档的相关性得分（使用match_all时不适用）

每个搜索请求都是独立的：Elasticsearch在请求中不维护任何状态信息。要翻阅搜索结果，请在请求中指定from和size参数。

例如，以下请求的匹配数为10到19：

GET /bank/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "account_number": "asc" }
  ],
  "from": 10,
  "size": 10
}

既然您已经了解了如何提交基本的搜索请求，则可以开始构建比match_all有趣的查询。

要在字段中搜索特定字词，可以使用match查询。例如，以下请求搜索address字段以查找其地址包含mill或land：

GET /bank/_search
{
  "query": { "match": { "address": "mill lane" } }
}

要构造更复杂的查询，可以使用bool查询来组合多个查询条件。您可以根据需要（must match），期望（shhould match）或不期望（must not match）指定条件。

例如，以下请求在bank索引中搜索属于40岁客户的帐户，但不包括居住在Idaho（ID）的任何人：

GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "age": "40" } }
      ],
      "must_not": [
        { "match": { "state": "ID" } }
      ]
    }
  }
}

布尔查询中的每个must，should和must_not元素都称为查询子句。文档满足每个必须或应条款中的标准的程度会提高文档的相关性得分。分数越高，文档就越符合您的搜索条件。默认情况下，Elasticsearch返回按这些相关性分数排名的文档。

must_not子句中的条件被视为过滤器。它影响文件是否包含在结果中，但不会影响文件的评分方式。您还可以根据结构化数据显式指定任意过滤器以包括或排除文档。

例如，以下请求使用范围过滤器将结果限制为余额在20,000美元到30,000美元（含）之间的帐户。

GET /bank/_search
{
  "query": {
    "bool": {
      "must": { "match_all": {} },
      "filter": {
        "range": {
          "balance": {
            "gte": 20000,
            "lte": 30000
          }
        }
      }
    }
  }
}

Analyze results with aggregations

Elasticsearch聚合使您能够获取有关搜索结果的元信息，并回答诸如“德克萨斯州有多少个帐户持有人？”或“田纳西州的平均帐户余额是多少？”之类的问题。您可以在一个请求中搜索文档，过滤命中并使用汇总分析结果。

例如，以下请求使用terms汇总将bank索引中的所有帐户按状态分组，并按降序返回帐户数量最多的十个州：

GET /bank/_search
{
  "size": 0,
  "aggs": {
    "group_by_state": {
      "terms": {
        "field": "state.keyword"
      }
    }
  }
}

响应中的buckets是state字段的值。doc_count显示每个状态下的帐户数。例如，您可以看到ID（爱达荷州）中有27个帐户。因为请求集size=0，所以响应仅包含聚合结果。

{
  "took": 29,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped" : 0,
    "failed": 0
  },
  "hits" : {
     "total" : {
        "value": 1000,
        "relation": "eq"
     },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "group_by_state" : {
      "doc_count_error_upper_bound": 20,
      "sum_other_doc_count": 770,
      "buckets" : [ {
        "key" : "ID",
        "doc_count" : 27
      }, {
        "key" : "TX",
        "doc_count" : 27
      }, {
        "key" : "AL",
        "doc_count" : 25
      }, {
        "key" : "MD",
        "doc_count" : 25
      }, {
        "key" : "TN",
        "doc_count" : 23
      }, {
        "key" : "MA",
        "doc_count" : 21
      }, {
        "key" : "NC",
        "doc_count" : 21
      }, {
        "key" : "ND",
        "doc_count" : 21
      }, {
        "key" : "ME",
        "doc_count" : 20
      }, {
        "key" : "MO",
        "doc_count" : 20
      } ]
    }
  }
}

您可以组合聚合以构建更复杂的数据汇总。例如，以下请求在前一个group_by_state聚合内嵌套avg聚合，以计算每个状态的平均帐户余额。

GET /bank/_search
{
  "size": 0,
  "aggs": {
    "group_by_state": {
      "terms": {
        "field": "state.keyword"
      },
      "aggs": {
        "average_balance": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}

除了这些基本的存储桶和指标聚合外，Elasticsearch还提供了专门的聚合，用于在多个字段上操作并分析特定类型的数据，例如日期，IP地址和地理数据。您还可以将单个聚合的结果馈送到管道聚合中，以进行进一步分析。

聚合提供的核心分析功能可启用高级功能，例如使用机器学习来检测异常。

Mapping

映射是定义文档及其包含的字段的存储和索引方式的过程。例如，使用映射定义：

• 哪些字符串字段应视为全文字段。
• 哪些字段包含数字，日期或地理位置。
• format 日期值的格式。
• 自定义规则来控制动态添加字段的映射。 dynamically added fields.

Field datatypes

每个字段的数据类型可以是：

• a simple type like text, keyword, date, long, double, boolean or ip.
• 支持JSON的层次结构性质的类型 object or nested.
• 专业型 geo_point, geo_shape, or completion.

为不同的目的以不同的方式对同一字段建立索引通常很有用。例如，可以将string字段索引为全文搜索的text字段，以及作为排序或聚合的keyword字段。另外，您可以使用标准分析器，英语分析器和法语分析器为字符串字段建立索引。

这是多字段的目的。大多数数据类型通过fields参数支持多字段。

Dynamic mapping（动态映射）

字段和映射类型在使用之前不需要定义。通过动态映射，仅通过索引文档即可自动添加新的字段名称。新字段既可以添加到*映射类型，也可以添加到内部对象和嵌套字段。object and nested

可以将动态映射规则配置为自定义用于新字段的映射。 dynamic mapping

使用显式映射创建索引

您可以使用create index API创建带有显式映射的新索引。

PUT /my-index
{
  "mappings": {
    "properties": {
      "age":    { "type": "integer" },  
      "email":  { "type": "keyword"  }, 
      "name":   { "type": "text"  }     
    }
  }
}

Add a field to an existing mapping

将字段添加到现有映射 您可以使用放置映射API将一个或多个新字段添加到现有索引。

下面的示例添加employee-id，这是一个关键字字段，其索引映射参数值为false。这意味着已存储employee-id字段的值，但未编制索引或可用于搜索。

PUT /my-index/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false
    }
  }
}

更新字段的映射

您不能更改现有字段的映射，但以下情况除外：

• You can add new properties to an object field.
• 您可以使用字段映射参数来启用多字段。 field
• 您可以更改ignore_above映射参数的值。 ignore_above

更改现有字段的映射可能会使已经建立索引的数据无效。如果需要更改字段的映射，请使用正确的映射创建一个新索引，然后将数据重新索引 reindex 到该索引中。如果只想重命名字段，请考虑添加别名 alias 字段。

查看索引的映射

您可以使用get mapping API查看现有索引的映射。

GET /my-index/_mapping

Query DSL

Elasticsearch提供了基于JSON的完整查询DSL（特定于域的语言）来定义查询。将查询DSL视为查询的AST（抽象语法树），它由两种子句组成：

• Leaf query clauses

叶子查询子句在特定字段中查找特定值，例如match，term或range查询。这些查询可以自己使用。

• Compound query clauses

复合查询子句包装其他叶查询或复合查询，并用于以逻辑方式组合多个查询（例如bool或dis_max查询），或更改其行为（例如constant_score查询）。

查询子句的行为会有所不同，具体取决于它们是在查询上下文中还是在过滤器上下文中使用。 query context or filter context.

查询和过滤上下文

Relevance scores

默认情况下，Elasticsearch按相关性得分对匹配的搜索结果进行排序，该得分衡量每个文档与查询的匹配程度。

相关性分数是一个正浮点数，在searchAPI的_score元字段中返回。 _score越高，文档越相关。虽然每种查询类型可以不同地计算相关性分数，但是分数计算还取决于查询子句是在查询上下文中还是在过滤器上下文中运行。

Query context 查询上下文

在查询上下文中，查询子句回答“此文档与该查询子句的匹配程度如何”的问题。除了确定文档是否匹配外，查询子句还计算_score元字段中的相关性得分。

每当将查询子句传递到查询参数（例如搜索API中的查询参数）时，查询上下文即生效。

Filter context 过滤上下文

在过滤器上下文中，查询子句回答问题“此文档是否与此查询子句匹配？”答案是简单的“是”或“否”，即不计算分数。过滤器上下文主要用于过滤结构化数据，例如

• Does this timestamp fall into the range 2015 to 2016?
• Is the status field set to "published"?

常用过滤器将由Elasticsearch自动缓存，以提高性能。

每当将查询子句传递到过滤器参数（例如bool查询中的filter或must_not参数，constant_score查询中的filter参数或过滤器聚合）时，过滤器上下文即生效。

Example of query and filter contexts

以下是在searchAPI的查询和过滤器上下文中使用的查询子句的示例。此查询将匹配满足以下所有条件的文档：

• The title field contains the word search.
• The content field contains the word elasticsearch.
• The status field contains the exact word published.
• The publish_date field contains a date from 1 Jan 2015 onwards.

GET /_search
{
  "query": { 
    "bool": { 
      "must": [
        { "match": { "title":   "Search"        }},
        { "match": { "content": "Elasticsearch" }}
      ],
      "filter": [ 
        { "term":  { "status": "published" }},
        { "range": { "publish_date": { "gte": "2015-01-01" }}}
      ]
    }
  }
}

• The query parameter indicates query context.
• bool和两个match子句用于查询上下文，这意味着它们用于对每个文档的匹配程度进行评分。
• filter参数指示过滤器上下文。其term和range子句用于过滤器上下文。它们将过滤出不匹配的文档，但不会影响匹配文档的分数。

在查询上下文中为查询计算的分数表示为单精度浮点数；它们只有24位才能表示有效的精度。超过有效位数的分数计算将被转换为浮点数而失去精度。

在查询上下文中使用查询子句来确定会影响匹配文档得分的条件（即文档匹配程度），并在过滤器上下文中使用所有其他查询子句。

Compound queries 复合查询

复合查询包装其他复合查询或叶查询，以组合其结果和分数，更改其行为或从查询切换到过滤器上下文。

该组中的查询是：

• bool query

默认查询，用于组合多个叶子或复合查询子句（must，should，must_not或filter子句）。must和should子句的分数组合在一起-匹配的子句越多越好-而must_not和filter子句在过滤器上下文中执行。

• boosting query

返回与肯定查询匹配的文档，但减少与否定查询匹配的文档的分数。

• constant_score query

一个查询，它包装另一个查询，但是在过滤器上下文中执行它。所有匹配的文档都使用相同的“常量” _score。

• dis_max query

一个查询，它接受多个查询，并返回与任何查询子句匹配的任何文档。当布尔查询合并所有匹配查询的分数时，dis_max查询使用单个最佳匹配查询子句的分数。

• function_score query

使用functions修改主查询返回的分数，以考虑诸如受欢迎程度，新近度，距离或使用脚本实现的自定义算法等因素。

Boolean query

与文档匹配的查询，这些文档与其他查询的布尔组合匹配。布尔查询映射到Lucene BooleanQuery。它是使用一个或多个布尔子句构建的，每个子句都具有类型的出现。发生类型为：

Occur	Description
must	子句（查询）必须出现在匹配的文档中，并将有助于得分。
filter	子句（查询）必须出现在匹配的文档中。但是与查询分数不同的是，忽略该分数。 Filter子句在过滤器上下文中执行，这意味着计分被忽略，并且子句被视为用于缓存。
should	子句（查询）应出现在匹配的文档中。
must_not	子句（查询）不得出现在匹配的文档中。子句在过滤器上下文中执行，这意味着计分被忽略，并且子句被视为用于缓存。由于计分被忽略，因此所有文档的分数均返回0。

The bool query takes a more-matches-is-better approach, so the score from each matching must or should clause will be added together to provide the final _score for each document.

POST _search
{
  "query": {
    "bool" : {
      "must" : {
        "term" : { "user" : "kimchy" }
      },
      "filter": {
        "term" : { "tag" : "tech" }
      },
      "must_not" : {
        "range" : {
          "age" : { "gte" : 10, "lte" : 20 }
        }
      },
      "should" : [
        { "term" : { "tag" : "wow" } },
        { "term" : { "tag" : "elasticsearch" } }
      ],
      "minimum_should_match" : 1,
      "boost" : 1.0
    }
  }
}

在filter元素下指定的查询对得分没有影响-得分将返回0。得分仅受指定查询的影响。

Boosting query

返回匹配肯定查询的文档，同时降低也匹配否定查询的文档的相关性得分。

您可以使用boosting查询来降级某些文档，而不必将它们从搜索结果中排除。

positive

（必需的查询对象）要运行的查询。返回的所有文档都必须与此查询匹配。

negative

（必需的查询对象）查询用于降低匹配文档的相关性得分。

如果返回的文档与肯定查询和该查询匹配，则增强查询将计算该文档的最终相关性得分，如下所示：

1. 从肯定查询中获取原始的相关性分数。
2. 将分数乘以negative_boost值。

negative_boost

（必需，浮点数）0到1.0之间的浮点数，用于降低与否定查询匹配的文档的相关性得分。

Example request

GET /bank/_search
{
  "query": {
    "boosting": {
      "positive": {
        "match": {
          "state": "ID"
        }
      },
      "negative": {
        "range": {
          "balance": {
            "gte": 20000,
            "lte": 30000
          }
        }
      },
      "negative_boost": 0.5
    }
  }
}

Constant score query

包装过滤查询，并返回每个相关文档的相关性得分等于boost 参数值。

filter

（必需的查询对象）过滤要运行的查询。返回的所有文档都必须与此查询匹配。

过滤查询不计算相关性分数。为了提高性能，Elasticsearch自动缓存经常使用的过滤器查询。

boost

（可选，float）浮点数用作与查询匹配的每个文档 的恒定 相关性得分filter。默认为1.0。

GET /bank/_search
{
  "query": {
    "constant_score": {
      "filter": {"range": {
        "balance": {
          "gte": 20000,
          "lte": 30000
        }
      }},
      "boost": 0.1
    }
  }
}

Full text queries 全文检索

全文查询使您可以搜索已分析的文本字段，例如电子邮件的正文。使用在索引期间应用于字段的同一分析器来处理查询字符串。

该组中的查询是：

• intervals query

全文查询，可以对匹配项的顺序和接近度进行细粒度控制。

• match query

用于执行全文查询的标准查询，包括模糊匹配和短语或接近查询。

• match_bool_prefix query

创建一个bool与每个词条匹配的term查询作为查询，但最后一个词条作为prefix查询匹配

• match_phrasequery

与match查询类似，但用于匹配确切的短语或单词接近匹配。

• match_phrase_prefix query

与match_phrase查询类似，但是对最后一个单词进行通配符搜索。

• multi_match query

match查询的多字段版本。

• common terms query

一个更专业的查询，它对不常见的单词给予更多的偏爱。

• query_stringquery

支持紧凑的Lucene 查询字符串语法，允许您在单个查询字符串中指定AND | OR | NOT条件和多字段搜索。仅限于专业用户。

• simple_query_stringquery

query_string适用于直接向用户公开的语法的更简单，更可靠的版本。

Intervals query

根据匹配项的顺序和接近程度返回文档。

间隔查询使用匹配规则，该规则由一小组定义构成。然后将这些规则应用于来自指定字段的术语。

这些定义产生的最小间隔序列跨越了文本主体中的各个术语。这些间隔可以由父源进一步组合和过滤。

Match query

返回与提供的文本，数字，日期或布尔值匹配的文档。匹配之前分析提供的文本。

匹配查询是用于执行全文搜索的标准查询，其中包括模糊匹配的选项。

GET /_search
{
    "query": {
        "match" : {
            "message" : {
                "query" : "this is a test"
            }
        }
    }
}

REST APIs

Index APIs

Create Index

创建一个新索引。

PUT /twitter

Request

PUT /<index>

Description

您可以使用create index API将新索引添加到Elasticsearch集群。创建索引时，可以指定以下内容：

• Settings 索引设置
• Mappings 索引中字段的映射
• Index aliases 索引别名

Path parameters

<index>（可选，字符串）您要创建的索引的名称。

索引名称必须满足以下条件：

• Lowercase only
• Cannot include \, /, *, ?, ", <, >, |, (space character), ,, #
• Indices prior to 7.0 could contain a colon (:), but that’s been deprecated and won’t be supported in 7.0+
• Cannot start with -, _, +
• Cannot be . or ..
• Cannot be longer than 255 bytes (note it is bytes, so multi-byte characters will count towards the 255 limit faster)

Query parameters

• include_type_name

[7.0.0] Deprecated in 7.0.0. Mapping types have been deprecated. See Removal of mapping types.(Optional, boolean) If true, a mapping type is expected in the body of mappings. Defaults to false.

• wait_for_active_shards

（可选，字符串）在继续操作之前必须处于活动状态的分片副本数。设置为全部或任何正整数，直到索引中的分片总数（number_of_replicas + 1）。默认值：1，主分片。

• timeout

（可选，时间单位）指定等待响应的时间。如果在超时到期之前未收到任何响应，则请求将失败并返回错误。默认为30秒。

• master_timeout

（可选，时间单位）指定等待连接到主节点的时间段。如果在超时到期之前未收到任何响应，则请求将失败并返回错误。默认为30秒。

Request body

• aliases

(Optional, alias object) Index aliases which include the index. See Update index alias.

• mappings

(Optional, mapping object) Mapping for fields in the index. If specified, this mapping can include:

• Field names
• Field datatypes
• Mapping parameters

See Mapping.

• settings

(Optional, index setting object) Configuration options for the index. See Index Settings.

Examples例子

Index settings索引设置

创建的每个索引都可以具有与之关联的特定设置，这些设置在主体中定义：

PUT /twitter
{
    "settings" : {
        "index" : {
            "number_of_shards" : 3,  默认1
            "number_of_replicas" : 2  默认1
        }
    }
}

PUT /twitter
{
    "settings" : {
        "number_of_shards" : 3,
        "number_of_replicas" : 2
    }
}

Mapping

创建索引API允许提供映射定义：

PUT /test
{
    "settings" : {
        "number_of_shards" : 1
    },
    "mappings" : {
        "properties" : {
            "field1" : { "type" : "text" }
        }
    }
}

Aliases

PUT /test
{
    "aliases" : {
        "alias_1" : {},
        "alias_2" : {
            "filter" : {
                "term" : {"user" : "kimchy" }
            },
            "routing" : "kimchy"
        }
    }
}

默认情况下，索引创建仅在每个分片的主副本已启动或请求超时时才向客户端返回响应。索引创建响应将指示发生了什么：

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "test"
}

acknowledged 指示索引是否在集群中成功创建, 而shards_acknowledged 指示在超时之前是否为索引中的每个分片启动了必要数量的分片副本。请注意，acknowledged 或shards_acknowledged仍然可能为假，但索引创建成功。 这些值仅表示操作是否在超时之前完成。如果accepted为false，那么在使用新创建的索引更新集群状态之前，我们会超时，但是可能很快就会创建它。 If shards_acknowledged is false, then we timed out before the requisite number of shards were started (by default just the primaries), even if the cluster state was successfully updated to reflect the newly created index (i.e. acknowledged=true).

我们可以通过索引设置index.write.wait_for_active_shards更改仅等待主分片启动的默认设置

Search APIs

Most search APIs are multi-index, with the exception of the Explain API endpoints.

Search

返回与请求中定义的查询匹配的搜索命中。

GET /twitter/_search?q=tag:wow

Request

GET /<index>/_search

POST /<index>/_search

GET /_search

POST /_search

Description

允许您执行搜索查询并获取与查询匹配的搜索命中。可以使用简单查询字符串作为参数来提供查询，也可以使用请求正文来提供查询。 query string as a parameter, or using a request body.

为确保快速响应，如果一个或多个分片失败，搜索API将以部分结果响应。有关更多信息，请参见分片故障。

Path parameters

<index>（可选，字符串）索引名称的逗号分隔列表或通配符表达式，用于限制请求。

Query parameters

allow_no_indices

（可选，布尔值）如果为true，则如果通配符表达式或_all值仅检索丢失或闭合的索引，则请求不会返回错误。

此参数还适用于指向别名缺失或封闭索引的索引别名。

allow_partial_search_results

（可选，布尔值）指示如果部分搜索失败或超时，是否应返回错误。默认为true。

Request body

query

(Optional, query object) Defines the search definition using the Query DSL.