python操作es查询

发表于 | 更新于 | 分类于 | 阅读次数：

#es查询相关

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
aggs聚合中terms和cardinality的区别:
    terms:聚合分组，类似于sql中group by，结果为每个单位出现的次数，需要给定size值，不然默认最大为10
    举例:
    "aggs": {
    "classid": {
      "terms": {
        "field": "classid",
        "size": 10
      }
    }
  	}    
    返回结果为classid去重后对应每个classid出现的次数
        
    cardinality: 去重，类似于sql中distinct ,结果为单位数量，
    举例:
    "aggs": {
        "classid": {
          "cardinality": {
            "field": "classid"
          }
        }
      }	
	返回结果为classid去重后的个数

–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
query==match==query实现模糊查询        分词查询含有的会被找出(如下含有学校或者公司的会被找出)===自动分词或者自己设计
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "match": {
                                 'applicant_address_other': {
                                     'query':'公司'
                                 },
                                 #  检索条件
                             },
#                              'match':{
#                                  'app_text':'CN01316971'
#                              }
                         }
                     },
                        filter_path=[
                               'hits.hits._source.applicant_address_other',
                                'hits.hits._source.app_text',
                            'hits.hits._source.applicant_other'
                           ],
                                          # 数据量
                        size=10
                     )
result_list

–match_phrase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
query==match_phase_query 必须符合全部分词才会被找出来添加slop可以放宽条件
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "match_phrase": {
                                     'applicant_address_other': {
                                     'query':'山东学校',
                                         'slop': 1
                                         
                                 },         #  检索条件
                                 
                                 
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                                'hits.hits._source.app_text',
                           ],                    # 数据量
                     )
result_list

–multi_match–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
multi_match 多字段匹配其中一个满足即可========也是自动分词
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "multi_match": {
                                     'query':'山东电学校',
                                     'fields':['applicant_address_other','applicant_other']
                                 ,         #  检索条件
                                 
                                 
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],                    # 数据量
                     )
result_list

–term–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
term表示完全匹配不会经过分词器
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "term": {
                                     'applicant_other.keyword':'山东省电力学校',         
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],                    # 数据量
                     )
result_list

–terms–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
terms多条件精准匹配
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "terms": {
                                     'applicant_other.keyword':['孙向柔','吕百顺'],         
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],
                        size=1000# 数据量
                     )
result_list

–bool filter–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
bool====filter双重过滤(相当于mysql中的where)
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {'bool':{
                             'must':{"match": {
                                     'applicant_other.keyword':'吕百顺'        
                             }},

                              'filter':{
                                  'match':{
                                          'app_text':'CN89215264'
                                      
                                  }
                              }
                         }}},
                     filter_path=['hits.hits._source.applicant_other']
                            
                             
                         
                                       
                     )
result_list

–prefix–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
prefix以什么指定开头
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "prefix": {
                                     'applicant_other.keyword':'三江瓦力',         
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],
                        size=1000# 数据量
                     )
result_list

–regexp–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
正则表达式检索
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "regexp": {
                                     'applicant_other.keyword':'C.*',         
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],
                        size=4000# 数据量
                     )
result_list

–wildcard–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
通配符查询(?和*)
result_list = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "wildcard": {
                                     'applicant_other.keyword':'CDT??有限公司',         
                             }
                         }
                     },
                       filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                           ],
                        size=4000# 数据量
                     )
result_list

–聚合查询–(avg\sum\min\max\stats)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
result_list = es.search(index=['patent_cn_v7'],
                     body={'size':0,
                         "query": {
                             "match_all": { }
                         }
                     ,
                     'aggs':{
                         'agg_terms':{
                              'stats':{
                             'field':'country_id'
                         }   
                         }
                     }
                     }
                     )
result_list

–聚合分组–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
result_list = es.search(index=['patent_cn_v7'],
                     body={'size':0,
                         "query": {
                             "match": {'applicant_other':'CJ第一制糖株式会社' }
                         }
                     ,
                           #分组
                     'aggs':{
                         'agg_terms':{
                              'terms':{
                             'field':'ipcr_text'
                         }   
                         }
                     }
                     }
                     )
result_list

–聚合分组后计算–

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

result_list = es.search(index=['patent_cn_v7'],
                     body={'size':0,
                         "query": {
                             "match": {'applicant_other':'CJ第一制糖株式会社' }
                         }
                     ,
                           #分组
                     'aggs':{
                         'agg_terms':{
                              'terms':{
                             'field':'ipcr_text'
                         },
                             'aggs':{
                                 'avg_id':{
                                     'stats':{
                                         'field':'country_id'
                                     }
                                 }
                             }
                         }
                     }
                     }
                     )
result_list

—返回聚合分组后的某一组数据(post_filter)—

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
返回聚合分组后的某一组数据(post_filter)
result = es.search(index=['patent_cn_v71'],body={
        'query':{
        'match_all':{}
                
        },
        'aggs':{
            'ipcr':{
                    'terms':{
                        'field': "applicant_type"
                },
                
            }
        },
    'post_filter':{
        'term':{'applicant_type':'individual'}
    }
},
                  filter_path=['hits.hits._source.app_text'])
