Elasticserch与Elasticsearch_dsl用法
Elasticserch与Elasticsearch_dsl用法
Elasticsearch_dsl:：https://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html
Elasticserch：https://elasticsearch-py.readthedocs.io/en/master/api.html
1. 连接
from elasticsearch import Elasticsearch
es = Elasticsearch(hosts="127.0.0.1:9200")
# connections可以设置多个集群
from elasticsearch_dsl import connections
es = connections.create_connection(hosts=['localhost:9200'], timeout=60)
2. 查询
from elasticsearch import Elasticsearch
from elasticsearch_dsl import Search
client = Elasticsearch()
s = Search(using=client)
API是可链接的，允许在一个语句中组合多个方法调用：
s = Search().using(client).query("match", title="python")
要将请求发送到Elasticsearch：
response = s.params(size=10000).execute()
# params(size) 为指定搜索结果返回条数，默认size是10，最大size为10000
如果只想迭代搜索返回的命中，可以遍历该Search对象：
for hit in s:
print(hit.title)
搜索结果将被缓存。后续调用execute或尝试迭代已执行的Search对象不会触发发送到Elasticsearch的其他请求。强制请求指定 ignore_cache=True何时调用execute。
出于调试目的，可以将Search对象序列化为dict 显式：
s = Search().using(client).query("match", title="python")
print(s.to_dict())
按查询删除
可以通过调用对象来删除与搜索匹配的文档delete，Search而不是 execute像这样：
s = Search(index='i').query("match", title="python")
response = s.delete()
2.1 Q
from elasticsearch_dsl import Q
Q("multi_match", query='python django', fields=['title', 'body'])
Q({"multi_match": {"query": "python django", "fields": ["title", "body"]}})
要将查询添加到Search对象，使用.query()方法：
q = Q("multi_match", query='python django', fields=['title', 'body'])
s = Search().query(q)
该方法还接受所有参数作为Q快捷方式：
s = s.query("multi_match", query='python django', fields=['title', 'body'])
如果已有查询对象或dict表示查询对象，则可以覆盖Search对象中使用的查询：
s.query = Q('bool', must=[Q('match', title='python'), Q('match', body='best')])
2.2 虚线字段
有时想要引用另一个字段中的字段，可以是多字段（title.keyword），也可以是结构化json文档address.city。为了更方便的Q快捷方式（还有 query，filter以及exclude对方法Search的类），可以使用__（双下划线）代替关键字参数点的：
s = Search()
s = s.filter('term', category__keyword='Python')
s = s.query('match', address__city='prague')
或者：
s = Search()
s = s.filter('term', **{'category.keyword': 'Python'})
s = s.query('match', **{'address.city': 'prague'})
2.3 查询组合
可以使用逻辑运算符组合查询对象：
Q("match", title='python') | Q("match", title='django')
# {"bool": {"should": [...]}}
Q("match", title='python') & Q("match", title='django')
# {"bool": {"must": [...]}}
~Q("match", title="python")
# {"bool": {"must_not": [...]}}
当.query()多次调用该方法时，&将在内部使用该运算符：
s = s.query().query()
print(s.to_dict())
# {"query": {"bool": {...}}}
如果要对查询表单进行精确控制，使用Q快捷方式直接构造组合查询：
q = Q('bool',
must=[Q('match', title='python')],
should=[Q(...), Q(...)],
minimum_should_match=1
)
s = Search().query(q)
# start_time为开始时间，end_time为结束时间
q = Q('bool', must=[Q('range', start_time={"gte": start_time}), Q('range', end_time={"lte": end_time})])
s = Search().query(q)
2.4 过滤器
如果要在Search之后添加查询， 可以使用该filter()方法使事情变得更容易：
s = Search()
s = s.filter('terms', tags=['search', 'python'])
# 过滤，在此为范围过滤，range是方法，timestamp是所要查询的field的名字，gte意为大于等于，lt意为小于，根据需要设定即可(似乎过滤只能接受数字形式的内容，如果是文本就会返回空)
# 关于term和match的区别，term是精确匹配，match会模糊化，会进行分词，返回匹配度分数，（term查询字符串之接受小写字母，如果有大写会返回空即没有命中，match则是不区分大小写都可以进行查询，返回结果也一样）
例1:范围查询
s = s.filter("range", timestamp={"gte": 0, "lt": time.time()}).query("match", country="in")
例2:普通过滤
res_3 = s.filter("terms", balance_num=["39225", "5686"]).execute()
在幕后，这将生成一个Bool查询并将指定的 terms查询放入其filter分支，使其等效于：
s = Search()
s = s.query('bool', filter=[Q('terms', tags=['search', 'python'])])
如果要将post_filter元素用于分面导航，请使用该 .post_filter()方法。
exclude()可以查询查询中的项目，如下所示：
s = Search()
s = s.exclude('terms', tags=['search', 'python'])
这是简写： s = s.query('bool', filter=[~Q('terms', tags=['search', 'python'])])
2.5 聚合
聚合可以放在查询，过滤等操作的后面叠加，需要加aggs
要定义聚合，可以使用A快捷方式：
from elasticsearch_dsl import A
A('terms', field='tags')
# {"terms": {"field": "tags"}}
也可以使用.bucket()，.metric()和 .pipeline()方法
bucket即为分组，其中第一个参数是分组的名字，自己指定即可，第二个参数是方法，第三个是指定的field。
metric也是同样，metric的方法有sum、avg、max、min等等，但是需要指出的是有两个方法可以一次性返回这些值，stats和extended_stats，后者还可以返回方差等值。
a = A('terms', field='category')
# {'terms': {'field': 'category'}}
a.metric('clicks_per_category', 'sum', field='clicks').bucket('tags_per_category', 'terms', field='tags')
# {
# 'terms': {'field': 'category'},
# 'aggs': {
# 'clicks_per_category': {'sum': {'field': 'clicks'}},
# 'tags_per_category': {'terms': {'field': 'tags'}}
# }
# }
# 例1
s.aggs.bucket("per_country", "terms", field="timestamp").metric("sum_click", "stats", field="click").metric("sum_request", "stats", field="request")
# 例2
s.aggs.bucket("per_age", "terms", field="click.keyword").metric("sum_click", "stats", field="click")
# 例3
s.aggs.metric("sum_age", "extended_stats", field="age")
# 例4
s.aggs.bucket("per_age", "terms", field="country.keyword")
# 最后依然是要execute，此处注意s.aggs的操作不能用变量接收（如res=s.aggs的操作就是错误的），聚合的结果会在res中显示
# 例5
a = A("range", field="account_number", ranges=[{"to": 10}, {"from": 11, "to": 21}])
res = s.execute()
要向Search对象添加聚合，请使用.aggs属性作为顶级聚合：
s = Search()
a = A('terms', field='category')
s.aggs.bucket('category_terms', a)
# {
# 'aggs': {
# 'category_terms': {
# 'terms': {
# 'field': 'category'
# }
# }
# }
# }
要么
s = Search()
s.aggs.bucket('articles_per_day', 'date_histogram', field='publish_date', interval='day')\
.metric('clicks_per_day', 'sum', field='clicks')\
.pipeline('moving_click_average', 'moving_avg', buckets_path='clicks_per_day')\
.bucket('tags_per_day', 'terms', field='tags')
s.to_dict()
# {
# "aggs": {
# "articles_per_day": {
# "date_histogram": { "interval": "day", "field": "publish_date" },
# "aggs": {
# "clicks_per_day": { "sum": { "field": "clicks" } },
# "moving_click_average": { "moving_avg": { "buckets_path": "clicks_per_day" } },
# "tags_per_day": { "terms": { "field": "tags" } }
# }
# }
# }
# }
您可以按名称访问现有的key(类似字典的方式)：
s = Search()
s.aggs.bucket('per_category', 'terms', field='category')
s.aggs['per_category'].metric('clicks_per_category', 'sum', field='clicks')
s.aggs['per_category'].bucket('tags_per_category', 'terms', field='tags')
3.删除
es.delete(index='xxx', doc_type='xxx', id='xxx')
4.更新
body = {'doc': {}}
body['doc']['filed_name'] = '新的值'
es.update(index=_index, doc_type='alarm', id='xxx', body=body)
es.update(index='xxx', doc_type='xxx', id='xxx', body={待更新字段})