nested类型是一种特殊的对象object数据类型，允许对象数组彼此独立的进行索引和查询
_

对象数组如何扁平化

内部对象object字段的数组不能像我们所期望的那样工作。Lucene内部没有对象的概念，所以ES将对象层次结构扁平化为一个字段名称和值的简单列表：

  1. PUT /my_index/_doc/1?pretty
  2. {
  3.         "group": "fans",
  4.         "user": [
  5.       {"first":"John", "last":"Smith"},
  6.       {"first":"Alice", "last":"White"}
  7.     ]
  8. }

user字段被动态的添加为object类型的字段，在其内部转化为一个看起来像下面这样的文档：

  1. {
  2.       "group":"fans",
  3.       "user.first":["John","Alice"],
  4.       "user.last":["Smith","White"]
  5. }

user.first和user.last字段被扁平化为多值字段，并且alice和white质检的关联已经丢失。

以下文本文档将错误的匹配user.first和user.last为smith查询：

  1. GET /my_indx/_doc
  2. {
  3.       "query":{
  4.             "bool":{
  5.                 "must":[
  6.                   {"match":{"user.first":"Alice"}},
  7.                   {"match":{"user.last":"Smith"}}
  8.             ]
  9.         }
  10.     }
  11. }
  13. //响应
  14. {
  15.     "took": 2,
  16.     "timed_out": false,
  17.     "_shards": {
  18.         "total": 1,
  19.         "successful": 1,
  20.         "skipped": 0,
  21.         "failed": 0
  22.     },
  23.     "hits": {
  24.         "total": {
  25.             "value": 1,
  26.             "relation": "eq"
  27.         },
  28.         "max_score": 0.5753642,
  29.         "hits": [
  30.             {
  31.                 "_index": "my_index",
  32.                 "_type": "_doc",
  33.                 "_id": "1",
  34.                 "_score": 0.5753642,
  35.                 "_source": {
  36.                     "group": "fans",
  37.                     "user": [
  38.                         {
  39.                             "first": "john",
  40.                             "last": "smith"
  41.                         },
  42.                         {
  43.                             "first": "alice",
  44.                             "last": "white"
  45.                         }
  46.                     ]
  47.                 }
  48.             }
  49.         ]
  50.     }
  51. }

解释：可以看到，我们原本是想要查询用户名为Alice Smith的用户，实际文档中并不存在此用户，但是搜索还是错误的命中了此文档。

对对象数组使用嵌套字段

上面的例子描述了我们日常搜索的一些错误场景，但是我们要如何解决上面例子描述的问题呢？
如果需要索引对象数组并维护每个对象的独立性，则应对字段使用nested类型而不是使用object类型。
在内部，嵌套对象将数组中的每个对象作为单独的隐藏文档进行索引，这意味着每个嵌套对象都可以使用嵌套查询nested query独立于其他对象进行查询。

要实现netsted查询，我们首先要为文档设置正确的映射（mapping）:

  1. DELETE /my_index
  3. PUT /my_index
  4. {
  5.         "mappings": {
  6.             "properties": {
  7.                 "user": {
  8.                     "type":"nested"
  9.             }
  10.         }
  11.     }
  12. }
  14. PUT /my_index/_doc/1?pretty
  15. {
  16.         "group": "fans",
  17.         "user": [
  18.       {"first":"John", "last":"Smith"},
  19.       {"first":"Alice", "last":"White"}
  20.     ]
  21. }

说明：此时user字段映射为nested类型，而不是默认的object类型

此时需要对bool查询进行一定的更改，再使用nested查询：

  1. GET /my_index/_serach?pretty
  2. {
  3.         "query": {
  4.             "nested": {
  5.                 "path":"user",
  6.               "query": {
  7.                   "bool": {
  8.                     "must": [
  9.                     {"match":{"user.first":"Alice"}},
  10.                     {"match":{"user.last":"White"}},
  11.                   ]
  12.                 }
  13.             }
  14.         }
  15.     }
  16. }
  18. //响应
  19. {
  20.     "took": 2,
  21.     "timed_out": false,
  22.     "_shards": {
  23.         "total": 1,
  24.         "successful": 1,
  25.         "skipped": 0,
  26.         "failed": 0
  27.     },
  28.     "hits": {
  29.         "total": {
  30.             "value": 1,
  31.             "relation": "eq"
  32.         },
  33.         "max_score": 1.3862942,
  34.         "hits": [
  35.             {
  36.                 "_index": "my_index",
  37.                 "_type": "_doc",
  38.                 "_id": "1",
  39.                 "_score": 1.3862942,
  40.                 "_source": {
  41.                     "group": "fans",
  42.                     "user": [
  43.                         {
  44.                             "first": "John",
  45.                             "last": "Smith"
  46.                         },
  47.                         {
  48.                             "first": "Alice",
  49.                             "last": "White"
  50.                         }
  51.                     ]
  52.                 }
  53.             }
  54.         ]
  55.     }
  56. }

可以发现。此时Alice White用户文档则被正确的命中。