nested类型是一种特殊的对象object数据类型(specialised version of the object datatype )，允许对象数组彼此独立地进行索引和查询。

1. 对象数组如何扁平化

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

  1. curl -XPUT 'localhost:9200/my_index/my_type/1?pretty' -H 'Content-Type: application/json' -d'
  2. {
  3.   "group" : "fans",
  4.   "user" : [
  5.     {
  6.       "first" : "John",
  7.       "last" :  "Smith"
  8.     },
  9.     {
  10.       "first" : "Alice",
  11.       "last" :  "White"
  12.     }
  13.   ]
  14. }
  15. '

说明

user字段被动态的添加为object类型的字段。

在内部其转换成一个看起来像下面这样的文档：

  1. {
  2.   "group" :        "fans",
  3.   "user.first" : [ "alice", "john" ],
  4.   "user.last" :  [ "smith", "white" ]
  5. }

user.first和user.last字段被扁平化为多值字段，并且alice和white之间的关联已经丢失。 本文档将错误地匹配user.first为alice和user.last为smith的查询：

  1. curl -XGET 'localhost:9200/my_index/_search?pretty' -H 'Content-Type: application/json' -d'
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": [
  6.         { "match": { "user.first": "Alice" }},
  7.         { "match": { "user.last":  "Smith" }}
  8.       ]
  9.     }
  10.   }
  11. }
  12. '

2. 对对象数组使用嵌套字段

如果需要索引对象数组并维护数组中每个对象的独立性，则应使用nested数据类型而不是object数据类型。 在内部，嵌套对象将数组中的每个对象作为单独的隐藏文档进行索引，这意味着每个嵌套对象都可以使用嵌套查询nested query独立于其他对象进行查询：

  1. curl -XPUT 'localhost:9200/my_index?pretty' -H 'Content-Type: application/json' -d'
  2. {
  3.   "mappings": {
  4.     "my_type": {
  5.       "properties": {
  6.         "user": {
  7.           "type": "nested"
  8.         }
  9.       }
  10.     }
  11.   }
  12. }
  13. '
  15. curl -XPUT 'localhost:9200/my_index/my_type/1?pretty' -H 'Content-Type: application/json' -d'
  16. {
  17.   "group" : "fans",
  18.   "user" : [
  19.     {
  20.       "first" : "John",
  21.       "last" :  "Smith"
  22.     },
  23.     {
  24.       "first" : "Alice",
  25.       "last" :  "White"
  26.     }
  27.   ]
  28. }
  29. '

说明

user字段映射为nested类型，而不是默认的object类型

  1. curl -XGET 'localhost:9200/my_index/_search?pretty' -H 'Content-Type: application/json' -d'
  2. {
  3.   "query": {
  4.     "nested": {
  5.       "path": "user",
  6.       "query": {
  7.         "bool": {
  8.           "must": [
  9.             { "match": { "user.first": "Alice" }},
  10.             { "match": { "user.last":  "Smith" }}
  11.           ]
  12.         }
  13.       }
  14.     }
  15.   }
  16. }
  17. '

说明

此查询得不到匹配，是因为Alice和Smith不在同一个嵌套对象中。

  1. curl -XGET 'localhost:9200/my_index/_search?pretty' -H 'Content-Type: application/json' -d'
  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.       "inner_hits": {
  15.         "highlight": {
  16.           "fields": {
  17.             "user.first": {}
  18.           }
  19.         }
  20.       }
  21.     }
  22.   }
  23. }
  24. '

说明

此查询得到匹配，是因为Alice和White位于同一个嵌套对象中。

inner_hits允许我们突出显示匹配的嵌套文档。

