Elasticsearch中父子文档的关联：利用Join类型赋予文档的层级关系

心中有诗画，指尖舞代码，目光览世界，步履越千山，人间尽值得 !

Elasticsearch是一个强大的搜索引擎，它提供了丰富的功能来满足复杂的搜索需求。其中，父子索引类型的join功能是一个强大的工具，它允许我们在同一索引中创建具有层级关系的文档。在这篇博客中，我们将深入探讨Elasticsearch中的父子索引类型join，包括其工作原理、如何使用以及需要注意的事项。

目录

• • 前言
  • • 1. 父子关系文档
    • 2. Nested嵌套类型
    • 3. Nested类型和父子类型的差异
    • 一、使用对象数组存在的问题
    • 二、父子索引类型join的工作原理和作用
    • • 父子join关联解决的问题
      • 使用join字段的优势
      • 三、父子join关联的使用
      • • 3.1 创建带join字段的索引
        • 3.2 添加父子文档
        • 3.3 特殊搜索方式
        • 3.4 聚集操作
        • 四、应用层关联数据
        • 五、注意事项和性能考虑
        • 结语

          前言

          在Elasticsearch的实际应用中，嵌套文档是一个常见的需求，尤其是当我们需要对对象数组进行独立索引和查询时。在Elasticsearch中，这类嵌套结构被称为父子文档，它们能够“彼此独立地进行查询”。实现这一功能主要有两种方式：

          1. 父子关系文档

          • 在Elasticsearch 5.x版本中，这种关系是通过parent-child父子type来实现的，允许一个索引对应多个type。
          • 但从6.x版本开始，由于Elasticsearch不再支持单个索引对应多个type，因此父子索引的实现方式转变为使用Join数据类型。

            2. Nested嵌套类型

            • 这是一种更为紧凑和高效的方式来处理嵌套文档，允许在单个文档中直接嵌套其他文档，并保持它们之间的关联性，便于进行复杂的查询操作。

              3. Nested类型和父子类型的差异

              Nested类型：

              1. 数据结构：Nested类型用于索引和查询对象数组，其中每个对象都可以看作是一个独立的文档。这些对象在内部被视为独立的文档，可以独立地进行索引和查询。
              2. 查询性能：由于Nested类型的每个嵌套对象都是独立索引的，因此查询性能相对较高。你可以直接针对嵌套对象的特定字段进行查询，而无需扫描整个文档。
              3. 使用场景：当你有一个文档，其中包含多个与主文档相关联的子对象时，例如一个订单文档中包含多个商品项，每个商品项都有自己的一组属性，这时使用Nested类型是非常合适的。
              4. 更新限制：更新Nested类型中的一个嵌套对象通常需要重新索引整个主文档，这可能会影响性能。

              

              父子类型：

              1. 数据结构：父子Join类型允许你将两个独立的文档（父文档和子文档）通过关系字段连接起来。每个文档都是单独存储的，但它们之间通过特定的join字段来建立关联。
              2. 查询性能：查询性能可能略低于Nested类型，因为父子文档是分开存储的，查询时可能需要进行额外的连接操作。
              3. 使用场景：当你需要处理具有一对多关系的文档时，例如博客文章（父文档）和评论（子文档），或者用户和他们的订单等场景，父子Join类型是一个很好的选择。
              4. 更新灵活性：与Nested类型不同，使用父子Join类型时，你可以独立地更新父文档或子文档，而无需重新索引与其相关联的文档。这提供了更大的灵活性，特别是在需要频繁更新或添加新关联数据的情况下。

              Nested类型和父子Join类型在处理关联数据时各有优势。Nested类型更适合处理静态的、紧密关联的嵌套数据，而父子Join类型则更适合处理需要动态更新或具有一对多关系的文档。

              一、使用对象数组存在的问题

              对象数组的默认存储方式：

              Elasticsearch内部并不直接支持对象的层次结构，而是将对象层次结构扁平化为一个字段名和字段值的简单列表。这种处理方式可能导致数据关联性的丢失。例如，考虑以下文档：

              PUT user/user_info/1
              {
                "group": "man",
                "userName": [ 
                  {
                    "first": "张",
                    "last": "三"
                  },
                  {
                    "first": "李",
                    "last": "四"
                  }
                ]
              }
              

              如果我们尝试查询first为“张”且last为“四”的数据，按照常理，这样的数据应该不存在。然而，使用以下查询：

              GET /user/user_info/_search
              {
                "query": {
                  "bool": {
                    "must": [
                      {
                        "match": {
                          "userName.first": "张"
                        }
                      },
                      {
                        "match": {
                          "userName.last": "四"
                        }
                      }
                    ]
                  }
                }
              }
              

              意外地，我们可能会得到结果。这是因为Lucene（Elasticsearch的底层库）没有内部对象的概念，它将内部对象扁平化处理了。在内部，文档实际上被存储为：

              {
                "group": "man",
                "userName.first": ["张", "李"],
                "userName.last": ["三", "四"]
              }
              

              可以看到，userName.first和userName.last被扁平化为多值字段，它们之间的关联性已经丢失，因此查询结果可能不符合我们的预期。

              二、父子索引类型join的工作原理和作用

              在Elasticsearch中，父子索引类型join是通过特殊的字段类型来实现的，该字段类型被称为“join”。这个字段允许我们定义文档之间的父子关系。当我们创建一个包含join字段的索引时，我们需要指定哪些文档类型是父文档，哪些是子文档。

              在底层，Elasticsearch使用特殊的路由机制来确保父子文档存储在同一个分片上。这是非常重要的，因为这样可以提高查询性能并确保数据的一致性。当我们索引一个子文档时，需要使用routing参数来指定其父文档的ID，以便Elasticsearch可以将它们路由到相同的分片。

              父子join关联解决的问题

              1. 数据层级关系的表示：在实际应用中，很多数据天然具有层级或关联关系。例如，一个博客系统可能包含博客文章和对应的评论，其中博客文章是父级数据，而评论是与文章相关联的子级数据。父子索引类型允许在Elasticsearch中明确地表示这种数据之间的层级关系。

              2. 关联查询的优化：当数据之间存在关联关系时，我们经常需要进行跨层级的查询。比如，我们可能想要找到所有包含特定评论的博客文章，或者查找某篇博客文章下的所有评论。通过使用父子索引类型，Elasticsearch可以高效地处理这类关联查询，因为它内部优化了父子文档之间的关联访问。

              3. 数据聚合和分析：在数据分析场景下，我们可能需要对具有层级关系的数据进行聚合操作。父子索引类型使得这类聚合更加直观和高效。例如，可以很容易地统计每篇博客文章有多少评论，或者分析不同类型的博客文章下评论的分布情况。

              4. 文档间的引用完整性：在某些情况下，确保文档间的引用完整性是很重要的。通过使用父子关系，可以更容易地管理和维护这种完整性。例如，当删除一个父文档时，可以方便地找到并处理所有相关的子文档。

              5. 简化数据模型：在某些情况下，使用父子关系可以简化数据模型的设计。通过将相关联的数据组织在同一个索引中，并明确它们的层级关系，可以减少数据冗余和提高数据的一致性。

              虽然父子索引类型提供了解决上述问题的有效手段，但它也带来了一些额外的复杂性和性能考虑。因此，在使用之前需要仔细评估数据模型和查询需求，以确定是否适合使用父子索引类型。

              使用join字段的优势

              join字段提供了一种在索引中明确定义父子文档之间关系的方法。使用join字段的优势在于：

              • 独立操作：可以独立地对子文档进行增加、删除和修改操作，而不需要对整个数组进行操作。
              • 性能优化：父子文档位于同一索引，减少了查询时的网络开销，因为不需要跨索引进行搜索。
              • 特殊搜索方式：支持以父搜子、以子搜父等特殊搜索方式，使得查询更加灵活和高效。
              • 聚集操作：join字段还支持children和parent聚集操作，用于对父子文档进行统计分析。

                三、父子join关联的使用

                3.1 创建带join字段的索引

                创建一个新的索引，并定义好父子文档的映射关系。在映射中加入join字段，并设置好父子关系的名称。例如，我们可以定义一个订单索引，其中包含商品子文档。

                PUT order-join
                {
                  "settings": {
                    "number_of_shards": 5,
                    "number_of_replicas": 1
                  },
                  "mappings": {
                    "properties": {
                      "orderid": { "type": "integer" },
                      "buyer": { "type": "keyword" },
                      "order_time": { "type": "date", "format": "yyyy-MM-dd HH:mm:ss" },
                      "goodsid": { "type": "integer" },
                      "goods_name": { "type": "keyword" },
                      "price": { "type": "double" },
                      "produce_time": { "type": "date", "format": "yyyy-MM-dd HH:mm:ss" },
                      "my_join_field": {
                        "type": "join",
                        "relations": {
                          "order": "goods"
                        }
                      }
                    }
                  }
                }
                

                3.2 添加父子文档

                在添加文档时，需要明确指定文档的父子关系。父文档只需指定join字段的关系名称，而子文档则需指定父文档的主键和关系名称。

                PUT order-join/_doc/1
                {
                  "orderid": "1",
                  "buyer": "tom",
                  "order_time": "2020-11-04 00:00:00",
                  "my_join_field": {
                    "name": "order"
                  }
                }
                PUT order-join/_doc/2?routing=1
                {
                  "goodsid": "1",
                  "goods_name": "milk",
                  "price": 5.2,
                  "produce_time": "2020-10-04 00:00:00",
                  "my_join_field": {
                    "name": "goods",
                    "parent": "1"
                  }
                }
                

                3.3 特殊搜索方式

                利用join字段，可以实现一些特殊的搜索操作：

                • 以父搜子：通过父文档的属性来查询子文档。例如，我们可以查询所有属于特定买家的商品。

                  POST order-join/_search
                  {
                    "query": {
                      "has_parent": {
                        "parent_type": "order",
                        "query": {
                          "term": {
                            "buyer": {
                              "value": "tom"
                            }
                          }
                        }
                      }
                    }
                  }
                  

                • 以子搜父：通过子文档的属性来查询父文档。例如，我们可以查询所有包含特定商品的订单。

                  POST order-join/_search
                  {
                    "query": {
                      "has_child": {
                        "type": "goods",
                        "query": {
                          "match_all": {}
                        }
                      }
                    }
                  }
                  

                • 父文档主键搜索：通过父文档的主键值来查询所有关联的子文档。例如，我们可以查询订单号为1的所有商品。

                  POST order-join/_search
                  {
                    "query": {
                      "parent_id": {
                        "type": "goods",
                        "id": "1"
                      }
                    }
                  }
                  

                  3.4 聚集操作

                  join字段还支持children和parent聚集操作，用于对父子文档进行统计分析。

                  • children聚集：统计每个父文档的子文档数据。例如，我们可以统计每个买家购买的商品名称和数量。

                    POST order-join/_search
                    {
                      "query": {
                        "match_all": {}
                      },
                      "aggs": {
                        "orders": {
                          "terms": {
                            "field": "buyer",
                            "size": 10
                          },
                          "aggs": {
                            "goods_data": {
                              "children": {
                                "type": "goods"
                              },
                              "aggs": {
                                "goods_name": {
                                  "terms": {
                                    "field": "goods_name",
                                    "size": 10
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    

                  • parent聚集：统计每个子文档的父文档数据。例如，我们可以统计每种商品的购买者信息。

                    POST order-join/_search
                    {
                      "aggs": {
                        "goods": {
                          "terms": {
                            "field": "goods_name",
                            "size": 10
                          },
                          "aggs": {
                            "goods_data": {
                              "parent": {
                                "type": "goods"
                              },
                              "aggs": {
                                "orders": {
                                  "terms": {
                                    "field": "buyer",
                                    "size": 10
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    

                    四、应用层关联数据

                    除了使用join字段，还可以在应用层通过外键字段来实现父子关联。这种方法需要为父文档和子文档分别建立索引，并在查询时进行多次请求。虽然这种方法在处理父子关系时可能不如join字段高效，但它提供了更多的灵活性。

                    五、注意事项和性能考虑

                    • 性能影响：由于父子文档必须存储在同一个分片上，这可能会对索引的性能产生影响。当数据量非常大时，单个分片上的文档数量可能会增加，从而影响查询和索引性能。因此，在设计数据模型时需要谨慎考虑父子关系的使用。
                    • 数据一致性：当更新或删除父子文档时，需要确保数据的一致性。Elasticsearch不会自动处理父子文档之间的一致性，因此需要应用程序逻辑来确保数据同步。

                      结语

                      Elasticsearch中的父子索引类型join是一个强大的工具，它允许我们在同一索引中创建具有层级关系的文档。通过正确使用join字段和相关的查询DSL，我们可以有效地表示和查询具有父子关系的数据模型。然而，在使用时需要注意性能影响和数据一致性等问题，并确保与当前Elasticsearch版本的兼容性。

                      ---

                      ---

                      听说...关注下面公众号的人都变牛了，纯技术，纯干货 !

                      

手机扫描二维码访问