Nest数据类型

nest 类型是对象数据类型的一种特殊版本，允许以一种可以独立查询对象数组元素的方式对对象数组进行索引。

The nested type is a specialised version of the object data type that allows arrays of objects to be indexed in a way that they can be queried independently of each other.

nest类型的官方文档介绍

• dynamic：todo — 待更新
• properties：todo — 待更新
• include_in_parent：todo — 待更新
• include_in_root：todo — 待更新

nested类型的限制：

// todo — 待更新

e.g.

PUT my-index-000001/_doc/1
{
  "user": [
    {
      "first": "John",
      "last": "Smith"
    },
    {
      "first": "Alice",
      "last": "White"
    }
  ]
}

上述的插入文档的操作在内部会将其转换成如下：

{
	"user.first": ["john", "alice"],
	"user.last": ["smith", "white"]
}

可以看出 user.first、user.last 字段都会平铺成多值的字段，alice、white 之间还有 john、smith 之间的关联关系会丢失。

导致下面的查询的结果也是不准确的：

GET my-index-000001/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "user.first": "Alice"
          }
        },
        {
          "match": {
            "user.last": "Smith"
          }
        }
      ]
    }
  }
}

对此，可以采用 nested 类型解决这种问题。

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "user": {
        "type": "nested",
        "properties": {
          "first": {
            "type": "text"
          },
          "last": {
            "type": "text"
          }
        }
      }
    }
  }
}

PUT my-index-000001/_doc/1
{
  "user": [
    {
      "first": "John",
      "last": "Smith"
    },  
    {
      "first": "Alice",
      "last": "White"
    }
  ]
}

GET my-index-000001/_search
{
  "query": {
    "nested": {
      "path": "user",
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "user.first": "Alice"
              }
            },
            {
              "match": {
                "user.last": "White"
              }
            }
          ]
        }
      }
    }
  }
}

Nested Query

即嵌套查询。针对 nested 类型字段的查询。

自己的理解：前面说到 nested 类型是允许以一种可以独立查询对象数组元素的方式对对象数组进行索引，也就是说对象数组元素即子对象作为一个整体进行匹配，如果匹配成功，则返回父文档。

nested query 的官方文档介绍

• path：（必须）想要查询的嵌套对象

• query：（必须）基于嵌套对象，想要查询的内容

• score_mode：匹配的子对象集合的分数如何影响父文档的关联性分数

  • avg：（默认值）取匹配的子对象集合的分数的平均值作为父文档的关联性分数
  • max：取匹配的子对象集合的分数的最大值作为父文档的关联性分数
  • min：取匹配的子对象集合的分数的最小值作为父文档的关联性分数
  • none：将父文档的关联性分数设置为0
  • sum：累加匹配的子对象集合的分数作为父文档的关联性分数

• ignore_unmapped：当 path 没有匹配到时，如果设置为 true，则返回空文档；如果设置为 false，则报错。默认 false

多层嵌套

PUT drivers
{
  "mappings": {
    "properties": {
      "driver": {
        "type": "nested",
        "properties": {
          "last_name": {
            "type": "text"
          },
          "vehicle": {
            "type": "nested",
            "properties": {
              "make": {
                "type": "text"
              },
              "model": {
                "type": "text"
              }
            }
          }
        }
      }
    }
  }
}

PUT /drivers/_doc/1
{
  "driver": {
    "last_name": "McQueen",
    "vehicle": [
      {
        "make": "Powell Motors",
        "model": "Canyonero"
      },
      {
        "make": "Miller-Meteor",
        "model": "Ecto-1"
      }
    ]
  }
}

PUT /drivers/_doc/2?refresh
{
  "driver": {
    "last_name": "Hudson",
    "vehicle": [
      {
        "make": "Mifune",
        "model": "Mach Five"
      },
      {
        "make": "Miller-Meteor",
        "model": "Ecto-1"
      }
    ]
  }
}

GET drivers/_search
{
  "query": {
    "nested": {
      "path": "driver",
      "query": {
        "nested": {
          "path": "driver.vehicle",
          "query": {
            "bool": {
              "must": [
                {
                  "match": {
                    "driver.vehicle.make": "Powell Motors"
                  }
                },
                {
                  "match": {
                    "driver.vehicle.model": "Canyonero"
                  }
                }
              ]
            }
          }
        }
      }
    }
  }
}

