15-GuliMall ElasticSearch复杂检索

官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html

1.导入测试数据

测试数据点击下载

将文本文件中的内容直接复制粘贴到Kibana控制台, 执行命令,导入数据

2.SearchAPI

ES 支持两种基本方式检索 :

• 一个是通过使用 REST request URI 发送搜索参数（uri+检索参数）
• 另一个是通过使用 REST request body 来发送它们（uri+请求体）

下面分别使用两种方式检索 bank 下所有信息，包括 type 和 docs
1.uri+检索参数

GET bank/_search?q=*&sort=account_number:asc
1

响应数据

{
  "took" : 161,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1000,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "bank",
        "_type" : "account",
        "_id" : "0",
        "_score" : null,
        "_source" : {
          "account_number" : 0,
          "balance" : 16623,
          "firstname" : "Bradshaw",
          "lastname" : "Mckenzie",
          "age" : 29,
          "gender" : "F",
          "address" : "244 Columbus Place",
          "employer" : "Euron",
          "email" : "bradshawmckenzie@euron.com",
          "city" : "Hobucken",
          "state" : "CO"
        },
        "sort" : [
          0
        ]
      },
      {
        "_index" : "bank",
        "_type" : "account",
        "_id" : "1",
        "_score" : null,
        "_source" : {
          "account_number" : 1,
          "balance" : 39225,
          "firstname" : "Amber",
          "lastname" : "Duke",
          "age" : 32,
          "gender" : "M",
          "address" : "880 Holmes Lane",
          "employer" : "Pyrami",
          "email" : "amberduke@pyrami.com",
          "city" : "Brogan",
          "state" : "IL"
        },
        "sort" : [
          1
        ]
      },
      //后面省略...
   }
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
59
60
61
62

响应结果解释： 
took - Elasticsearch 执行搜索的时间（毫秒） 
time_out - 告诉我们搜索是否超时 
_shards - 告诉我们多少个分片被搜索了，以及统计了成功/失败的搜索分片 
hits - 搜索结果 
hits.total - 搜索结果 
hits.hits - 实际的搜索结果数组（默认为前 10 的文档） 
sort - 结果的排序 key（键）（没有则按 score 排序） 
score 和 max_score –相关性得分和最高得分（全文检索用）
1
2
3
4
5
6
7
8
9

2.uri+请求体进行检索

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

3.Query DSL

1.基本语法格式

Elasticsearch 提供了一个可以执行查询的 Json 风格的 DSL（domain-specific language 领域特 定语言）。这个被称为 Query DSL。该查询语言非常全面，并且刚开始的时候感觉有点复杂， 真正学好它的方法是从一些基础的示例开始的。

• 一个查询语句的典型结构

{ 
  QUERY_NAME: 
  { 
    ARGUMENT: VALUE, 
    ARGUMENT: VALUE,
    ... 
  }  
}
1
2
3
4
5
6
7
8

• 如果是针对某个字段，那么它的结构如下：

{ 
  QUERY_NAME: 
  { 
    FIELD_NAME: 
    { 
      ARGUMENT: VALUE, 
      ARGUMENT: VALUE,
      ... 
    } 
  } 
}
1
2
3
4
5
6
7
8
9
10
11

例子:

GET bank/_search 
{ 
  "query": 
  { 
    "match_all": {} 
  },
  "from": 0, 
  "size": 5, 
  "sort": 
  [ 
    { 
      "account_number":
      { 
        "order": "desc" 
      } 
    } 
  ] 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.query 定义如何查询，
2.match_all 查询类型【代表查询所有的所有】，es 中可以在 query 中组合非常多的查询类型完成复杂查询 
3.除了 query 参数之外，我们也可以传递其它的参数以改变查询结果。如 sort，size 
4.from+size 限定，完成分页功能
5.sort 排序，多字段排序，会在前序字段相等时后续字段内部排序，否则以前序为准
1
2
3
4
5

2.查询部分字段

只查询age和balance字段

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5,
  "_source": [
    "age",
    "balance"
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12

3.match匹配查询

1.match 返回 account_number=20 的

GET bank/_search
{
  "query": {
    "match": {
      "account_number": "20"
    }
  }
}
1
2
3
4
5
6
7
8

2.字符串，全文检索

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  }
}
1
2
3
4
5
6
7
8

响应数据

最终查询出 address 中包含 mill 单词的所有记录
match 当搜索字符串类型的时候，会进行全文检索，并且每条记录有相关性得分。

3.字符串，多个单词（分词+全文检索）

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill road"
    }
  }
}
1
2
3
4
5
6
7
8

响应数据

最终查询出 address 中包含 mill 或者 road 或者 mill road 的所有记录，并给出相关性得分

4.match_phrase短语匹配

将需要匹配的值当成一个整体单词（不分词）进行检索

查出 address 中包含 mill road 的所有记录，并给出相关性得分

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill road"
    }
  }
}
1
2
3
4
5
6
7
8

响应数据

5.multi_match多字段匹配

state 或者 address 包含 mill

