如何在Elasticsearch中对tags字段执行类似multi_term的聚合？

问题背景 #

现有Elasticsearch文档，每个文档包含tags数组字段，示例数据如下：

[
    { "id": 0, "tags": ["ant", "bird", "dog", "fox"]},
    { "id": 1, "tags": ["cat", "fox", "goose", "horse"]},
    { "id": 2, "tags": ["ant", "bird", "cat", "eel", "fox", "goose", "horse"]},
    { "id": 3, "tags": ["ant", "eel", "goose", "horse"]},
    { "id": 4, "tags": ["ant", "bird", "cat", "eel", "fox"]},
    { "id": 5, "tags": ["ant", "bird", "cat", "eel", "fox"]},
    { "id": 6, "tags": ["bird", "cat", "dog", "eel", "fox", "goose"]},
    { "id": 7, "tags": ["ant", "cat", "eel", "fox", "horse"]},
    { "id": 8, "tags": ["ant", "cat", "dog", "eel", "fox", "horse"]}
]

需要实现类似multi_term的聚合效果，但针对tags字段的所有三元标签组合，统计每个组合出现的文档数量，预期输出如示例所示。

可行实现方案 #

方案1：运行时脚本生成组合（适合小数据量）

通过Painless脚本在聚合阶段实时生成tags的所有三元组合，再对生成的组合做terms聚合。这种方式无需修改索引结构，但性能依赖数据量，文档数或标签过多时会有性能损耗。

完整查询DSL示例：

{
  "size": 0,
  "aggs": {
    "tag_triples": {
      "terms": {
        "script": {
          "source": """
            List triples = new ArrayList();
            List tags = params._source.tags;
            // 排序标签保证组合一致性（避免["ant","cat","eel"]和["cat","ant","eel"]被视为不同键）
            Collections.sort(tags);
            // 生成所有三元组合
            for (int i = 0; i < tags.size(); i++) {
              for (int j = i + 1; j < tags.size(); j++) {
                for (int k = j + 1; k < tags.size(); k++) {
                  triples.add(tags.get(i) + "," + tags.get(j) + "," + tags.get(k));
                }
              }
            }
            return triples;
          """,
          "lang": "painless"
        },
        "size": 1000, // 根据需要调整返回的桶数量
        "order": {
          "_count": "desc"
        }
      }
    }
  }
}

注意：脚本中对标签做了排序，确保同一组标签的不同排列被视为同一个组合，避免重复统计。聚合结果的key是用逗号分隔的字符串，若需要数组格式，可在客户端将字符串拆分转换。

方案2：索引前预处理生成组合（适合大数据量）

在文档索引阶段，提前生成tags的所有三元组合并存储为新字段（如tag_triples），之后直接对该字段做terms聚合，这种方式性能最优，适合数据量较大的场景。

步骤1：定义索引Mapping

确保新字段tag_triples为keyword类型（支持聚合）：

{
  "mappings": {
    "properties": {
      "id": {"type": "integer"},
      "tags": {"type": "keyword"},
      "tag_triples": {"type": "keyword"}
    }
  }
}

步骤2：生成三元组合（两种方式）

• 客户端预处理：在将文档写入Elasticsearch前，在业务代码中生成tags的所有三元组合，存入tag_triples字段。
• Ingest Pipeline自动生成：通过Elasticsearch管道在索引时自动生成组合，无需修改业务代码：

PUT _ingest/pipeline/tag-triple-generator
{
  "processors": [
    {
      "script": {
        "source": """
          List tags = ctx.tags;
          if (tags == null || tags.size() < 3) {
            ctx.tag_triples = [];
            return;
          }
          Collections.sort(tags);
          List triples = new ArrayList();
          for (int i = 0; i < tags.size(); i++) {
            for (int j = i + 1; j < tags.size(); j++) {
              for (int k = j + 1; k < tags.size(); k++) {
                triples.add(tags.get(i) + "," + tags.get(j) + "," + tags.get(k));
              }
            }
          }
          ctx.tag_triples = triples;
        """,
        "lang": "painless"
      }
    }
  ]
}

索引文档时指定管道：

PUT /your_index/_doc/0?pipeline=tag-triple-generator
{
  "id": 0,
  "tags": ["ant", "bird", "dog", "fox"]
}

步骤3：聚合查询

直接对tag_triples字段做terms聚合即可：

{
  "size": 0,
  "aggs": {
    "my_agg": {
      "terms": {
        "field": "tag_triples",
        "size": 1000,
        "order": {"_count": "desc"}
      }
    }
  }
}

内容的提问来源于stack exchange，提问作者Nathan Kronenfeld