Elasticsearch学习-父子文档

蔚落 2024-03-27 11:27 58阅读 0赞

#### [elasticsearch][]父子文档处理 join ####

*  一、背景
 *  二、需求
 *  三、前置知识
 *  四、实现步骤
 *   *  1、创建 mapping
     *  2、添加父文档数据
     *  3、添加子文档
     *  4、查询文档
     *   *  1、根据父文档id查询它下方的子文档
         *  2、has\_child返回满足条件的父文档
         *  3、has\_parent返回满足父文档的子文档
 *  五、Nested Object 和 join 对比
 *  六、参考文档

## 一、背景 ##

在我们工作的过程中，有些时候我们需要用到父子文档的关系映射。\*\*比如：\*\*一个问题有多个答案、一本书籍有多个评论等等。此处我们可以使用 es 的 `jion`数据类型或 `nested`来实现。此处我们使用`join`来建立es中的父子文档关系。

## 二、需求 ##

我们需要创建一个计划(`plan`)，计划下存在活动(`activity`)和书籍(`book`)，书籍下存在评论(`comments`)。

**即层级结构为：**

plan
        /    \
       /      \
    activity  book
               |
               |
              comments
    1234567

## 三、前置知识 ##

1.  每一个`mapping`下只能有一个`join`类型的字段。
2.  父文档和子文档必须在同一个分片(`shard`)上。**即：** 增删改查一个子文档都必须和父文档使用相同的 routing key。
3.  每个元素只能有一个父，但是可以存在多个子。
4.  可以为一个已经存在的 join 字段增加新的关联关系。
5.  可以为一个已经是父的元素增加一个子元素。

> `join`数据类型在`elasticsearch`中不应该像关系型数据库那种使用。而且`has_child`和`has_parent`都是比较消耗性能的。
> 
> 只有当 子的数据 远远大于 父的数据时，使用`join`才是有意义的。比如：一个博客下，有多个评论。

## 四、实现步骤 ##

### 1、创建 mapping ###

PUT /plan_index
    {
        
      "settings": {
        
        "number_of_shards": 3,
        "number_of_replicas": 1
      },
      "mappings": {
        
        "properties": {
        
          "plan_id":{
        
            "type": "keyword"
          },
          "plan_name":{
        
            "type": "text",
            "fields": {
        
              "keyword":{
        
                "type" : "keyword",
                "ignore_above" : 256
              }
            }
          },
          "act_id":{
        
            "type": "keyword"
          },
          "act_name":{
        
            "type": "text",
            "fields": {
        
              "keyword":{
        
                "type" : "keyword",
                "ignore_above" : 256
              }
            }
          },
          "comment_id":{
        
            "type": "keyword"
          },
          "comment_name":{
        
            "type": "text",
            "fields": {
        
              "keyword":{
        
                "type" : "keyword",
                "ignore_above" : 256
              }
            }
          },
          "creator":{
        
            "type": "keyword"
          },
          "create_time":{
        
            "type": "date",
            "format": "yyyy-MM-dd||yyyy-MM-dd HH:mm:ss"
          },
          "plan_join": {
        
            "type": "join",
            "relations": {
        
              "plan": ["activity", "book"],
              "book": "comments"
            }
          }
        }
      }
    }
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061

**注意⚠️**

![父子关系映射][33c816b39b17faf66ae62b7249fb8ec1.png]

### 2、添加父文档数据 ###

此处添加的是 (`plan`) 数据。

PUT /plan_index/_doc/plan-001
    {
        
      "plan_id": "plan-001",
      "plan_name": "四月计划",
      "creator": "huan",
      "create_time": "2021-04-07 16:27:30",
      "plan_join": {
        
        "name": "plan"
      }
    }
    
    PUT /plan_index/_doc/plan-002
    {
        
      "plan_id": "plan-002",
      "plan_name": "五月计划",
      "creator": "huan",
      "create_time": "2021-05-07 16:27:30",
      "plan_join": "plan"
    }
    12345678910111213141516171819

**注意⚠️：**

1、如果是创建父文档，则需要使用 `plan_join` 指定父文档的关系的名字(此处为plan)。

2、`plan_join`为创建索引的 `mapping`时指定`join`的字段的名字。

3、指定父文档时,`plan_join`的这2种写法都可以。

### 3、添加子文档 ###

