elasticsearch之嵌套对象、父子文档_es嵌套对象

一，嵌套对象

es并非关系型数据库，它并不擅长关系型数据库的join操作。在存储数据时，用冗余数据替代查询时的关联。

如blog和comments，如果用关系型数据库，会将blog存一个表，comments存另一个表，然后将这两个表关联起来。

在es中可以这样存储：

PUT /nested_index/_doc/1
{
  "title": "Nest eggs",
  "body":  "Making your money work...",
  "tags":  [ "cash", "shares" ],
  "comments": [ 
    {
      "name":    "John Smith",
      "comment": "Great article",
      "age":     28,
      "stars":   4,
      "date":    "2014-09-01"
    },
    {
      "name":    "Alice White",
      "comment": "More like this please",
      "age":     31,
      "stars":   5,
      "date":    "2014-10-22"
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

查询时就很高效，一次把文档和关联的信息查出来。

不过，在用es查询时，可能出现一些意外情况：

GET nested_index/_search
{
  
  "query": {
         "bool": {
            "must": [
              {
                "match": {
                  "comments.name": "john"
                }
              },
              {
                "match": {
                  "comments.age": "31"
                }
              }
            ]
          }
      }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

本来，根据john+31是不应该查出数据的，因为john是28岁，实际上却能查出来结果。

原因在于es存储object对象时会将对象扁平化处理：

{
   "blog":"aking your money work...",
   "comments.name":["john","alice"],
   "comments.age":[31,28]
}
1
2
3
4
5

这样子，就失去了边界，两个comments就区分不了了。

这种情况下，可以用到嵌套对象，嵌套对象的mapping不能动态创建，必须在索引文档之前创建。

PUT /nested_index2
{
  "mappings": {
    "properties": {
      "comments":{
        "type": "nested"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10

再次查询

GET nested_index2/_search
{
  
  "query": {
    "nested": {
      "path": "comments",
      "query": {
         "bool": {
            "must": [
              {
                "match": {
                  "comments.name": "john"
                }
              },
              {
                "match": {
                  "comments.age": "31"
                }
              }
            ]
          }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这时查询31岁的john就不会有结果了，把条件age改成28就可以了。

原理就是对于nested对象，es会将其抽取出来作为独立的文档，并保留文档之间的关联关系，在查询时，把相应文档关联起来。

二，父子文档

可以把结构相同但有父子关系的文档存储在同一个索引中，在形式上父子文档都是独立的文档，互相之间的修改、更新都是独立的，在逻辑上二者是有层次关系的。

1，设置mapping，设置一个field用于识别父子关系的key，这个field的类型时join，relations用来指明父子关系：answer是子文档，question是父文档。

PUT join_index
{
  "mappings": {
    "properties": {
      "my_join_field": { 
        "type": "join",
        "relations": {
          "question": "answer" 
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2，插入父文档时要指明文档类型

PUT join_index/_doc/1?refresh
{
  "text": "This is a question",
  "my_join_field": {
    "name": "question" 
  }
}

PUT join_index/_doc/2?refresh
{
  "text": "This is another question",
  "my_join_field": {
    "name": "question"
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3，插入子文档时用routing关键字，指明文档类型和父文档id

PUT join_index/_doc/3?routing=1&refresh
{
  "text": "This is an answer",
  "my_join_field": {
    "name": "answer", 
    "parent": "1" 
  }
}

PUT join_index/_doc/4?routing=1&refresh
{
  "text": "This is another answer",
  "my_join_field": {
    "name": "answer",
    "parent": "1"
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4，根据父文档id查所有子文档

GET join_index/_search
{
  "query": {
    "parent_id":{
      "type":"answer",
      "id":"1"
    }
  }
}
1
2
3
4
5
6
7
8
9

5，根据父文档内容查询所有子文档

GET join_index/_search
{
  "query": {
    "has_parent": {
      "parent_type": "question",
      "query": {
        "match": {
          "text": "question"
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

6，根据子文档内容查询所有父文档

GET join_index/_search
{
  "query": {
    "has_child": {
      "type": "answer",
      "query": {
        "match": {
          "text": "answer"
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13