Elasticsearch 基本使用（二）简单查询 & 嵌套查询_es 嵌套查询

简单查询

按id查询单条记录

GET bank/_doc/1
1

查询所有数据

• 默认只查询10条记录

GET bank/_search
{
  "query": {
    "match_all": {}
  }
}
1
2
3
4
5
6

• 设置分页条件

GET bank/_search
{
  "query": {
  # 无条件查询
    "match_all": {}
  },
  # 偏移量，从第一条开始查
  "from": 0,
  # 记录条数
  "size": 1000
}
1
2
3
4
5
6
7
8
9
10
11

设置排序

两种设置方式

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "字段名": "asc"
    },
    {
      "字段名": {
        "order": "desc/asc"
      }
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意：_id 为字符串，其排序方式为按位比较，并非数值大小

filter 过滤

在 bool 查询内，可以使用 filter 对数据进行过滤。
单从最终数据来看，filter 也是用于过滤数据，用于条件查询。
不同点在于，filter 查询的结果不进行评分，但也不影响bool查询内其他查询的评分结果。

# 查询 age = 10 & province = 600 的数据
# 使用 filter 过滤，filter 仅过滤数据，而不进行评分，当然也不影响 使用 query 内其他查询的评分结果
GET /stu/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "nested": {
            "path": "address",
            "query": {
              "term": {
                "address.province": {
                  "value": "600"
                }
              }
            }
          }
        }
      ],
      "filter": [
        {
          "term": {
            "age": 10
          }
        }
      ]
    }
  }
}
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
26
27
28
29
30

查询数组内的值查询

ES没有数组一说，对数组值的查询就像普通值那样查询即可。
数组内其中一项匹配就算成功
terms：在多个条件值里面匹配，匹配上一个就算成功。
term：只能传一个条件值，不分词的字段值 或者 数组内某项字段值 或者 字段分词后的词典 匹配上这个值就算成功。
直接匹配数组字段，只要匹配上数组内任一项（或者关系）就算成功；
如果要同时匹配数组内多个值，可以使用bool must 对多个值进行（与关系匹配）

# 查询 hobbies 包含 swimming 或者 music 的数据
GET /stu/_search
{
  "query": {
    "terms": {
      "hobbies": [
        "movie",
        "music"
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

可以查到以下数据

      {
        "_index" : "stu",
        "_type" : "_doc",
        "_id" : "jjoE7YgBKFUjhQBi3mz1",
        "_score" : 1.0,
        "_source" : {
          "id" : 2,
          "name" : "李四",
          "age" : 20,
          "hobbies" : [
            "music",
            "speaking",
            "drive"
          ],
          "address" : [
            {
              "province" : "500",
              "city" : "025",
              "county" : "1993"
            },
            {
              "province" : "502",
              "city" : "027",
              "county" : "1999"
            }
          ]
        }
      },
      {
        "_index" : "stu",
        "_type" : "_doc",
        "_id" : "jzoE7YgBKFUjhQBi_2zu",
        "_score" : 1.0,
        "_source" : {
          "id" : 3,
          "name" : "张三四",
          "age" : 30,
          "hobbies" : [
            "movie",
            "book",
            "swimming"
          ],
          "address" : [
            {
              "province" : "600",
              "city" : "021",
              "county" : "1887"
            },
            {
              "province" : "601",
              "city" : "073",
              "county" : "1953"
            }
          ]
        }
      }
    
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

嵌套查询

有时，我们查询的条件字段不在最外层；此时需要使用嵌套查询

• 如果多个条件是在一个 nested 字段内，则可以在netsted 内的query 中使用 bool 查询
• 如果多个条件不在同一个 nested 字段内，则在外层query中使用 bool 查询

查询一个外层条件字段 内的嵌套字段

GET xxx_index/_search
{
  "query": {
  	# 嵌套查询，其他字段该怎么查怎么查，如果还有不属于这个嵌套字段的其他条件，依然使用 bool ，处理
    "nested": {
      "path": "外层字段名",
      # 基于这个path，当前的层级，再写一个 普通的query
      "query": {
        "bool": {
        	# 多条件
          "must": [
            {
              "term": {
                "外层字段名.内层字段名1": 条件值1
              }
            },
            {
              "match_phrase": {
                "外层字段名.内层字段名2": 条件值2
              }
            }
          ]
        }
      }
    }
  }
}
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
26
27

查询多个条件，其中有嵌套字段

# 一个嵌套字段 & 一个普通字段
GET xxx_index/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "nested": {
            "path": "外层字段名1",
            "query": {
              "term": {
                "外层字段名1.内层字段名1": 条件值1
              }
            }
          }
        },
        {
          "match": {
            "外层字段名2": " 条件值2"
          }
        }
      ]
    }
  }
}
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

如果还有，其他外层字段，依旧在 外层 bool 里面加条件。

自定义查询字段

返回指定字段

{
  "_source": [
    "字段名",
    "字段名.属性名",
    "字段名.*"
  ],
  "query": {
    xxxx
  }
}
1
2
3
4
5
6
7
8
9
10

或

{
  "_source": {
    "includes": [
      "字段名",
	  "字段名.属性名",
	  "字段名.*"
    ]
  },
  "query": {
    xxx
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

不显示字段

{
  "_source": false,
  "query": {
    xxxx
  }
}
1
2
3
4
5
6

排除指定字段

{
  "_source": {
    "exclude": [
      "字段名",
	  "字段名.属性名",
	  "字段名.*"
    ]
  },
  "query": {
    xxxx
  }
}
1
2
3
4
5
6
7
8
9
10
11
12