PUT /plan_index/_doc/act-001?routing=plan-001
    {
        
      "act_id":"act-001",
      "act_name":"四月第一个活动",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"activity",
        "parent":"plan-001"
      }
    }
    
    PUT /plan_index/_doc/book-001?routing=plan-001
    {
        
      "book_id":"book-001",
      "book_name":"四月读取的第一本书",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"book",
        "parent":"plan-001"
      }
    }
    
    PUT /plan_index/_doc/book-002?routing=plan-001
    {
        
      "book_id":"book-002",
      "book_name":"编程珠玑",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"book",
        "parent":"plan-001"
      }
    }
    
    PUT /plan_index/_doc/book-003?routing=plan-002
    {
        
      "book_id":"book-003",
      "book_name":"java编程思想",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"book",
        "parent":"plan-002"
      }
    }
    
    # 理论上 comment 的父文档是 book ，但是此处routing使用 plan 也是可以的。
    PUT /plan_index/_doc/comment-001?routing=plan-001
    {
        
      "comment_id":"comment-001",
      "comment_name":"这本书还可以",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"comments",
        "parent":"book-001"
      }
    }
    
    PUT /plan_index/_doc/comment-002?routing=plan-001
    {
        
      "comment_id":"comment-002",
      "comment_name":"值得一读，棒。",
      "creator":"huan.fu",
      "plan_join":{
        
        "name":"comments",
        "parent":"book-001"
      }
    }
    123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566

**注意⚠️：**

![子文档的创建][689c8b11d162e15d44634dddb5a872f2.png]

1、子文档（子孙文档等）需要和父文档使用相同的路由键。

2、需要指定父文档的id。

3、需要指定join的名字。

### 4、查询文档 ###

#### 1、根据父文档id查询它下方的子文档 ####

\*\*需求：\*\*返回父文档id是plan-001下的类型为book的所有子文档。

GET /plan_index/_search
    {
      "query":{
        "parent_id": {
          "type":"book",
          "id":"plan-001"
        }
      }
    }
    123456789

![根据父文档id查询子文档][id]

#### 2、has\_child返回满足条件的父文档 ####

\*\*需求：\*\*返回创建者(creator)是huan.fu,并且子文档最少有2个的父文档。

GET /plan_index/_search
    {
        
      "query": {
        
        "has_child": {
        
          "type": "book",
          "min_children": 2,  
          "query": {
        
            "match": {
        
              "creator": "huan.fu"
            }
          }
        }
      }
    }
    1234567891011121314

![has\_child返回满足条件的父文档][has_child]

#### 3、has\_parent返回满足父文档的子文档 ####

\*\*需求：\*\*返回父文档(book)的创建者是huan.fu的所有子文档

GET /plan_index/_search
    {
        
      "query": {
        
        "has_parent": {
        
          "parent_type": "book",
          "query": {
        
            "match": {
        
              "creator":"huan.fu"
            }
          }
        }
      }
    }
    12345678910111213

![has\_parent返回满足父文档的子文档][has_parent]

## 五、Nested Object 和 join 对比 ##

<table> 
 <thead> 
  <tr> 
   <th>Nested Object</th> 
   <th>join (Parent/Child)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1、文档存储在一起，读取性能高</td> 
   <td>1、父子文档单独存储，互不影响。但是为了维护join的关系，需要占用额外的内容，读取性能略差。</td> 
  </tr> 
  <tr> 
   <td>2、更新父文档或子文档时，需要更新整个文档。</td> 
   <td>2、父文档和子文档可以单独更新。</td> 
  </tr> 
  <tr> 
   <td>3、适用于查询频繁，子文档偶尔更新的情况。</td> 
   <td>3、适用于更新频繁的情况，且子文档的数量远远超过父文档的数量。</td> 
  </tr> 
 </tbody> 
</table>

## 六、参考文档 ##

1、[join数据类型][join]

2、[has child查询][has child]

3、[has parent查询][has parent]

4、[parent id查询][parent id]

[elasticsearch]: https://so.csdn.net/so/search?q=elasticsearch&spm=1001.2101.3001.7020
[33c816b39b17faf66ae62b7249fb8ec1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/457e756c5e774956a44023cc4089b422.png
[689c8b11d162e15d44634dddb5a872f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ffd039fc93744e7e894c7d8454035490.png
[id]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/27b362f9faa249a38a4ce05237e4d9f9.png
[has_child]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/27b7c25bb606457cb6b1d8f9b32642b8.png
[has_parent]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/58d419461572492e9460b6cf841ec005.png
[join]: https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html#parent-join
[has child]: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-has-child-query.html
[has parent]: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-has-parent-query.html
[parent id]: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-parent-id-query.html