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等。聚合操作可以嵌套使用，从而实现更复杂的聚合查询操作。

相关问题

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 的文档数量，并且使用了条件脚本来判断每个文档是否符合条件。最终，它们的计数结果被汇总到了每个分组中。

"sort_agg": { "bucket_sort": { "from": 0, "size": 10, "sort": [] } },转换成java的NativeSearchQueryBuilder写法

可以使用以下代码将该查询转换为 Java 的 `NativeSearchQueryBuilder` 写法：

import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.sort.BucketSortPipelineAggregationBuilder;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;

NativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder();
BucketSortPipelineAggregationBuilder bucketSortAggregation = AggregationBuilders.bucketSort("sort_agg")
        .from(0)
        .size(10);
searchQueryBuilder.addAggregation(bucketSortAggregation);

其中，`NativeSearchQueryBuilder` 是 Spring Data Elasticsearch 提供的用于构建 Elasticsearch 查询的构建器。`AggregationBuilders.bucketSort` 方法用于创建 `bucket_sort` 聚合，其中 `"sort_agg"` 是聚合的名称。`from` 和 `size` 方法用于设置聚合的分页。最后，我们通过 `searchQueryBuilder.addAggregation` 方法将聚合添加到查询中。