result

—聚合嵌套-(注意写的位置)–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
result = es.search(index=['patent_cn_v71'],body={
        'query':{
        'match_all':{}
                
        },
        'aggs':{
            'ipcr':{
                    'terms':{
                        'field':'ipcr_text'

                },
                'aggs':{
                    'ipcrs':{
                        'terms':{
                            'field':'ipcr_text'
                        }
                    }
                }
            }
        }
        
})
result

—聚合返回拼接字段聚合(script)—

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
result = es.search(index=['patent_cn_v71'],body={
    'query':{
        'match_all':{}
    },
    'aggs':{
        'kl':{
            'terms':{
                'script':{
                    'inline':"doc['app_country'].value+' '+doc['app_date'].value+' '+doc['id'].value",
                }, 'size':'1000'
            }
        }
    }
})
result

–聚合结果排序–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
result = es.search(index=['patent_cn_v71'],body={
            'query':{
                    'match_all': {}
            }
            ,
            'aggs':{
                'company_name':{
                    'terms':{
                        'field':'ipcr_text',
                        'order':[{
                            '_count':'asc'
                        }]
                    }
                },
                
            }
        }
            )
result

–对聚合结果排序顺序倒叙–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
result = es.search(index=['patent_us_v71'],body={'size':0,
            'query':{
                    'match_all': {}
            }
            ,
            'aggs':{
                'company_name':{
                    'terms':{
                        'field':'app_text',
                        'order':[{
                            '_count':'desc'
                        }]
                    ,
                    'size':'200000'}
                },
                
            }
        }
            )
result

–nested嵌套查询–

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
#例1
es = Elasticsearch(hosts={'192.168.0.220', '192.168.0.225', '192.168.0.221', }, timeout=3600)
result_2 = es.search(index='patent_cn_v71',

                     body={
                         "query": {
                         "bool": {
                             "must": [
                                 {"terms": {"patent_type": [1, 2]}},
                                 {
                                     "nested": {
                                         "path": "applicants",
                                         "query": {
                                             "bool": {
                                                 "must": [
                                                     {"term": {
                                                         "applicants.name_other.keyword": '宝洁公司'}},
                                                 ]
                                             }
                                         }

                                     }}
                             ]
                         }},
                         #三层三次聚合,一次进里面.二次再进一步,三次进入到inventors中
                         "aggs": {
                             "aggs": {
                                 "aggs": {"de_inventor": {
                                     "terms": {"field": "inventors.name_other.keyword", "size": 200000}}},
                                 "nested": {"path": "inventors"}
                             }
                         }
                     },
                     )
result2_list
#例2
result_2 = es.search(index=['patent_cn_v7'],
                     body={
                         "query": {
                             "nested": {
                                         "path": "applicants",
                                 'query':{
                                     'term':{
                                          'applicants.name_other.keyword': 'CJ第一制糖株式会社',
                                     }
                                       
                                 },
                             
                             }
                    
                             },
                        "aggs": {
                             "aggs": {
                                 "aggs": {"de_inventor": {
                                     "terms": {"field": "inventors.name_other.keyword", "size": 200000}}},
                                 "nested": {"path": "inventors"}
                             }
                         }
                     }
                     )
result_2['aggregations']['aggs']

–复合查询bool–

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
result = es.search(index = ['patent_cn_v7'],
                   body={
                        'query':{
                            'bool':{
                                'must':[{
                                   'term':{
                                             'applicant_other.keyword':'孙长友'
                                             }
                                                         }
                                ],
                                'must_not':
                                    {
                                        'term':{
                                            'app_text':'CN201320765434'
                                        },
                                        
                                    },
                               
                            }
                        }
                    },
                   filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                   ],
                   size=10)
result

–切片式查询from size–

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
result = es.search(index = ['patent_cn_v7'],
                   body={
                        'query':{
                            'bool':{
                                'must':[{
                                   'term':{
                                             'applicant_other.keyword':'孙长友'
                                             }
                                                         }
                                ],
                                'must_not':
                                    {
                                        'term':{
                                            'app_text':'CN201320765434'
                                        },
                                        
                                    },
                               
                            }
                        }
                    },
                   filter_path=[
                               'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                                'hits.hits._source.app_text',
                   ],
                   size=10)
result

–范围查询range–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
result  = es.search(index = ['patent_cn_v7'],body={
    'query':{
        'range':{
            'id':{
                'gte':1000,
                'lte':10000
            }
        }
    }
},
    filter_path = [
                         'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                            'hits.hits._source.app_text',
                        'hits.hits._source.id',
                   ],
                   )

