Elasticsearch篇：Elasticsearch增、删、改、查

目录

• 一、Elasticsearch的文档增删查改(CURD)
• 二、Elasticsearch之查询的两种方式
• 三、term与match查询
• 四、Elasticsearch之排序查询
• 五、Elasticsearch之分页查询
• 六、Elasticsearch之布尔查询
• 七、Elasticsearch之查询结果过滤
• 八、Elasticsearch之高亮查询
• 九、Elasticsearch之聚合函数
• 十、Elasticsearch for Python之连接

一、Elasticsearch的文档增删查改(CURD)

复制代码
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
# 增
PUT lqz/_doc/1
{
  "name":"顾老二",
  "age":30,
  "from": "gu",
  "desc": "皮肤黑、武器长、性格直",
  "tags": ["黑", "长", "直"]
}

# 删 
DELETE lqz/_doc/4
# 改
# 修改1:如果之前没有，就是新增，如果之前有，会使用新的覆盖掉旧的（新的字段少，少的字段会被删除）
PUT lqz/_doc/1
{
  "desc":"皮肤很黄，武器很长，性格很直",
  "tags":["很黄","很长", "很直"]
}

# 修改2---这个多
POST lqz/_doc/2/_update
{
  "doc": {
    "desc": "皮肤很黄，武器很长，性格很直",
    "tags": ["很黄","很长", "很直"]
  }
}

# 查（复杂）
# 根据id查,查单条
GET lqz/_doc/1

二、Elasticsearch之查询的两种方式

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 查询方式一：
GET lqz/_search?q=from:gu
GET lqz/_search?q=age:30


# 查询方式二：结构化查询，查询要放到query字典中，使用match查询，条件有且只有一个
GET lqz/_search
{
  "query": {
    "match": {
      "from": "gu"
    }
  }
}

三、term与match查询

复制代码
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
# term和match有什么区别？
	-match：进行搜索的时候，会先进行分词，分词完后，再来匹配，全文检索用它
    -term：term是代表完全匹配，也就是精确查询，搜索前不会再对搜索词进行分词
    -如果查的类型是keyword类型，用term比较好
    -如果全文检索，text类型，用match较好
    
    
# match_all：查询所有
GET lqz/_search
{
  "query": {
    "match_all": {
    }
  }
}


# 短语查询之match_phrase   中国和世界之间最多有2个字符
GET t1/_search
{
  "query": {
    "match_phrase": {
      "title": {
        "query": "中国世界",
        "slop": 2
      }
    }
  }
}

# 最左前缀match_phrase_prefix
-查询一bea开头的单词
GET t3/_search
{
  "query": {
    "match_phrase_prefix": {
      "desc": "bea"
    }
  }
}

四、Elasticsearch之排序查询

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
GET lqz/_search
{
  "query": {
    "match": {
      "from": "gu"
    }
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}


# 不是所有字段都可以排序，只有数字字段可以

五、Elasticsearch之分页查询

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
GET lqz/_search
{
  "query": {
    "match_all": {}
  },
    "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 2
}

六、Elasticsearch之布尔查询

复制代码
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
# 多个条件的查询
must（and）
should（or）
must_not（not）
filter

# and条件
GET lqz/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "age": "28"
          }
        }
      ]
    }
  }
}


## or条件
GET lqz/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "tags": "闭月"
          }
        }
      ]
    }
  }
}

# 取反
GET lqz/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "tags": "可爱"
          }
        },
        {
          "match": {
            "age": 18
          }
        }
      ]
    }
  }
}

# filter
GET lqz/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match_all": {
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "lte": 25
          }
        }
      }
    }
  }
}


# 小结
must：与关系，相当于关系型数据库中的and。
should：或关系，相当于关系型数据库中的or。
must_not：非关系，相当于关系型数据库中的not。

filter：过滤条件。
range：条件筛选范围。
gt：大于，相当于关系型数据库中的>。
gte：大于等于，相当于关系型数据库中的>=。
lt：小于，相当于关系型数据库中的<。
lte：小于等于，相当于关系型数据库中的<=。

七、Elasticsearch之查询结果过滤

复制代码
1
2
3
4
5
6
7
8
9
GET lqz/_search
{
  "query": {
    "match": {
      "name": "顾老二"
    }
  },
  "_source": ["name", "age"]
}

八、Elasticsearch之高亮查询

复制代码
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
# 基本使用
GET lqz/_search
{
  "query": {
    "match": {
      "name": "石头"
    }
  },
  "highlight": {
    "fields": {
      "name": {}
    }
  }
}


# 自定义高亮显示
GET lqz/_search
{
  "query": {
    "match": {
      "name": "石头"
    }
  },
  "highlight": {
    "pre_tags": "<b class='key' style='color:red'>",
    "post_tags": "</b>",
    "fields": {
      "name": {}
    }
  }
}

<b class='key' style='color:red'>石</b><b class='key' style='color:red'>头</b>

九、Elasticsearch之聚合函数

复制代码
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
# 聚合函数
avg
max
min
sum


GET lqz/_search
{
  "query": {
    "match_all": {
    }
  },
  "aggs": {
    "my_avg": {
      "sum": {
        "field": "age"
      }
    }
  }
}


# 分组
GET lqz/_search
{
  "size": 0, 
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_group": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "from": 15,
            "to": 20
          },
          {
            "from": 20,
            "to": 25
          },
          {
            "from": 25,
            "to": 30
          }
        ]
      }
    }
  }
}

十、Elasticsearch for Python之连接

复制代码
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
# import requests
#
# res=requests.get('http://localhost:9200/lqz/_doc/2').json()
# print(res['_source'])

# es官方提供的操作的包，es的客户端
from elasticsearch import Elasticsearch

# es是7版本，模块也要用7版本
obj = Elasticsearch(hosts=['http://127.0.0.1:9200', ])
# 创建索引（Index）
# result = obj.indices.create(index='user',ignore=[400, 404])
# result = obj.indices.delete(index='user', ignore=[400, 404])
# print(result)


# 插入数据
# data = {'userid': '1', 'username': 'lqz','password':'123'}
# result = obj.create(index='user1',id=2, document=data)
# print(result)
# 更新数据

# data = {'password': '888', 'test': '88'}
# result = obj.update(index='user1', doc=data, id=2)
# print(result)

# 删除数据
# result = obj.delete(index='user1',id=1)

# 查询
# 查找所有文档
# query = {'query': {'match_all': {}}}
#  查找名字叫做jack的所有文档
query = {'query': {'term': {'from': 'gu'}}}

# 查找年龄大于11的所有文档
# query = {'query': {'range': {'age': {'gt': 11}}}}
#
allDoc = obj.search(index='lqz', body=query)
# print(allDoc)
print(allDoc['hits']['hits'][0]['_source'])