输出

  1. {
  2.     "took": 151,
  3.     "timed_out": false,
  4.     "_shards": {
  5.         "total": 5,
  6.         "successful": 5,
  7.         "skipped": 0,
  8.         "failed": 0
  9.     },
  10.     "hits": {
  11.         "total": 1,
  12.         "max_score": 1.3862944,
  13.         "hits": [
  14.             {
  15.                 "_index": "indextest010",
  16.                 "_type": "my_type",
  17.                 "_id": "1",
  18.                 "_score": 1.3862944,
  19.                 "_source": {
  20.                     "group": "fans",
  21.                     "user": [
  22.                         {
  23.                             "first": "John",
  24.                             "last": "Smith"
  25.                         },
  26.                         {
  27.                             "first": "Alice",
  28.                             "last": "White"
  29.                         }
  30.                     ]
  31.                 },
  32.                 "inner_hits": {
  33.                     "user": {
  34.                         "hits": {
  35.                             "total": 1,
  36.                             "max_score": 1.3862944,
  37.                             "hits": [
  38.                                 {
  39.                                     "_index": "indextest010",
  40.                                     "_type": "my_type",
  41.                                     "_id": "1",
  42.                                     "_nested": {
  43.                                         "field": "user",
  44.                                         "offset": 1
  45.                                     },
  46.                                     "_score": 1.3862944,
  47.                                     "_source": {
  48.                                         "first": "Alice",
  49.                                         "last": "White"
  50.                                     },
  51.                                     "highlight": {
  52.                                         "user.first": [
  53.                                             "<em>Alice</em>"
  54.                                         ]
  55.                                     }
  56.                                 }
  57.                             ]
  58.                         }
  59.                     }
  60.                 }
  61.             }
  62.         ]
  63.     }
  64. }

嵌套文档可以：

3. 嵌套字段参数

嵌套字段接受以下参数：

参数 描述
dynamic 是否将新属性动态添加到现有的嵌套对象。共有true（默认），false和strict三种参数。
include_in_all Sets the default include_in_all value for all the properties within the nested object. Nested documents do not have their own _all field. Instead, values are added to the _all field of the main “root” document.
properties 嵌套对象中的字段，可以是任何数据类型，包括嵌套。新的属性可能会添加到现有的嵌套对象。

备注

类型映射(type mapping)、对象字段和嵌套字段包含的子字段，称之为属性properties。这些属性可以为任意数据类型，包括object和 nested。属性可以通过以下方式加入:

  • 当在创建索引时显式定义他们。
  • 当使用PUT mapping API添加或更新映射类型时显式地定义他们。
  • 当索引包含新字段的文档时动态的加入。

重要

由于嵌套文档作为单独的文档进行索引，因此只能在nested查询，nested/reverse_nested聚合或者 nested inner hits 的范围内进行访问。

For instance, if a string field within a nested document has index_options set to offsets to allow use of the postings highlighter, these offsets will not be available during the main highlighting phase. Instead, highlighting needs to be performed via nested inner hits.

4. 限制嵌套字段的个数

索引一个拥有100个嵌套字段的文档，相当于索引了101个文档，因为每一个嵌套文档都被索引为一个独立的文档．为了防止不明确的映射，每个索引可以定义的嵌套字段的数量已被限制为50个。 具体请参阅 Settings to prevent mappings explosion

原文：https://www.elastic.co/guide/en/elasticsearch/reference/current/nested.html#nested-params

补充更新2018年7月30日

多嵌套查询方式：

  1. {
  2.     "query": {
  3.         "bool": {
  4.             "must": [
  5.                 {
  6.                     "nested": {
  7.                         "path": [
  8.                             "ajxx"
  9.                         ],
  10.                         "query": {
  11.                             "bool": {
  12.                                 "must": [
  13.                                     {
  14.                                         "match": {
  15.                                             "ajxx.ajmc": "案件名称"
  16.                                         }
  17.                                     },
  18.                                     {
  19.                                         "range": {
  20.                                             "ajxx.sasj": {
  21.                                                 "gte": "2015-01-01 12:10:10",
  22.                                                 "lte": "2015-01-01 12:10:40"
  23.                                             }
  24.                                         }
  25.                                     }
  26.                                 ]
  27.                             }
  28.                         }
  29.                     }
  30.                 },
  31.                 {
  32.                     "nested": {
  33.                         "path": [
  34.                             "rqxx"
  35.                         ],
  36.                         "query": {
  37.                             "bool": {
  38.                                 "must": [
  39.                                     {
  40.                                         "range": {
  41.                                             "rqxx.rqsj": {
  42.                                                 "gte": "2015-01-01 12:10:10",
  43.                                                 "lte": "2015-01-01 12:10:40"
  44.                                             }
  45.                                         }
  46.                                     }
  47.                                 ]
  48.                             }
  49.                         }
  50.                     }
  51.                 }
  52.             ]
  53.         }
  54.     }
  55. }