–sort排序–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
result= es.search(index=['patent_cn_v7'],
                 body={
                     'query':{
                         'match_all':{}
                     },
                     'sort':{
                         'app_text':{
                             'order':'asc'
                         }
                     }
                 },
                  filter_path=[
                         'hits.hits._source.applicant_address_other',
                           'hits.hits._source.applicant_other',
                            'hits.hits._source.app_text',
                        'hits.hits._source.id',
                   ])

–keyword与text的区别是分词与不分词的区别

1
2
3
4
5
6
7
8
9
10
11
12
result = es.search(index=['patent_cn_v71'],body={
                  'query':{
                      'nested':{
                          'path':'applicants',
                          'query':{
                              'term':{
                                  'applicants.name_en.keyword':'ELECTROLUX APPLIANCES'
                              }
                          }
                      }
                  }})
result

–count–获取匹配到的数量

1
2
3
4
5
6
7
8
9
result = es.count(index=['patent_cn_v7'],
                 body={
                     'query':{
                         'match':{
                                 'applicant_other.keyword':'蒋子刚'  
                         }

                     }
                 })

–es_scroll进行深度分页you表获取内容–

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# list1 = []
result = es.search(index=['patent_cn_v71'],body=
     {
         'query':{
             'match_all':{}
         },
         'sort':{
             'app_text':'asc'
         }
     },scroll='1m',size=10)
mdata = result.get("hits").get("hits")
scroll_id = result["_scroll_id"]
total = result["hits"]["total"]
j = 1
for i in range(total//100):
    res = es.scroll(scroll_id=scroll_id, scroll='1m') #scroll参数必须指定否则会报错
    mdata += res["hits"]["hits"]
    if j==2:
        break
    j+=1
for  result in mdata:
    print(result['_source']['app_text'])

–是否存在某个字段exists–

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
#方法1
result = es.search(index=['patent_cn_v7'],
                  body={
                      'query':{
                          'exists':{
                              'field':'applicant_other'
                          }
                      }}    
                  )
#方法2
es.search(index=['patent_jp_v71'],
                     body={
                         "query": {
                             "bool":{
                                 "must_not":{
                                     "nested":{
                                         "path": "prime_notified",
                                             "query":{
                                                     "match_all":{}
                                                         }}}
                                             }
                             },
#                          'aggs':{
#                          'agg_terms':{
#                               'terms':{
#                              'field':'app_date',
#                                   'size':'10000'
#                          } }}

                     } ,filter_path=['hits.total',
              'hits.hits._source.app_text'],size=300)
#方法3
es.search(index=['patent_jp_v71'],
                     body={
                         "query": {
                             "nested": {
                                         "path": "inventors",
                                 'query':{
                                        "bool":{
                                            'must':[
                                        {
                                        'exists':{
                                            'field':'inventors.name_other'
                                        }},
                                                 {
                                        'exists':{
                                            'field':'inventors.name_en'
                                        }},
                                          ]
                                        }
                                       
                                 },
                             
                             }
                             },
#                         "aggs": {
#                              "aggs": {
#                                  "aggs": {"de_inventor": {
#                                      "terms": {"field": "inventors.name_other.keyword", "size": 200000}}},
#                                  "nested": {"path": "inventors"}
#                              }
#                          }
                     }
                     ,filter_path=['hits.total',
              'hits.hits._source.app_text'],size=300)

–深度理解filter–

1
2
3
4
5
6
7
8
9
10
result = es.search(index=['patent_cn_v71'],
                  body={
                          'query':{
                              
                          'bool':{'must':{'term':{'id':'17640553'}},
                                        'filter':{'term':{'applicant_other.keyword':'王永民'}}
                                }
                       }},
                  filter_path=['hits.hits._source.app_text'])
print(result)

–案例一filter放在bool下的等级等同于must

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import time
s1 = time.time()
result = es.search(index=['patent_cn_v71'],
                  body={
                      'query':{
                           'bool':{
                        'must':{'match':{'applicant_address_other':{'query':'北京市'}}},
                        'filter':{'term':{'applicant_other.keyword':'王永民'}}
                    }
                      }
                   
                  },
                  filter_path =['hits.hits._source.app_text'])
print(result)
print(time.time()-s1)

filter常与bool一起使用,等级同must(里面要加match\term之类的)

1
2
3
4
5
6
7
8
9
10
11
12
result = es.search(index=['patent_cn_v71'],
                  body={
                      'query':{
                           'bool':{
                               'filter':{'term':{'applicant_other.keyword':'王永民'}},
                         'must':{'match':{'applicant_address_other':{'query':'北京市'}}},
                        
                    }
                      } 
                  },
                  filter_path =['hits.hits._source.app_text'])
print(result)
1
2
3
4
5
6
7
注意事项:
	1.中文只能通过关键字查询
	2.match会系统自动分词,而term表示完全匹配不进行分词
	3.match对应模糊查找,term对应精确查找
	4.gte大于等于 gt大于 lte小于等于 lt小于
	5.terms表示符合其中任意一个条件即可
分词:如我是中国人 会分成我 中国人类似,可以使用系统默认的亦可以自己设置