ElasticSearch——nested（mapping,query,aggregation）

最新推荐文章于 2023-11-07 19:51:16 发布
最新推荐文章于 2023-11-07 19:51:16 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： Elasticsearch ElasticSearch从0到1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiyaru1314/article/details/71479807
版权

ElasticSearch 包含nested字段类型，该类型的出现主要是由于对象数组类型的操作往往不能如我们预期，这主要是因为在Lucene内部没有对象的概念，所以ES将层级的JSON数据转化成扁平的键值对列表形式。

例如文档：

PUT my_index/my_type/5
{
  "owner" : "小李",
  "family" : [
    {
      "call" : "dad",
      "name" :  "李俊杰"
    },
    {
      "call" : "mom",
      "name" :  "李翠莲"
    }
  ]
}

转化之后实际上为： 

PUT my_index/my_type/5
{
  "owner": "小李",
  "family.call": [
    "dad",
    "mom"
  ],
  "family.name": [
    "李俊杰",
    "李翠莲"
  ]
}

这样的话 我们想搜索爸爸的名称为李翠莲 也能够搜索到结果，这显然和我们的预期不符。

然而ES中nested类型字段，允许对象数组中的每一个对象被独立的索引和查询。

我们先做一个通常的处理方式，看看能够得到什么结果：

不使用nest的例子：

使用动态mapping，直接插入数据，对象数组mapping的数据类型是对象类型

第一步：添加数据：

PUT my_index/my_type/1
{
  "owner": "张三",
  "family": [
    {
      "call": "dad",
      "name": "张三爸"
    },
    {
      "call": "mom",
      "name": "张三妈"
    }
  ]
}
PUT my_index/my_type/2
{
  "owner" : "李四",
  "family" : [
    {
      "call" : "dad",
      "name" :  "李四爸"
    },
    {
      "call" : "mom",
      "name" :  "李四妈"
    }
  ]
}
PUT my_index/my_type/3
{
  "owner" : "王五",
  "family" : [
    {
      "call" : "dad",
      "name" :  "王五爸"
    },
    {
      "call" : "mom",
      "name" :  "王五妈"
    }
  ]
}

PUT my_index/my_type/4
{
  "owner" : "赵六",
  "family" : [
    {
      "call" : "dad",
      "name" :  "赵六爸"
    },
    {
      "call" : "mom",
      "name" :  "赵六妈"
    }
  ]
}

PUT my_index/my_type/5
{
  "owner" : "我",
  "family" : [
    {
      "call" : "dad",
      "name" :  "我老爸"
    },
    {
      "call" : "mom",
      "name" :  "我老妈"
    }
  ]
}
执行上面，对索引库my_index的表my_type添加五条数据

第二步：查看mapping结果