2018年7月31日 16:59:14更新

全文及条件检索

  1. {
  2.     "query": {
  3.         "bool": {
  4.             "must": [
  5.                 {
  6.                     "nested": {
  7.                         "path": [
  8.                             "ajxx"
  9.                         ],
  10.                         "query": {
  11.                             "bool": {
  12.                                 "must": [
  13.                                     {
  14.                                         "match": {
  15.                                             "ajxx.ajzt": "破案"
  16.                                         }
  17.                                     },
  18.                                     {
  19.                                         "range": {
  20.                                             "ajxx.sasj": {
  21.                                                 "gte": "2017-01-01 12:10:10",
  22.                                                 "lte": "2017-01-02 12:10:40"
  23.                                             }
  24.                                         }
  25.                                     }
  26.                                 ],
  27.                                 "should": [
  28.                                     {
  29.                                         "bool": {
  30.                                             "must": [
  31.                                                 {
  32.                                                     "query_string": {
  33.                                                         "query": "20170316盗窃案"
  34.                                                     }
  35.                                                 }
  36.                                             ]
  37.                                         }
  38.                                     }
  39.                                 ]
  40.                             }
  41.                         }
  42.                     }
  43.                 }
  44.             ]
  45.         }
  46.     }
  47. }

多嵌套且全文检索

  1. {
  2.     "query": {
  3.         "bool": {
  4.             "must": [
  5.                 {
  6.                     "nested": {
  7.                         "path": [
  8.                             "ajxx"
  9.                         ],
  10.                         "query": {
  11.                             "bool": {
  12.                                 "must": [
  13.                                     {
  14.                                         "match": {
  15.                                             "ajxx.ajmc": "案件名称"
  16.                                         }
  17.                                     },
  18.                                     {
  19.                                         "range": {
  20.                                             "ajxx.sasj": {
  21.                                                 "gte": "2015-01-01 12:10:10",
  22.                                                 "lte": "2015-01-01 12:10:40"
  23.                                             }
  24.                                         }
  25.                                     },
  26.                                     {
  27.                                         "query_string": {
  28.                                             "query": "物品状态"
  29.                                         }
  30.                                     }
  31.                                 ]
  32.                             }
  33.                         }
  34.                     }
  35.                 },
  36.                 {
  37.                     "nested": {
  38.                         "path": [
  39.                             "rqxx"
  40.                         ],
  41.                         "query": {
  42.                             "bool": {
  43.                                 "must": [
  44.                                     {
  45.                                         "range": {
  46.                                             "rqxx.rqsj": {
  47.                                                 "gte": "2015-01-01 12:10:10",
  48.                                                 "lte": "2015-01-01 12:10:40"
  49.                                             }
  50.                                         }
  51.                                     }
  52.                                 ]
  53.                             }
  54.                         }
  55.                     }
  56.                 }
  57.             ]
  58.         }
  59.     }
  60. }

最后精简

  1. {
  2.     "query": {
  3.         "bool": {
  4.             "must": [
  5.                 {
  6.                     "nested": {
  7.                         "path": [
  8.                             "ajxx"
  9.                         ],
  10.                         "query": {
  11.                             "bool": {
  12.                                 "must": [
  13.                                     {
  14.                                         "match": {
  15.                                             "ajxx.ajzt": "破案"
  16.                                         }
  17.                                     },
  18.                                     {
  19.                                         "range": {
  20.                                             "ajxx.sasj": {
  21.                                                 "gte": "2017-01-01 12:10:10",
  22.                                                 "lte": "2017-01-02 12:10:40"
  23.                                             }
  24.                                         }
  25.                                     }
  26.                                 ],
  27.                                 "should": [
  28.                                     {
  29.                                         "query_string": {
  30.                                             "query": "20170316盗窃案"
  31.                                         }
  32.                                     }
  33.                                 ]
  34.                             }
  35.                         }
  36.                     }
  37.                 }
  38.             ]
  39.         }
  40.     }
  41. }

查询字段名称的模糊匹配编辑

