ElasticSearch_DSL 使用方法合集(持续更新中......)

官方文档(7.4)：link

1. Search 方法

Search是一个核心类，用于创建和执行搜索查询。
下面是一些在Search类中常用的方法和属性：

1.1 query

用于指定查询的查询部分。它接受一个查询对象作为参数，例如Q对象或Bool对象。

1.2 filter：

用于指定查询的过滤部分。它接受一个过滤对象作为参数，例如F对象或Bool对象。

1.3 sort：

用于指定查询的排序部分。它接受一个或多个排序对象作为参数，例如S对象。

1.3 highlight：

用于指定查询的高亮部分。它接受一个高亮对象作为参数，例如H对象。

1.3 aggs(重点,请看第2章)：

用于指定查询的聚合部分。它接受一个或多个聚合对象作为参数，例如A对象。

1.4 slice：

用于指定查询的切片部分。它接受一个切片对象作为参数，例如Slice对象。

1.5 source：

用于指定查询的原始JSON字符串。它接受一个字符串作为参数。

1.6 extra：

用于指定额外的查询参数。它接受一个字典作为参数。

示例:

from elasticsearch import Elasticsearch  
from elasticsearch_dsl import Search, Q  
  
# 创建 Elasticsearch 客户端  
client = Elasticsearch(hosts=['localhost:9200']) 
  
# 创建一个搜索查询  
search_query = Search(using=client, index='my_index')\  
    .query(Q('match', title='Elasticsearch'))\  
    .filter('term', category='technology')\  
    .sort('relevance')\  
    .source(includes=['title', 'content'])  
  
# 执行搜索查询  
response = search_query.execute()  
# hits = response.hits.hits  
# for hit in hits:  
#     print(hit.title)
sliced_response = response.slice(start=0, size=10)  # 提取前10个结果
# 处理响应结果  
hits = sliced_response .hits.hits  
for hit in hits:  
    print(hit.title)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在上面的示例中，我们创建了一个搜索查询 search_query，该查询将在索引 my_index 中执行。我们使用了 query 方法来指定一个匹配查询，该查询将匹配标题中包含 “Elasticsearch” 的文档。然后，我们使用 filter 方法来添加一个过滤器，该过滤器将仅选择类别为 “technology” 的文档。最后，我们使用 sort 方法指定按相关性进行排序，并使用 source 方法指定要返回的字段。
在执行搜索查询后，我们使用 slice 方法提取了前10个搜索结果，并将其存储在 sliced_response 中。然后，我们可以遍历切片后的响应结果，并访问每个结果的标题。

# 创建一个搜索查询  
search_query = Search(index='my_index')\  
    .query(Q('match', title='Elasticsearch'))\  
    .filter('term', category='technology')\  
    .sort('relevance')\  
    .source(includes=['title', 'content'])\  
    .highlight('content')  # 指定要突出显示的字段  
  
# 执行搜索查询  
response = search_query.execute()  
  
# 处理响应结果中的高亮部分  
hits = response.hits.hits  
for hit in hits:  
    highlighted_content = hit.meta.get('highlight', {}).get('content')  # 获取高亮显示的内容  
    if highlighted_content:  
        print(highlighted_content[0])  # 打印第一个高亮显示的片段
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们使用 highlight 方法指定要突出显示的字段为 “content”。
在执行搜索查询后，我们可以访问每个搜索结果的元数据，并使用 hit.meta.get(‘highlight’, {}).get(‘content’) 来获取高亮显示的内容。如果存在高亮显示的内容，我们打印第一个高亮显示的片段。

# 创建一个搜索查询  
search_query = Search(index='my_index')\  
    .query(Q('match', title='Elasticsearch'))\  
    .filter('term', category='technology')\  
    .sort('relevance')\  
    .source(includes=['title', 'content'])\  
    .extra(explain=True)  # 添加额外查询参数，开启解释功能  
  
# 执行搜索查询  
response = search_query.execute()  
  
# 处理响应结果中的解释信息  
hits = response.hits.hits  
for hit in hits:  
    explanation = hit.meta.get('explanation')  # 获取解释信息  
    if explanation:  
        print(explanation)  # 打印解释信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们使用 extra 方法指定了额外查询参数 explain=True，以开启解释功能。
在执行搜索查询后，我们可以访问每个搜索结果的元数据，并使用 hit.meta.get(‘explanation’) 来获取解释信息。如果存在解释信息，我们打印出来。

2. 聚合查询 bucket, metric, pipeline

2.1 aggs

在 elasticsearch_dsl 中，aggs 方法用于构建聚合查询。它允许你对搜索结果进行分组和汇总操作。

下面是一个使用 aggs 方法的示例：

from elasticsearch_dsl import Search, A, Terms, DateHistogram  
  
# 创建一个搜索查询  
search_query = Search(index='my_index')\  
    .query('match_all')\  
    .aggs(  
        # 创建一个按字段分组的聚合  
        A('group_by_field', Terms(field='my_field')),  
        # 创建一个按日期分组的聚合  
        A('group_by_date', DateHistogram(field='my_date_field', interval='month'))  
    )  
  
# 执行搜索查询  
response = search_query.execute()  
  
# 处理响应结果中的聚合数据  
aggregations = response.aggregations  
field_agg = aggregations.group_by_field.buckets  # 获取按字段分组的聚合结果  
date_agg = aggregations.group_by_date.buckets  # 获取按日期分组的聚合结果  
for bucket in field_agg:  
    print(bucket.key, bucket.doc_count)  # 打印字段分组的结果  