Join数据类型

join 类型是一种特殊类型，可以在相同索引下的多个文档中创建父子关系。它会在 relations 字段中定义一组可能的关系，包括父名称和子名称。

The join data type is a special field that creates parent/child relation within documents of the same index. The relations section defines a set of possible relations within the documents, each relation being a parent name and a child name.

e.g.

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "my_join_field": {
        "type": "join",
        "relations": {
          "question": "answer"
        }
      },
      "text": {
        "type": "text"
      }
    }
  }
}

PUT my-index-000001/_doc/1
{
  "my_join_field": {
    "name": "question"
  },
  "text": "This is a question"
}

对于父文档来说，上述的文档可以简写成如下这种形式：

PUT my-index-000001/_doc/1
{
  "my_join_field": "question",
  "text": "This is a question"
}

但是对于子文档来说，name、parent 一定要有。

PUT my-index-000001/_doc/3?routing=1
{
  "my_join_field": {
    "name": "answer",
    "parent": "1"
  },
  "text": "This is an answer"
}

创建子文档，必须指定routing参数值

join 类型的限制

• 每个索引中只能有一个 join 类型的字段
• 父文档与子文档必须在相同的分片中，也就是说子文档的增、删、改操作中必须指定 routing
• 一个元素可以有多个子关系，但是只能有一个父关系
• 可以在已经存在的 join 类型的字段中添加一组新的父子关系
• 可以对作为父关系的元素添加一个子关系

join 类型的字段使用全局序号来提高连接查询的速度。在分片发生变化后，需要重建全局序号。存储在一个分片中的 parent id 值越多，重建 join 类型的字段的全局序号所需的时间越长。默认情况下，全局序号会预先构建，如果索引发生了变化，join 类型的字段的全局序号就会作为刷新的一部分进行重新构建。

如果 join 类型的字段不经常使用并且写操作频繁时，可以选择禁用预先加载全局序号，如下：

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "my_join_field": {
        "type": "join",
        "relations": {
           "question": "answer"
        },
        "eager_global_ordinals": false
      }
    }
  }
}

此外，可以一个父关系对应多个子关系：

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "my_join_field": {
        "type": "join",
        "relations": {
          "question": ["answer", "comment"]  
        }
      }
    }
  }
}

还可以定义多层的关系模型：

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "my_join_field": {
        "type": "join",
        "relations": {
          "question": ["answer", "comment"],  
          "answer": "vote" 
        }
      }
    }
  }
}

不推荐使用上述的多层的关系模型。每一层级关系在查询时都会增加内存和计算的开销。

Has_Child Query

返回与提供的查询相匹配的子文档关联的父文档。可以使用 join 类型的字段在不同文档中建立父子关系。

Returns parent documents whose joined child documents match a provided query. You can create parent-child relationships between documents in the same index using a join field mapping.

因为 has_child 查询执行关联查询，所以它比其它查询要慢。并且它会随着匹配的子文档数量增加而性能降低。搜索中的每个 has_child 查询会显著增加查询时间。

Because it performs a join, the has_child is slow compared to other queries. Its performance degrades as the number of matching child documents pointing to unique parent documents increases. Each has_child query in a search can increase query time significantly.

has_child query 的官方文档介绍

• type：（必须）join 类型的字段中定义的子关系名称

• query：（必须）基于 type 查询对应的子文档，如果有子文档匹配查询，则返回与之关联的父文档

• ignore_unmapped：如果 type 没有匹配到，选择返回空内容还是返回一个错误。默认 false

  • true：返回空内容
  • false：返回一个错误

• max_children：要求父文档中子文档的数量<=该值时，父文档才能从结果中返回

• min_children：要求父文档中子文档的数量>=该值时，父文档才能从结果中返回

• score_mode：匹配的子文档的分数如何影响父文档的关联性分数。默认 none

  • none：将 boost 参数值（默认1）作为父文档的关联性分数
  • avg：取匹配的子文档的分数的平均值作为父文档的关联性分数
  • max：取匹配的子文档的分数的最大值作为父文档的关联性分数
  • min：取匹配的子文档的分数的最小值作为父文档的关联性分数
  • sum：累加匹配的子文档的分数作为父文档的关联性分数

e.g.