字段名称可以用模糊匹配的方式给出：任何与模糊模式正则匹配的字段都会被包括在搜索条件中

  1. {
  2.     "multi_match": {
  3.         "query":  "结果",
  4.         "fields": ["*","*_title"]
  5.     }
  6. }

当这些子字段出现数值类型的时候，就会报异常了，解决方法是加入lenient字段

  1. {
  2.     "type": "parse_exception",
  3.     "reason": "failed to parse date field [XXX] with format [yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis]"
  4. }
  1. {
  2.     "multi_match": {
  3.         "query": "结果",
  4.         "lenient": "true",
  5.         "fields": ["*"]
  6.     }
  7. }

利用multi_match嵌套全文检索

  1. "include_in_parent":true,
  2. "include_in_root":true,
  1. {
  2.     "query": {
  3.         "bool": {
  4.             "must": [
  5.                 {
  6.                     "match": {
  7.                         "ajztmc": "立案"
  8.                     }
  9.                 },
  10.                 {
  11.                     "match": {
  12.                         "ajlxmc": "刑事"
  13.                     }
  14.                 },
  15.                 {
  16.                     "range": {
  17.                         "lasj": {
  18.                             "gte": "2015-01-01 12:10:10",
  19.                             "lte": "2016-01-01 12:10:40"
  20.                         }
  21.                     }
  22.                 },
  23.                 {
  24.                     "nested": {
  25.                         "path": [
  26.                             "rqxx"
  27.                         ],
  28.                         "query": {
  29.                             "bool": {
  30.                                 "must": [
  31.                                     {
  32.                                         "match": {
  33.                                             "rqxx.baqmc": "办案区名称"
  34.                                         }
  35.                                     }
  36.                                 ]
  37.                             }
  38.                         }
  39.                     }
  40.                 },
  41.                 {
  42.                     "nested": {
  43.                         "path": [
  44.                             "saryxx"
  45.                         ],
  46.                         "query": {
  47.                             "bool": {
  48.                                 "must": [
  49.                                     {
  50.                                         "match": {
  51.                                             "saryxx.rylxmc": "嫌疑人"
  52.                                         }
  53.                                     },
  54.                                     {
  55.                                         "match": {
  56.                                             "saryxx.ryxb": "女"
  57.                                         }
  58.                                     }
  59.                                 ]
  60.                             }
  61.                         }
  62.                     }
  63.                 },
  64.                 {
  65.                     "nested": {
  66.                         "path": [
  67.                             "wp"
  68.                         ],
  69.                         "query": {
  70.                             "bool": {
  71.                                 "must": [
  72.                                     {
  73.                                         "match": {
  74.                                             "wp.wpzlmc": "赃物"
  75.                                         }
  76.                                     },
  77.                                     {
  78.                                         "match": {
  79.                                             "wp.wpztmc": "物品入库"
  80.                                         }
  81.                                     }
  82.                                 ]
  83.                             }
  84.                         }
  85.                     }
  86.                 },
  87.                 {
  88.                     "multi_match": {
  89.                         "query": "男",
  90.                         "lenient": "true",
  91.                         "fields": [
  92.                             "*"
  93.                         ]
  94.                     }
  95.                 }
  96.             ]
  97.         }
  98.     },
  99.     "from": 0,
  100.     "size": 100,
  101.     "sort": {
  102.         "zxxgsj": {
  103.             "order": "desc"
  104.         }
  105.     }
  106. }

参考：

https://www.elastic.co/guide/cn/elasticsearch/guide/current/multi-match-query.html

http://www.bubuko.com/infodetail-2153060.html

https://www.cnblogs.com/huangfox/p/3544883.html

