实战Elasticsearch6的join类型

最新推荐文章于 2024-06-20 14:36:07 发布
最新推荐文章于 2024-06-20 14:36:07 发布
阅读量3.1k 收藏 7
点赞数 1
分类专栏： elasticsearch 文章标签： elasticsearch es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boling_cavalry/article/details/89067738
版权

《Elasticsearch实战》(英文名Elasticsearch IN ACTION)是经典es教程，对应demo源码地址为：https://github.com/dakrone/elasticsearch-in-action ，最新分支6.x，在使用源码时，发现索引_doc的静态映射脚本增加了一个类型为join的字段，如下所示，：

"mappings" : {
    "_doc" : {
      "_source" : {
        "enabled" : true
      },
      "properties" : {
        "relationship_type": {
          "type": "join",
          "relations" : {
            "group": "event"
          }
        },
        ...

这是es6新增的类型，一起来通过实战学习这个join；

环境信息

  1. 操作系统：Ubuntu 18.04.2 LTS
  2. elasticsearch：6.7.1
  3. kibana：6.7.1

《Elasticsearch实战》demo源码下载地址

本文用到的源码一共两个文件，一个是创建静态映射的mapping.json，另一个是创建文档的populate.sh，地址分别如下：

  1. https://github.com/dakrone/elasticsearch-in-action/blob/6.x/mapping.json
  2. https://github.com/dakrone/elasticsearch-in-action/blob/6.x/populate.sh

上述文件的用法：下载到同一个目录，执行命令./populate.sh 192.168.1.101:9200，"192.168.1.101:9200"是es6的http地址和端口；

官方说法

官方对join类型的说明如下：
在这里插入图片描述
我的理解：

  1. join类型用于建立索引内文档的父子关系；
  2. 用父子文档的名字来表示关系；

接下来看看《Elasticsearch实战》的demo中是怎么使用这个字段的；

《Elasticsearch实战》的demo

  1. demo中部分文档的创建脚本如下所示：
curl -s -XPOST "$ADDRESS/get-together/_doc/1" -H'Content-Type: application/json' -d'{
  "relationship_type": "group",
  "name": "Denver Clojure",
  "organizer": ["Daniel", "Lee"],
  "description": "Group of Clojure enthusiasts from Denver who want to hack on code together and learn more about Clojure",
  "created_on": "2012-06-15",
  "tags": ["clojure", "denver", "functional programming", "jvm", "java"],
  "members": ["Lee", "Daniel", "Mike"],
  "location_group": "Denver, Colorado, USA"
}'

curl -s -XPOST "$ADDRESS/get-together/_doc/100?routing=1" -H'Content-Type: application/json' -d'{
  "relationship_type": {
    "name": "event",
    "parent": "1"
  },
  "host": ["Lee", "Troy"],
  "title": "Liberator and Immutant",
  "description": "We will discuss two different frameworks in Clojure for doing different things. Liberator is a ring-compatible web framework based on Erlang Webmachine. Immutant is an all-in-one enterprise application based on JBoss.",
  "attendees": ["Lee", "Troy", "Daniel", "Tom"],
  "date": "2013-09-05T18:00",
  "location_event": {
    "name": "Stoneys Full Steam Tavern",
    "geolocation": "39.752337,-105.00083"
  },
  "reviews": 4
}'

如上所示，id为1的记录，其relationship_type字段的值为"group"，id为2的记录，relationship_type字段的值不是字符串，而是对象，parent为1表示父文档id为1，name为"event"表示父子关系是"group:event"类型；

注意：上述第二个文档的地址中携带了routing参数，以保持父子在同一个分片，这是在使用join类型是要格外注意的地方；

接下来，确保前面提到的populate.sh脚本已经执行，使得_doc索引及其文档数据在es环境中准备好，就可以实战了，实战环境是Kibana的Det Tools：

查找所有父类型为"group"的文档(结果是子文档)：

执行如下脚本：

GET get-together/_search
{
  "query": {
    "has_parent": {
      "parent_type": "group",
      "query": {
        "match_all": {}
      }
    }
  }
}

可以得到所有父类型为"group"的子文档：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 15,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "106",
        "_score" : 1.0,
        "_routing" : "3",
        "_source" : {
          "relationship_type" : {
            "name" : "event",
            "parent" : "3"
          },
          "host" : "Mik",
          "title" : "Social management and monitoring tools",
          "description" : "Shay Banon will be there to answer questions and we can talk about management tools.",
          "attendees" : [
            "Shay",
            "Mik",
            "John",
            "Chris"
          ],
          "date" : "2013-03-06T18:00",
          "location_event" : {
            "name" : "Quid Inc",
            "geolocation" : "37.798442,-122.399801"
          },
          "reviews" : 5
        }
      },
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "107",
        "_score" : 1.0,
        "_routing" : "3",
        "_source" : {
          "relationship_type" : {
            "name" : "event",
            "parent" : "3"
          },
          "host" : "Mik",
          "title" : "Logging and Elasticsearch",
          "description" : "Get a deep dive for what Elasticsearch is and how it can be used for logging with Logstash as well as Kibana!",
          "attendees" : [
            "Shay",
            "Rashid",
            "Erik",
            "Grant",
            "Mik"
          ],
          "date" : "2013-04-08T18:00",
          "location_event" : {
            "name" : "Salesforce headquarters",
            "geolocation" : "37.793592,-122.397033"
          },
          "reviews" : 3
        }
      },
     ...