{
  "my_index": {
    "mappings": {
      "my_type": {
        "properties": {
          "family": {
            "properties": {
              "call": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "owner": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }
  }
}
可以看到family是个对象类型包含两个属性。

第三步查询：

must+term查询

GET my_index/my_type/_search
{
 "query": {
   "bool": {
     "must": [
       {
         "term": {
           "family.name.keyword": "王五妈"
         }
       }, {
         "term": {
           "family.call.keyword": "dad"
         }
       }
     ]
   }
 }
}
预期没有返回结果 因为没有一个爸爸的名字叫做“王五妈”

实际返回的结果如下：

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 0.5753642,
    "hits": [
      {
        "_index": "my_index",
        "_type": "my_type",
        "_id": "3",
        "_score": 0.5753642,
        "_source": {
          "owner": "王五",
          "family": [
            {
              "call": "dad",
              "name": "王五爸"
            },
            {
              "call": "mom",
              "name": "王五妈"
            }
          ]
        }
      }
    ]
  }

第四步：聚合，得到所有爸爸的统计

GET my_index/my_type/_search?size=0
{
  "aggs": {
    "call": {
      "filter": {
        "term": {
          "family.call.keyword": "dad"
        }
      },
      "aggs": {
        "name": {
          "terms": {
            "field": "family.name.keyword",
            "size": 10
          }
        }
      }
    }
  }
}
期望得到5个爸爸的统计结果，实际却把妈妈的名称也返回了 

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 5,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "call": {
      "doc_count": 5,
      "name": {
        "doc_count_error_upper_bound": 0,
        "sum_other_doc_count": 0,
        "buckets": [
          {
            "key": "张三妈",
            "doc_count": 1
          },
          {
            "key": "张三爸",
            "doc_count": 1
          },
          {
            "key": "我老妈",
            "doc_count": 1
          },
          {
            "key": "我老爸",
            "doc_count": 1
          },
          {
            "key": "李四妈",
            "doc_count": 1
          },
          {
            "key": "李四爸",
            "doc_count": 1
          },
          {
            "key": "王五妈",
            "doc_count": 1
          },
          {
            "key": "王五爸",
            "doc_count": 1
          },
          {
            "key": "赵六妈",
            "doc_count": 1
          },
          {
            "key": "赵六爸",
            "doc_count": 1
          }
        ]
      }
    }
  }
}
可见对于对象数组如果不做特殊处理的话，其结果是不符合预期的。


接下来进行nested相关的操作例子：

第一步：不能任由字段类型动态映射，需要改变对象数组类型映射成nested类型

可以建一个动态映射的模板：

在建模版之前，为了测试方便，把原来的上例子中的测试数据删除，重新开始：

删除执行操作：DELETE  my_index

PUT my_index
{
  "mappings": {
    "my_type": {
      "dynamic_templates": [
        {
          "object_as_nest": {
            "match_mapping_type": "object",
            "mapping": {
              "type": "nested"
            }
          }
        }
      ]
    }
  }
}
这样的话，对象类型就映射为nested类型，其他的字段依旧按照默认的动态映射。

第二步：添加数据（可批量也可以一条条插入）

这里就省略 

使用上面例子中的第一步的插入操作将数据添加进来

得到五条数据。

第三步：查看mapping结果：

{
  "my_index": {
    "mappings": {
      "my_type": {
        "dynamic_templates": [
          {
            "object_as_nest": {
              "match_mapping_type": "object",
              "mapping": {
                "type": "nested"
              }
            }
          }
        ],
        "properties": {
          "family": {
            "type": "nested",
            "properties": {
              "call": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "name": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "owner": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }
  }
}

可以看到family的类型变成nested

第四步：查询爸爸名称等于“王五妈”，预期没有返回结果

nested+must+term

GET my_index/my_type/_search
{
  "query": {
    "nested": {
      "path": "family",
      "score_mode": "sum",
      "query": {
        "bool": {
          "must": [
            {
              "term": {
                "family.call.keyword": "dad"
              }
            },
            {
              "term": {
                "family.name.keyword": "王五妈"
              }
            }
          ]
        }
      }
    }
  }
}
返回结果： 

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 0,
    "max_score": null,
    "hits": []
  }
}

查询爸爸名称等于“张三爸” 

GET my_index/my_type/_search
{
  "query": {
    "nested": {
      "path": "family",
      "score_mode": "sum",
      "query": {
        "bool": {
          "must": [
            {
              "term": {
                "family.call.keyword": "dad"
              }
            },
            {
              "term": {
                "family.name.keyword": "张三爸"
              }
            }
          ]
        }
      }
    }
  }
}
查询结果为：一条结果 和预期结果一致 

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 1,
    "max_score": 1.3862944,
    "hits": [
      {
        "_index": "my_index",
        "_type": "my_type",
        "_id": "1",
        "_score": 1.3862944,
        "_source": {
          "owner": "张三",
          "family": [
            {
              "call": "dad",
              "name": "张三爸"
            },
            {
              "call": "mom",
              "name": "张三妈"
            }
          ]
        }
      }
    ]
  }
}

第五步：聚合=》所有爸爸名称

nested+filter+term+terms 聚合方式

GET my_index/my_type/_search?size=0
{
  "aggs": {
    "家庭": {
      "nested": {
        "path": "family"
      },
      "aggs": {
        "爸爸": {
          "filter": {
            "term": {
              "family.call.keyword": "dad"
            }
          },
          "aggs": {
            "爸爸集合": {
              "terms": {
                "field": "family.name.keyword",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}
聚合结果如下： 

{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 5,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "家庭": {
      "doc_count": 10,
      "爸爸": {
        "doc_count": 5,
        "爸爸集合": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 0,
          "buckets": [
            {
              "key": "张三爸",
              "doc_count": 1
            },
            {
              "key": "我老爸",
              "doc_count": 1
            },
            {
              "key": "李四爸",
              "doc_count": 1
            },
            {
              "key": "王五爸",
              "doc_count": 1
            },
            {
              "key": "赵六爸",
              "doc_count": 1
            }
          ]
        }
      }
    }
  }
}

聚合所有妈妈的名称： 

GET my_index/my_type/_search?size=0
{
  "aggs": {
    "家庭": {
      "nested": {
        "path": "family"
      },
      "aggs": {
        "妈妈": {
          "filter": {
            "term": {
              "family.call.keyword": "mom"
            }
          },
          "aggs": {
            "妈妈集合": {
              "terms": {
                "field": "family.name.keyword",
                "size": 10
              }
            }
          }
        }
      }
    }
  }
}

聚合得到所有妈妈名称的结果是; 

{
  "took": 6,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "failed": 0
  },
  "hits": {
    "total": 5,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "家庭": {
      "doc_count": 10,
      "妈妈": {
        "doc_count": 5,
        "妈妈集合": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 0,
          "buckets": [
            {
              "key": "张三妈",
              "doc_count": 1
            },
            {
              "key": "我老妈",
              "doc_count": 1
            },
            {
              "key": "李四妈",
              "doc_count": 1
            },
            {
              "key": "王五妈",
              "doc_count": 1
            },
            {
              "key": "赵六妈",
              "doc_count": 1
            }
          ]
        }
      }
    }
  }
}

以上得到的结果完全符合预期。

而且也相对简单，尤其是动态mapping模板的建立。


















温水的小青蛙2023
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Elasticsearch 7.x Nested 嵌套类型查询 | ES 干货
weixin_30865427的博客
07-23 2353
一、什么是 ES Nested 嵌套 Elasticsearch 有很多数据类型，大致如下： 基本数据类型： string 类型。ES 7.x 中，string 类型会升级为：text 和 keyword。keyword 可以排序；text 默认分词，不可以排序。 数据类型：integer、long 等 时间类型、布尔类型、二进制类型、区间类型等 复杂数据类型： 数组类型：Arr...
elasticsearch数据类型--nested
w1346561235的博客
09-17 2057
前面写到了object数据类型，这里来说说nested。按照官方文档的说法，nested是特殊的object类型，弥补了object对象不能单独作为整体进行检索的缺陷。为了达到这个目的，nested在es内部是作为隐藏文档存储的。下面来详细说明。 先来看如何创建一个包含nested类型的index： PUT test_nested { "settings": { "mappi...
一起来学ES —— 浅谈Nested结构
PacosonSWJTU的博客
06-14 2641
Nested是什么? 直观的说，Nested实际上就是Object的数组。如下，这个user就是个nested结构 { "user" : [ { "first" : "John", "last" : "Smith" }, { "first" : "Alice", "last" : "White" } ] } Nested 和 Object 是什么关系？ ES原生支持Object类型，也就是任意字段都可以是个对象，而ES又是所有字段都是多值
ElasticSearch查询复杂结构，aggs进行复杂结构（nested）聚合
kolloge的博客
07-09 9077
ES拥有强大的聚合统计能力故而应用广泛，简单结构的聚合统计功能不多，如何针对复杂结构进行聚合统计实际上是很多生产上需要面对的问题，而ES相关文档毕竟很少，大多数人又不太愿意去读官方文档。这里写一下如何对复杂结构进行聚合，产生我们想要的统计数据。 本次用到工具Kibana，操作均在Kibana上进行。例我们现在有一个doc，里面有很多很多的字段，其中一个字段为wordFrequency，其样式大致...
6.ELK之Elasticsearch嵌套(Nested)类型
最新发布
mijichui2153的博客
11-07 2317
在Elasticsearch实际应用中经常会遇到嵌套文档的情况，而且会有“对象数组彼此独立地进行索引和查询的诉求”。在ES中这种嵌套文档称为父子文档，父子文档“彼此独立地进行查询”至少有以下两种方式：1）父子文档。在ES的5.x版本中通过parent-child父子type实现，即一个索引对应多个type；对于6.X+版本由于不再支持一个索引多个type，所以父子索引的实现改成了Join。2）Nested嵌套类型。
干货 | Elasticsearch Nested类型深入详解
热门推荐
铭毅天下Elasticsearch
10-06 9万+
0、概要 在Elasticsearch实战场景中，我们或多或少会遇到嵌套文档的组合形式，反映在ES中称为父子文档。 父子文档的实现，至少包含以下两种方式： 1）父子文档 父子文档在5.X版本中通过parent-child父子type实现，即：1个索引对应多个type； 6.X+版本已经不再支持一个索引多个type，6.X+的父子索引的实现改成Join。 2）Nested嵌套类型 本文通过一个例...
Elasticsearch教程(25) 详解mapping之nested
Java Spring Elasticsearch
09-10 3461
Elasticsearch详解mapping之nested1 前言2 创建nested字段的mapping3 插入测试数据4 nested查询5 nested聚合分析 1 前言 在工作开发中, 我们常遇到2张表示1对多的关系,这样的父子结构, 如果用MySQL存的话,子表设一个字段parentId存储父表的id,这样就可以用join关联查询. 那么ES作为NoSQL,它有更便捷的存储方式来保存父子结构: 第一种:join字段类型,子文档包含父文档ID,可用has_parent和has_child来查询 第
elasticsearch插件delete-by-query
12-04
ElasticSearch之插件Delete-by-Query，当es想批量删除数据时，安装该插件，可用将查询的结果数据进行批量删除。
arcgis-elasticSearch-es-矢量数据导入插件-数据建模-mapping-indexsetting-字段映射
06-29
arcgis elasticSearch es 矢量数据导入插件 数据建模 mapping indexsetting 字段映射 索引建模支持geoshape、shape，text索引支持keyword/ngram/edgeNgram/ikSmart，快速导入，兼容multipolygon，带洞，多面，使用时...
ElasticSearch Mapping
01-07
一、Mapping介绍 1）什么是Mapping ？ 备注：7.0版本后ES,是通过自动识别字段type 2）字段类型 备注：相比其它存储，多了IP、坐标等特殊的格式 3）什么是Dynamic Mapping ？ 备注：Dynamic Mapping ，设置不恰当...
elasticsearch——搜索引擎
02-25
这是一个搜索引擎的开发包固件，通过它你可以和qython对接
elasticsearch：使用SQL语句查询elasticsearch
01-28
Crcms Elasticsearch 版本矩阵 Elasticsearch版本 crcms / elasticsearch分支 > = 7.0 大师（贝塔不稳定） > = 6.0 1. * > = 5.0，<6 xss=removed xss=removed> [ CrCms\ElasticSearch\LaravelServiceProvider:...
Elasticsearch实战（二十四）---ES数据建模一对多模型Nested结构
流浪的喵的博客
07-03 1386
上一篇，我们介绍了 一对多模型，采用Object对象存储的巨大缺陷，本篇文章，我们给出解决办法 就是采用Nested结构来存储数据， 但是Nested查询和读写需要有特定的语法，也就是一定程度上增加了读写的复杂性，但是数据的查询结果是正确的，所以说Nested 才是我们一对多 推荐的一种设计模型。查询结果错误， 要查询 华为手机-发烧的数据，结果把 小米手机查询出来了，这是明显的错误。同样的结果，查询结果没有数据， 也是符合我们预期的，是正确的查询结果。查询结果 不是我们想要的， 是错误的。
【Elasticsearch教程13】Mapping字段类型之nested
Java Spring Elasticsearch
08-31 1211
在上一篇博客Mapping字段类型之object中，已经验证了用object类型存放对象数组是不可取的，因为object会把多个对象进行扁平化存储。nested类型能够存放对象数组，每一个对象会单独存储，所以可以在nested类型上进行查询、聚合和排序等操作。然而nested一个文档最多有50个nested类型的字段一个文档所有nested类型的字段存储文档最大数量是10000条。...
Elasticsearch: object 及 nested 数据类型
Elastic 中国社区官方博客
08-25 5689
在处理大量数据时，关系数据库存在很多问题。 无论是速度，高效处理，有效并行化，可扩展性还是成本，当数据量开始增长时，关系数据库都会失败。该关系数据库的另一个挑战是必须预先定义关系和模式。Elasticsearch也是一个NoSQL文档数据存储。 但是，尽管是一个NoSQL数据存储，Elasticsearch在一定程度上提供了很多帮助来管理关系数据。 它支持类似SQL的连接，并且在嵌套和相关的数据实......
Elasticsearch Nested类型
weixin_43939924的博客
03-26 2023
概要 在Elasticsearch实战场景中，我们或多或少会遇到嵌套文档的组合形式，反映在ES中称为父子文档。 父子文档的实现，至少包含以下两种方式： 1）父子文档 父子文档在5.X版本中通过parent-child父子type实现，即：1个索引对应多个type； 6.X+版本已经不再支持一个索引多个type，6.X+的父子索引的实现改成Join。 2）Nested嵌套类型 问题引出 示例: { "age": 10, "name": "libai", "objs": [ {
深入了解ElasticSearch的Nested数据类型
Java鱼仔的博客
12-14 1万+
深入了解ElasticSearch的Nested数据类型
ElasticSearch——自定义排序
世界中心的专栏
03-09 2万+
GET _search { "_source": { "include": ["title.Value","dataType","_score"] }, "query": { "bool": { "should": [ { "query_string": { "default_field": "t
Elasticsearch es Mapping
05-26
Elasticsearch Mapping 是指索引（index）中的字段映射（mapping），它定义了文档中每个字段的数据类型和如何存储数据。Mapping 是 Elasticsearch 中非常重要的概念，因为它定义了如何解析和索引文档。 在 Elastic...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值