elasticsearch 嵌套对象之嵌套类型的更多相关文章

  1. elasticsearch嵌套对象的映射

    在es中,我们有时候可能需要映射,{ "field" : "xx" , "field01" : [] }这样格式的嵌套对象,默认情况下es会 ...

  2. elasticsearch 嵌套对象使用Multi Match Query、query_string全文检索设置

    参考: https://www.elastic.co/guide/en/elasticsearch/reference/1.7/mapping-nested-type.html https://sta ...

  3. Elasticsearch 7.x Nested 嵌套类型查询 | ES 干货

    一.什么是 ES Nested 嵌套 Elasticsearch 有很多数据类型,大致如下: 基本数据类型: string 类型.ES 7.x 中,string 类型会升级为:text 和 keywo ...

  4. AutoMapper 创建嵌套对象映射（原创）

    之前在做DTO转换时,用到AutoMapper.但DTO的层次太深了,无奈官方没针对嵌套类型提供好的解决方案,于是自己实现了一下: 思路:采用递归和反射很好的避免手工创建嵌套对象的映射. 第一个版本, ...

  5. js嵌套对象相等比较的一种方法 （原创）

    做前端开发经常会遇到比较js对象是否相等的情况, 或者说其它问题往往会归结到这个问题上来:比如对象数组的去重复. 网上看到过很多例子, 但是基本上都是那种比较简单的对象结构, 而复杂的对象结构,比如对 ...

  6. ElasticSearch 嵌套映射和过滤器及查询

    ElasticSearch - 嵌套映射和过滤器 Because nested objects are indexed as separate hidden documents, we can’t q ...

  7. 让jquery easyui datagrid列支持绑定嵌套对象

    嵌套对象是指返回的json数据,是对象的某个属性自带有属性.而我们恰恰又需要这个属性,默认情况下easyui的datagrid是不支持绑定嵌套对象的.比如:datagrid的field属性只能为fie ...

  8. WinForm 绑定到嵌套对象上的属性

    WinFrom 绑定到嵌套对象上的属性 关键字: Windows Forms, DataBindings, Nested Class, 嵌套类 在 WinForm 中很早就已经支持数据绑定, 使用数据 ...

  9. 转载 -- jquery easyui datagrid 动态表头 + 嵌套对象属性展示

    代码功能: 1.datagrid 的表头由后台生成,可以配置在数据库 2.datagrid 的列绑定数据 支撑嵌套对象 $(function() { var columns = new Array() ...

随机推荐

  1. Sass函数：unit()函数

    unit() 函数主要是用来获取一个值所使用的单位,碰到复杂的计算时,其能根据运算得到一个“多单位组合”的值,不过只充许乘.除运算: >> unit(100) "" & ...

  2. Center OS7网络设置

    虚拟机上设置网络连接为NAT方式(两层路由) 1:保证windows NAT 和dhcp服务启动 2:/etc/sysconfig/network-scripts/ifcfg-* TYPE=Ether ...

  3. ASP.NET Core中的依赖注入: 构造函数的选择与服务生命周期管理

    ServiceProvider最终提供的服务实例都是根据对应的ServiceDescriptor创建的,对于一个具体的ServiceDescriptor对象来说,如果它的ImplementationI ...

  4. python-字符串的处理

    s1 = '###12314##231###' print(s1.split('#')) #split,从左往右遇见# 就拆分一次['', '', '', '12314', '', '231', '' ...

  5. LOJ3119. 「CTS2019 | CTSC2019」随机立方体 二项式反演

    题目传送门 https://loj.ac/problem/3119 现在 BZOJ 的管理员已经不干活了吗,CTS(C)2019 和 NOI2019 的题目到现在还没与传上去. 果然还是 LOJ 好. ...

  6. IBM和DoE推出世界上最快的超级计算机

    IBM和美国能源部的橡树岭国家实验室今天发布了该部门最新的超级计算机Summit.IBM声称峰会目前是世界上“最强大,最聪明的科学超级计算机”,其峰值性能每秒高达20万亿次.当新的榜单在本月晚些时候发 ...

  7. 【leetcode】1020. Partition Array Into Three Parts With Equal Sum

    题目如下: Given an array A of integers, return true if and only if we can partition the array into three ...

  8. js-ifelse-奇技淫巧

    我们有A,B,C,D四个不同的类别,在最开始的时候只有三个类别,并且两个类别是做同样的事: function categoryHandle(category) { if(category !== 'A ...

  9. spring-boot整合mongodb的案例

    1.简介 MongoDB 是一个基于分布式文件存储的数据库.由 C++ 语言编写.旨在为 WEB 应用提供可扩展的高性能数据存储解决方案. MongoDB 是一个介于关系数据库和非关系数据库之间的产品 ...

  10. 【Java】字符串转json

    import org.json.JSONObject; JSONObject jo = new JSONObject(new String(需要转换的字符串));