查找所有子类型为"event"的文档（结果是父文档）

执行如下脚本：

GET get-together/_search
{
  "query": {
    "has_child": {
      "type": "event",
      "query": {
        "match_all": {}
      }
    }
  }
}

可以得到所有子类型为"event"的文档：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 5,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "relationship_type" : "group",
          "name" : "Elasticsearch San Francisco",
          "organizer" : "Mik",
          "description" : "Elasticsearch group for ES users of all knowledge levels",
          "created_on" : "2012-08-07",
          "tags" : [
            "elasticsearch",
            "big data",
            "lucene",
            "open source"
          ],
          "members" : [
            "Lee",
            "Igor"
          ],
          "location_group" : "San Francisco, California, USA"
        }
      },
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "relationship_type" : "group",
          "name" : "Denver Clojure",
          "organizer" : [
            "Daniel",
            "Lee"
          ],
          "description" : "Group of Clojure enthusiasts from Denver who want to hack on code together and learn more about Clojure",
          "created_on" : "2012-06-15",
          "tags" : [
            "clojure",
            "denver",
            "functional programming",
            "jvm",
            "java"
          ],
          "members" : [
            "Lee",
            "Daniel",
            "Mike"
          ],
          "location_group" : "Denver, Colorado, USA"
        }
      },
     ...

查找parent的id等于1的子文档

执行如下脚本：

GET get-together/_search
{
  "query": {
    "parent_id": {
      "type": "event",
      "id": "1"
    }
  }
}

可以得到所有parent的id等于1的子文档：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 1.3291359,
    "hits" : [
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "100",
        "_score" : 1.3291359,
        "_routing" : "1",
        "_source" : {
          "relationship_type" : {
            "name" : "event",
            "parent" : "1"
          },
          "host" : [
            "Lee",
            "Troy"
          ],
          "title" : "Liberator and Immutant",
          "description" : "We will discuss two different frameworks in Clojure for doing different things. Liberator is a ring-compatible web framework based on Erlang Webmachine. Immutant is an all-in-one enterprise application based on JBoss.",
          "attendees" : [
            "Lee",
            "Troy",
            "Daniel",
            "Tom"
          ],
          "date" : "2013-09-05T18:00",
          "location_event" : {
            "name" : "Stoneys Full Steam Tavern",
            "geolocation" : "39.752337,-105.00083"
          },
          "reviews" : 4
        }
      },
      ...

用script_fields简化返回内容

前面的查询，返回的内容是整个_source，如果不需要全部内容，可以用script_fields来简化；

  1. 查找所有父文档ID等1的的子文档，并且返回内容只有三个字段：父文档ID、子文档ID、子文档title字段：
GET get-together/_search
{
   "query": {
    "parent_id": {
      "type": "event",
      "id": "1"
    }
  },
  "script_fields":{
      "group_id":{
        "script":{
          "source":"doc['relationship_type#group']"
        }
      },"event_id":{
        "script":{
          "source":"doc['_id']"
        }
      },
      "title":{
        "script":"params['_source']['title']"
      }
    }
}

