elasticsearch聚合查询写法

Elasticsearch聚合查询可以使用Elasticsearch的各种聚合操作，如sum、avg、min、max等，可以对数据进行统计分析。

下面是一个简单的Elasticsearch聚合查询示例：

POST /sales/_search
{
  "size": 0,
  "aggs": {
    "total_sales": {
      "sum": {
        "field": "price"
      }
    }
  }
}

上述示例中，我们针对名为“sales”的索引执行了一个聚合查询操作，该查询将返回所有结果的总销售额。在这个查询中，我们使用了sum聚合操作来计算所有销售记录的价格总和。

除了sum聚合操作之外，Elasticsearch还支持其他聚合操作，如avg、min、max、cardinality、terms等。聚合操作可以嵌套使用，从而实现更复杂的聚合查询操作。

相关问题

在Java中如何elasticsearchClient 如何使用子聚合写法

在Java中使用Elasticsearch Client进行子聚合查询，可以通过构建复杂的查询DSL来实现。子聚合（sub-aggregation）是指在一个聚合操作中嵌套另一个聚合操作。以下是一个示例代码，展示如何在Java中使用Elasticsearch Client进行子聚合查询。

首先，确保你已经添加了Elasticsearch Java客户端的依赖到你的项目中。例如，使用Maven的话，可以在`pom.xml`中添加：

<dependency>
    <groupId>co.elastic.clients</groupId>
    <artifactId>elasticsearch-java</artifactId>
    <version>8.6.0</version>
</dependency>

然后，你可以使用以下代码进行子聚合查询：

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.indices.ElasticsearchIndicesClient;
import co.elastic.clients.elasticsearch.indices.CreateIndexRequest;
import co.elastic.clients.elasticsearch.indices.IndexSettings;
import co.elastic.clients.elasticsearch.indices.PutMappingRequest;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;

import java.io.IOException;

public class ElasticsearchSubAggregationExample {
    public static void main(String[] args) throws IOException {
        // 初始化Elasticsearch客户端
        RestClient restClient = RestClient.builder(new HttpHost("localhost", 9200)).build();
        ElasticsearchClient client = new ElasticsearchClient(new RestClientTransport(restClient, new JacksonJsonpMapper()));

        // 创建索引并设置映射（如果尚未创建）
        CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder().index("products").build();
        client.indices().create(createIndexRequest);

        // 设置映射
        PutMappingRequest putMappingRequest = new PutMappingRequest.Builder()
                .index("products")
                .withJson(new JacksonJsonpMapper().toJson(Map.of(
                        "properties", Map.of(
                                "category", Map.of("type", "keyword"),
                                "price", Map.of("type", "double")
                        )
                )))
                .build();
        client.indices().putMapping(putMappingRequest);

        // 构建子聚合查询
        co.elastic.clients.elasticsearch.core.SearchRequest searchRequest = new co.elastic.clients.elasticsearch.core.SearchRequest.Builder()
                .index("products")
                .query(q -> q
                        .matchAll(m -> m)
                )
                .aggregations("category_agg", a -> a
                        .terms(t -> t
                                .field("category")
                        )
                        .aggregations("price_avg", a2 -> a2
                                .avg(avg -> avg
                                        .field("price")
                                )
                        )
                )
                .build();

        // 执行查询
        co.elastic.clients.elasticsearch.core.SearchResponse<Void> searchResponse = client.search(searchRequest, Void.class);

        // 处理结果
        System.out.println("Aggregations: " + searchResponse.aggregations());

        restClient.close();
    }
}

这个示例代码展示了如何在Java中使用Elasticsearch Client进行子聚合查询。首先，初始化Elasticsearch客户端，然后创建索引并设置映射。接着，构建一个包含子聚合的查询，最后执行查询并处理结果。

elasticsearch7分组时，按照不同条件计数，类似mysql count(case when)写法

在 Elasticsearch 7 中，可以使用聚合（Aggregation）来实现类似 MySQL 中的 count(case when) 写法。具体来说，你可以使用“条件聚合”（Conditional Aggregation）来达到此目的。

例如，假设你有一个包含以下文档的索引：

POST my_index/_doc
{
  "category": "fruit",
  "price": 3
}

POST my_index/_doc
{
  "category": "vegetable",
  "price": 5
}

POST my_index/_doc
{
  "category": "fruit",
  "price": 2
}

POST my_index/_doc
{
  "category": "fruit",
  "price": 4
}

你可以使用以下代码来按照 category 分组，并在每个分组中计算 price 大于 3 的文档数量和 price 小于等于 3 的文档数量：

POST my_index/_search
{
  "size": 0,
  "aggs": {
    "group_by_category": {
      "terms": {
        "field": "category"
      },
      "aggs": {
        "price_greater_than_3": {
          "sum": {
            "script": {
              "source": "if (doc['price'].value > 3) { return 1 } else { return 0 }"
            }
          }
        },
        "price_less_than_or_equal_to_3": {
          "sum": {
            "script": {
              "source": "if (doc['price'].value <= 3) { return 1 } else { return 0 }"
            }
          }
        }
      }
    }
  }
}

这将返回以下结果：

{
  "aggregations" : {
    "group_by_category" : {
      "buckets" : [
        {
          "key" : "fruit",
          "doc_count" : 3,
          "price_greater_than_3" : {
            "value" : 1.0
          },
          "price_less_than_or_equal_to_3" : {
            "value" : 2.0
          }
        },
        {
          "key" : "vegetable",
          "doc_count" : 1,
          "price_greater_than_3" : {
            "value" : 0.0
          },
          "price_less_than_or_equal_to_3" : {
            "value" : 1.0
          }
        }
      ]
    }
  }
}

可以看到，在“group_by_category”聚合内部，每个分组都有一个“price_greater_than_3”和一个“price_less_than_or_equal_to_3”子聚合，它们分别计算了 price 大于 3 和小于等于 3 的文档数量，并且使用了条件脚本来判断每个文档是否符合条件。最终，它们的计数结果被汇总到了每个分组中。