PUT my-index-000001
{
  "mappings": {
    "properties": {
      "my_join_field": {
        "type": "join",
        "relations": {
          "question": "answer"
        }
      },
      "text": {
        "type": "text"
      }
    }
  }
}

PUT my-index-000001/_doc/1
{
  "my_join_field": {
    "name": "question"
  },
  "text": "This is a question"
}

PUT my-index-000001/_doc/2
{
  "my_join_field": {
    "name": "question"
  },
  "text": "This is another question"
}

PUT my-index-000001/_doc/3?routing=1
{
  "my_join_field": {
    "name": "answer",
    "parent": "1"
  },
  "text": "This is an answer"
}

PUT my-index-000001/_doc/4?routing=2
{
  "my_join_field": {
    "name": "answer",
    "parent": "2"
  },
  "text": "This is another answer"
}

PUT my-index-000001/_doc/5?routing=2
{
  "my_join_field": {
    "name": "answer",
    "parent": "2"
  },
  "text": "This is another answer"
}

创建子文档，必须指定routing参数值

GET my-index-000001/_search
{
  "query": {
    "has_child": {
      "type": "answer",
      "ignore_unmapped": true,
      "min_children": 2, 
      "query": {
        "match": {
          "text": "answer"
        }
      }
    }
  }
}

值得注意的是，不能使用标准的 sort options 对 has_child 查询结果排序，但是可以使用 function_score 查询，并且按照 _score 排序。

GET my-index-000001/_search
{
  "query": {
    "has_child": {
      "type": "answer",
      "score_mode": "max",
      "query": {
        "function_score": {
          "query": {
            "match": {
              "text": "answer"
            }
          },
          "script_score": {
            "script": "_score"
          }
        }
      }
    }
  }
}

Has_Parent Query

返回与提供的查询相匹配的父文档关联的子文档。可以使用 join 类型的字段在不同文档中建立父子关系。

Returns child documents whose joined parent documents match a provided query. You can create parent-child relationships between documents in the same index using a join field mapping.

因为 has_parent 查询执行关联查询，所以它比其它查询要慢。并且它会随着匹配的父文档的数量增加而性能降低。搜索中的每个 has_parent 查询会显著增加查询时间。

Because it performs a join, the has_parent query is slow compared to other queries. Its performance degrades as the number of matching parent documents increases. Each has_parent query in a search can increase query time significantly.

has_parent query 的官方文档介绍

• parent_type：（必须）join 类型的字段中定义的父关系名称

• query：（必须）基于 parent_type 查询对应的父文档，如果有父文档匹配查询，则返回与之关联的子文档

• ignore_unmapped：如果 parent_type 没有匹配到，选择返回空内容还是返回一个错误。默认 false

  • true：返回空内容
  • false：返回一个错误

• score：是否将匹配到的父文档的关联性分数聚合到对应的子文档中。默认 false

  • false：忽略父文档的关联性分数，将 boost 参数值（默认1）作为子文档的关联性分数
  • true：使用父文档的关联性分数作为子文档的关联性分数

e.g.

GET my-index-000001/_search
{
  "query": {
    "has_parent": {
      "parent_type": "question",
      "score": false,
      "query": {
        "match": {
          "text": "question"
        } 
      }
    }
  }
}

值得注意的是，不能使用标准的 sort options 对 has_child 查询结果排序，但是可以使用 function_score 查询，并且按照 _score 排序。

GET my-index-000001/_search
{
  "query": {
    "has_parent": {
      "parent_type": "question",
      "score": true,
      "query": {
        "function_score": {
          "query": {
            "match": {
              "text": "question"
            }
          },
          "script_score": {
            "script": "_score"
          }
        }
      }
    }
  }
}

Parent_Id Query

返回与指定父文档关联的所有子文档。可以使用 join 类型的字段在不同文档中建立父子关系。

Returns child documents joined to a specific parent document. You can use a join field mapping to create parent-child relationships between documents in the same index.

parent_id query 官方文档的介绍

• type：（必须）join 类型字段定义的子关系

• id：（必须）父文档的id

• ignore_unmapped：如果 type 没有匹配到，选择返回空内容还是返回一个错误。默认 false

  • true：返回空内容

  • false：返回一个错误

e.g.

GET my-index-000001/_search
{
  "query": {
    "parent_id": {
      "type": "answer",
      "id": 1
    }
  }
}