得到结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 1.3291359,
    "hits" : [
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "100",
        "_score" : 1.3291359,
        "_routing" : "1",
        "fields" : {
          "event_id" : [
            "100"
          ],
          "title" : [
            "Liberator and Immutant"
          ],
          "group_id" : [
            "1"
          ]
        }
      },
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "101",
        "_score" : 1.3291359,
        "_routing" : "1",
        "fields" : {
          "event_id" : [
            "101"
          ],
          "title" : [
            "Sunday, Surly Sunday"
          ],
          "group_id" : [
            "1"
          ]
        }
      },
      {
        "_index" : "get-together",
        "_type" : "_doc",
        "_id" : "102",
        "_score" : 1.3291359,
        "_routing" : "1",
        "fields" : {
          "event_id" : [
            "102"
          ],
          "title" : [
            "10 Clojure coding techniques you should know, and project openbike"
          ],
          "group_id" : [
            "1"
          ]
        }
      }
    ]
  }
}

聚合

执行以下查询，会将所有父文档为group的子文档做桶聚合聚合：

GET get-together/_search
{
  "query": {
    "has_parent": {
      "parent_type": "group",
      "query": {
        "match_all": {}
      }
    }
  },
   "aggs":{
      "parents":{
        "terms":{
          "field":"relationship_type#group"
        }
      }
    }
}

得到的结果如下，按照父文档ID得到聚合结果：

"aggregations" : {
    "parents" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "1",
          "doc_count" : 3
        },
        {
          "key" : "2",
          "doc_count" : 3
        },
        {
          "key" : "3",
          "doc_count" : 3
        },
        {
          "key" : "4",
          "doc_count" : 3
        },
        {
          "key" : "5",
          "doc_count" : 3
        }
      ]
    }
  }
}

以上就是join类型的主要实战内容了，希望能帮助您理解这个新的类型；

欢迎关注我的公众号：程序员欣宸

在这里插入图片描述