GET bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill",
      "fields": [
        "state",
        "address"
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

6.bool复合查询

bool 用来做复合查询： 复合语句可以合并任何其它查询语句，包括复合语句，了解这一点是很重要的。这就意味 着，复合语句之间可以互相嵌套，可以表达非常复杂的逻辑.

1.must：必须达到 must 列举的所有条件

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        },
        {
          "match": {
            "gender": "M"
          }
        }
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.should：应该达到 should 列举的条件，如果达到会增加相关文档的评分，并不会改变查询的结果。如果 query 中只有 should 且只有一种匹配规则，那么 should 的条件就会被作为默认匹配条件而去改变查询结果.

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        },
        {
          "match": {
            "gender": "M"
          }
        }
      ],
      "should": [
        {
          "match": {
            "address": "lane"
          }
        }
      ]
    }
  }
}
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

3.must_not 必须不是指定的情况

address 包含 mill，并且 gender 是 M，如果 address 里面有 lane 最好不过，但是 email 必 须不包含 baluba.com

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        },
        {
          "match": {
            "gender": "M"
          }
        }
      ],
      "should": [
        {
          "match": {
            "address": "lane"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "email": "baluba.com"
          }
        }
      ]
    }
  }
}
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

7.filter结果过滤

并不是所有的查询都需要产生分数，特别是那些仅用于 “filtering”（过滤）的文档。为了不计算分数 Elasticsearch 会自动检查场景并且优化查询的执行。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "filter": {
        "range": {
          "balance": {
            "gte": 10000,
            "lte": 20000
          }
        }
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8.term

和match 一样。匹配某个属性的值。全文检索字段用 match，其他非 text 字段匹配用 term。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "age": {
              "value": "28"
            }
          }
        },
        {
          "match": {
            "address": "990 Mill Road"
          }
        }
      ]
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

9.aggregations执行聚合

聚合提供了从数据中分组和提取数据的能力。最简单的聚合方法大致等于 SQL GROUP BY 和 SQL 聚合函数。在 Elasticsearch 中，您有执行搜索返回 hits（命中结果），并且同时返 回聚合结果，把一个响应中的所有 hits（命中结果）分隔开的能力。这是非常强大且有效的， 您可以执行查询和多个聚合，并且在一次使用中得到各自的（任何一个的）返回结果，使用 一次简洁和简化的 API 来避免网络往返。

size：0 不显示搜索数据 aggs：执行聚合。聚合语法如下 
"aggs": 
{ 
	"aggs_name 这次聚合的名字，方便展示在结果集中": 
	{ 
		"AGG_TYPE 聚合的类型（avg,term,terms）": {} 
	} 
},
1
2
3
4
5
6
7
8

1.搜索 address 中包含 mill 的所有人的年龄分布以及平均年龄，但不显示这些人的详情。

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "aggs": {
    "group_by_state": {
      "terms": {
        "field": "age"
      }
    },
    "avg_age": {
      "avg": {
        "field": "age"
      }
    }
  },
  "size": 0
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

响应数据

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "avg_age" : {
      "value" : 34.0
    },
    "group_by_state" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 38,
          "doc_count" : 2
        },
        {
          "key" : 28,
          "doc_count" : 1
        },
        {
          "key" : 32,
          "doc_count" : 1
        }
      ]
    }
  }
}

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

2.按照年龄聚合，并且请求这些年龄段的这些人的平均薪资

GET bank/account/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_avg": {
      "terms": {
        "field": "age",
        "size": 1000
      },
      "aggs": {
        "banlances_avg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 1000
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.查出所有年龄分布，并且这些年龄段中 M 的平均薪资和 F 的平均薪资以及这个年龄 段的总体平均薪资

GET bank/account/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_agg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "gender_agg": {
          "terms": {
            "field": "gender.keyword",
            "size": 100
          },
          "aggs": {
            "balance_avg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "balance_avg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 1000
}
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

4.Mapping

1.字段类型

2.映射

Mapping 是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和 索引的。

比如，使用 mapping 来定义：

1.哪些字符串属性应该被看做全文本属性（full text fields）。 
2.哪些属性包含数字，日期或者地理位置。 
3.文档中的所有属性是否都能被索引（_all 配置）。 
4.日期的格式。 
5.自定义映射规则来执行动态添加属性。
1
2
3
4
5

查看 mapping 信息

GET bank/_mapping
1

3.测试

1.创建索引并指定映射

PUT /my-index
{
  "mappings": {
    "properties": {
      "age": {
        "type": "integer"
      },
      "email": {
        "type": "keyword"
      },
      "name": {
        "type": "text"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.添加新的字段映射

PUT /my-index/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false
    }
  }
}
1
2
3
4
5
6
7
8
9

3.更新映射
对于已经存在的映射字段，我们不能更新。更新必须创建新的索引进行数据迁移

4.数据迁移
先创建出 new_twitter 的正确映射。然后使用如下方式进行数据迁移

POST _reindex
{
  "source": {
    "index": "twitter"
  },
  "dest": {
    "index": "new_twitter"
  }
}
1
2
3
4
5
6
7
8
9

将旧索引的 type 下的数据进行迁移

POST _reindex
{
  "source": {
    "index": "twitter",
    "type": "tweet"
  },
  "dest": {
    "index": "tweets"
  }
}
1
2
3
4
5
6
7
8
9
10