for bucket in date_agg:  
    print(bucket.key, bucket.doc_count)  # 打印日期分组的结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在上面的示例中，我们首先创建了一个搜索查询 search_query，该查询将在索引 my_index 中执行。我们使用 query(‘match_all’) 指定了一个匹配所有文档的查询。然后，我们使用 aggs 方法创建了两个聚合查询：一个按字段分组的聚合和一个按日期分组的聚合。

在执行搜索查询后，我们可以通过 response.aggregations 访问聚合结果。我们使用 aggregations.group_by_field.buckets 和 aggregations.group_by_date.buckets 分别获取按字段分组和按日期分组的聚合结果。然后，我们可以遍历每个桶并打印出结果。

2.2 bucket(), metric(), 和 pipeline()

在 elasticsearch_dsl 中，bucket(), metric(), 和 pipeline() 是聚合查询的一部分，用于构建复杂的聚合操作。

2.2.1 bucket() 方法：

.bucket() 方法用于在聚合查询中创建一个桶聚合。桶聚合会将文档分组到不同的桶中，并根据每个桶的文档进行进一步的聚合操作。

示例：

from elasticsearch_dsl import Search, A, Terms  
  
s = Search(index='my_index')  
s = s.aggs.bucket('my_buckets', A('terms', field='my_field'))  
response = s.execute()  
  
# 访问聚合结果  
buckets = response.aggregations.my_buckets.buckets  
for bucket in buckets:  
    print(bucket.key, bucket.doc_count)
1
2
3
4
5
6
7
8
9
10

2.2.2 metric() 方法：

.metric() 方法用于在聚合查询中创建一个度量聚合。度量聚合会对每个桶中的文档进行进一步的度量计算，例如求和、平均值等。

示例：

from elasticsearch_dsl import Search, A, Terms, Sum  
  
s = Search(index='my_index')  
s = s.aggs.bucket('my_buckets', A('terms', field='my_field'))\  
       .metric('my_metric', A('sum', field='my_numeric_field'))  
response = s.execute()  
  
# 访问聚合结果  
buckets = response.aggregations.my_buckets.buckets  
for bucket in buckets:  
    print(bucket.key, bucket.my_metric.value)
1
2
3
4
5
6
7
8
9
10
11

2.2.3 pipeline() 方法：

.pipeline() 方法用于在聚合查询中创建一个管道聚合。管道聚合可以对桶聚合或度量聚合的结果进行进一步的处理，例如移动平均、累计总和等。

示例：

from elasticsearch_dsl import Search, A, Terms, Sum, MovingAvg  
  
s = Search(index='my_index')  
s = s.aggs.bucket('my_buckets', A('terms', field='my_field'))\  
       .metric('my_metric', A('sum', field='my_numeric_field'))\  
       .pipeline('my_pipeline', A('movavg', buckets_path='my_metric'))  
response = s.execute()  
  
# 访问聚合结果  
buckets = response.aggregations.my_buckets.buckets  
for bucket in buckets:  
    print(bucket.key, bucket.my_metric.value, bucket.my_pipeline.value)
1
2
3
4
5
6
7
8
9
10
11
12

这些示例展示了如何使用 .bucket(), .metric(), 和 .pipeline() 方法来构建复杂的聚合查询。

3. A查询 Q查询

在 elasticsearch_dsl 中，A 查询和 Q 查询是用于构建 Elasticsearch 查询的两种不同方式。

3.1 A 查询

A 查询是 elasticsearch_dsl 中的一种查询方式，它使用 A 类来构建查询。A 类代表一个查询子句，可以通过链式调用的方式来构建复杂的查询。例如：

from elasticsearch_dsl import Search, A  
  
search_query = Search(index='my_index').query(  
    A('match', title='Elasticsearch') & A('term', category='technology')  
)
1
2
3
4
5

在上面的示例中，我们使用 A 类来构建了一个匹配查询和一个词项查询，并将它们组合在一起使用逻辑与操作符 &。

3.2 Q 查询

Q 查询是 Elasticsearch 中的另一种查询方式，它使用 Q 类来构建查询。Q 类代表一个查询子句，可以通过链式调用的方式来构建复杂的查询。例如：

from elasticsearch_dsl import Search, Q  
  
search_query = Search(index='my_index').query(  
    Q('match', title='Elasticsearch') & Q('term', category='technology')  
)
1
2
3
4
5

在上面的示例中，我们使用 Q 类来构建了一个匹配查询和一个词项查询，并将它们组合在一起使用逻辑与操作符 &。

A 查询和 Q 查询在语法上略有不同，但它们在功能上非常相似。

4. MultiSearch

在 elasticsearch_dsl 中，MultiSearch 是一个用于执行多个搜索查询的类。它允许你在单个请求中发送多个搜索请求，并获取每个请求的响应。这对于批量处理或并行处理多个查询非常有用。

下面是一个使用 MultiSearch 的示例：

from elasticsearch_dsl import Search, Q, MultiSearch  
  
# 创建两个搜索查询  
search1 = Search(index='my_index').query(Q('match', title='Elasticsearch'))  
search2 = Search(index='my_index').query(Q('match', content='Python'))  
  
# 创建 MultiSearch 对象并将查询添加到其中  
multi_search = MultiSearch()  
multi_search.add(search1)  
multi_search.add(search2)  
  
# 执行 MultiSearch  
responses = multi_search.execute() 
# 处理每个查询的响应  
for response in responses:  
    # 访问每个响应的搜索结果  
    hits = response.hits.hits  
    for hit in hits:  
        print(hit.title)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在上面的示例中，我们首先创建了两个搜索查询 search1 和 search2。然后，我们创建了一个 MultiSearch 对象，并使用 add 方法将这两个查询添加到其中。最后，我们使用 execute 方法执行 MultiSearch，并得到一个包含每个查询响应的列表。我们可以遍历这些响应，并访问每个响应的搜索结果。