程序员欣宸
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
elasticsearch数据类型--join
w1346561235的博客
09-16 789
elasticsearch是一个搜索引擎，附带了数据存储功能。相比关系数据库为关系而生而言，elasticsearch并不删除处理数据之间的关系模型。但仍然提供了对此类需求的有限支持，join和nested数据类型。尽管如此，贯穿整个elasticsearch手册都在强调的一句话是The join field shouldn’t be used like joins in a relation d...
Elasticsearch： Join 数据类型
Elastic 中国社区官方博客
09-01 3966
在Elasticsearch中，Join可以让我们创建parent/child关系。Elasticsearch不是一个RDMS。通常join数据类型尽量不要使用，除非不得已。那么Elasticsearch为什么需要Join数据类型呢？ 在Elasticsearch中，更新一个object需要root object一个完整的reindex： 即使是一个field的一个字符的改变 即便是nest......
elasticsearch6
最新发布
2401_84170391的博客
06-20 321
下载地址：https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.8.23.tar.gz1、准备三台机器，192.168.1.1、192.168.1.2、192.168.1.32、上传elasticsearch-6.8.23.tar.gz到三台机器的 /usr/local，然后都执行下面的命令 3、验证是否安装成功：curl 192.168.1.1:9200浏览器访问 http://192.168.1.1:9200/_cat/
4.elasticsearch join type
哇哈哈
10-22 551
Elasticsearch join type https://blog.csdn.net/laoyang360/article/details/79774481 join数据类型是一个特殊字段，可在相同索引的文档中创建父/子关系。 relations属性定义了一组可能的关系，每个关系都是父名称和子名称。 创建join类型的文档必须在源文档中通过name指定关系。 PUT my_index { ...
【ES实战】ES6.X Join
coding and writing
10-24 1725
ES6.X Join
elasticsearch的join查询
12-06 234
1.概述 官方文档 https://www.elastic.co/guide/en/elasticsearch/reference/current/joining-queries.html 两种类型的查询 嵌套查询 has_child和has_parent 其中，has_child返回包含特定查询字段文档的父文档; has_parent返回包含特定查询字段的父文档的子文档。...
Elasticsearch:ElasticSearch示例
05-02
**Elasticsearch：深入理解与实战** Elasticsearch（简称ES）是一款强大的开源搜索引擎，以其高效、可扩展和易用性赢得了广泛的认可。它基于Lucene库构建，但提供了更高级别的分布式、实时的搜索和分析引擎服务。在...
vue-react-h5实战遇到的问题.docx
04-17
6. **路由判断登录状态**：基于本地存储判断用户登录状态，根据状态决定是否跳转特定路由。 7. **递归组件**：为实现递归组件，需要给组件添加`name`属性。 【React中的问题及解决方案】 1. **列表更新问题**：给...
Pytorch入门实战学习笔记
04-24
### PyTorch 入门实战学习笔记 #### 一、PyTorch简介 PyTorch 是一个基于 Torch 的机器学习库，它支持动态计算图，主要用于应用程序中的深度神经网络研究。PyTorch 提供了丰富的功能，如自动梯度计算、GPU 加速...
Flink从入门到开发实战视频教程
12-28
3. **Flink与其他系统集成**：如何与Hadoop、Cassandra、Elasticsearch等系统集成，构建完整的数据处理流水线。 4. **高级特性**：如流-批统一、cep复杂事件处理、状态Backpressure等。 通过本视频教程，你将不仅...
Elasticsearch6.X 新类型Join深入详解
热门推荐
铭毅天下Elasticsearch
03-31 4万+
0、ES6.X 一对多、多对多的数据该如何存储和实现呢？ 引出问题： “某头条新闻APP”新闻内容和新闻评论是1对多的关系？ 在ES6.X该如何存储、如何进行高效检索、聚合操作呢？ 相信阅读本文，你就能得到答案！ 1、ES6.X 新类型Join 产生背景 Mysql中多表关联，我们可以通过left join 或者Join等实现； ES5.X版本，借助父子文档实现多...
es6.X 新类型Join深入详解
leveretz的博客
11-24 312
es6.X 新类型Join深入详解
Siren Federate - Elasticsearch (join)增强插件初探
点火三周的专栏
11-12 1万+
文章目录用户对于es join的热切需求Siren Federate 插件带来的扩展能力Siren Federate的安装外部数据源的虚拟映射支持的外部数据源MySQL测试创建远程数据源步骤创建远程数据源对象Siren Federate join 与 Elasticsearch joinSiren Federate的分布式join半连接（semi join）内联接（inner join）Siren Federate的分布式join的特点及限制虚拟索引和普通索引的jion?总结 最近在Elastic官网blo
Elasticsearch之join关联查询
星空的风fly
11-19 1万+
Elasticsearch提供了类似于SQL JOIN的关联查询，通过has_child/has_parent可以实现一对多关系的父子表数据查询。但是其损耗也是比较大的，在使用的时候要根据分片数量的多少和预估数量量级的大小，提前做好性能测试
elasticsearch父子文档处理(join)
huan的学习记录
05-08 1640
elasticsearch父子文档处理 join一、背景二、需求三、前置知识四、实现步骤1、创建 mapping2、添加父文档数据3、添加子文档4、查询文档1、根据父文档id查询它下方的子文档2、has_child返回满足条件的父文档3、has_parent返回满足父文档的子文档五、Nested Object 和 join 对比六、参考文档 一、背景 在我们工作的过程中，有些时候我们需要用到父子文档的关系映射。**比如：**一个问题有多个答案、一本书籍有多个评论等等。此处我们可以使用 es 的 jion数据
Elasticsearch中使用join来进行父子关联
weixin_43360488的博客
10-23 879
在使用关系数据库进行开发的过程中，你可能会经常使用外键来表示父表和子表之间的关联关系，在Elasticsearch中，有哪些方法可以用来让开发者解决索引之间一对多和多对多的关联关系的问题呢。
59_elasticSearch 通过应用层join实现用户与博客的关联
架构师的成长之路的博客
04-09 991
59_通过应用层join实现用户与博客的关联更多干货分布式实战（干货）spring cloud 实战（干货）mybatis 实战（干货）spring boot 实战（干货）React 入门实战（干货）构建中小型互联网企业架构（干货）python 学习持续更新ElasticSearch 笔记一、概述1、构造用户与博客数据在构造数据模型的时候，还是将有关联关系的数据，然后分割为不同的实体，类似于关系型...
[elasticsearch笔记] Joining Queries - nested/join
weixin_43834662的博客
07-25 696
note 干货 | Elasticsearch Nested类型深入详解 elasticsearch（lucene）使用的库没有内部对象的概念，因此内部对象被扁平化为一个简单的字段名称和值列表。 为了解决这个问题，需要用到 nested，nested对象会被作为隐式对象处理。其内容不会被扁平化处理。 关联 doc 必须保存于同一个分片，所以在构建 index的时候，需要添加 routing=pa...
Elasticsearch运维实战：从Schemaless到倒排索引详解
- Elasticsearch在7.0版本之前支持多类型（Type），但自7.0开始，Type被弃用，每个索引仅允许一个类型的命名："_doc"。 - ES的特点是schemaless（无模式），强调高相关性和高性能全文检索，而RDBMS则更侧重于事务...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员欣宸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值