Elasticsearch：统计可筛选长度的嵌套文档高频颜色组合

我有一个包含嵌套文档（colors）的Elasticsearch索引，希望通过带聚合的查询获取最频繁的颜色组合。要求组合顺序无关（red-green与green-red视为同一组合），同时能筛选组合的颜色数量（比如最小2个、最大5个）。我不想在索引时保存所有可能的组合，因为有4000种颜色，会导致数据膨胀。

示例数据 #

三个文档：

[
    {
        "name": "Document A",
        "colors": [
            { "name": "Red", "slug": "red" },
            { "name": "Green", "slug": "green" },
            { "name": "Blue", "slug": "blue" }
        ]
    },
    {
        "name": "Document B",
        "colors": [
            { "name": "Green", "slug": "green" },
            { "name": "Blue", "slug": "blue" }
        ]
    },
    {
        "name": "Document C",
        "colors": [
            { "name": "Red", "slug": "red" },
            { "name": "Blue", "slug": "blue" }
        ]
    }
]

期望结果 #

green-blue: doc count=2
red-blue: doc count=2
red-green: doc count=1
red-green-blue: doc count=1

索引映射 #

{
  "mappings": {
    "_doc": {
      "properties": {
        "created": {
          "type": "date"
        },
        "name": {
          "type": "text"
        },
        "colors": {
          "type": "nested",
          "properties": {
            "name": {
              "type": "text",
              "fields": {
                "keyword": {
                  "type": "keyword",
                  "ignore_above": 256
                }
              }
            },
            "slug": {
              "type": "keyword"
            }
          }
        }
      }
    }
  }
}

核心思路 #

利用Elasticsearch的**运行时字段（runtime field）**在查询时动态生成标准化的颜色组合字符串（排序slug后用分隔符连接，确保顺序无关），再通过聚合统计组合的出现次数，同时过滤组合的颜色数量。

具体查询语句 #

GET /your_index/_search
{
  "size": 0,
  "runtime_mappings": {
    "color_combinations": {
      "type": "keyword",
      "script": {
        "source": """
          def slugs = [];
          for (color in doc['colors.slug']) {
            slugs.add(color.value);
          }
          // 对slug排序，保证组合顺序一致
          slugs.sort();
          // 生成所有符合数量要求的子组合（这里处理2-5个颜色的组合）
          def combinations = [];
          int minSize = 2;
          int maxSize = 5;
          // 生成所有非空子集，筛选符合大小范围的
          for (int i = 0; i < (1 << slugs.size()); i++) {
            def subset = [];
            for (int j = 0; j < slugs.size(); j++) {
              if ((i & (1 << j)) != 0) {
                subset.add(slugs[j]);
              }
            }
            if (subset.size() >= minSize && subset.size() <= maxSize) {
              combinations.add(subset.join('-'));
            }
          }
          emit(combinations);
        """
      }
    }
  },
  "aggs": {
    "color_combination_counts": {
      "terms": {
        "field": "color_combinations",
        "size": 100 // 按需调整返回的组合数量
      }
    }
  }
}

关键细节说明 #

• 运行时字段动态生成组合：通过脚本遍历文档的colors.slug字段，排序后生成所有符合minSize和maxSize的子组合，用-连接成字符串，这样red-green和green-red会被处理成同一个字符串。
• 聚合统计次数：使用terms聚合对生成的color_combinations字段进行统计，直接得到每个组合的文档计数。
• 性能注意事项：
  • 脚本在查询时运行，对于大索引会有一定性能开销，但避免了索引时的数据膨胀。
  • 如果单文档的colors数量较多（比如超过10个），生成子集的计算量会指数增长，建议限制单文档的colors数量，或者调整maxSize避免生成过多组合。
  • 可以将脚本逻辑封装成存储脚本（stored script），复用代码并提高可读性。

优化方向 #

如果查询性能达不到要求，可以考虑在索引时生成单个排序后的slug字符串（比如blue-green-red），然后使用significant_terms聚合或者借助外部工具（如Spark）来计算组合频率，但这种方式需要额外的处理，不如运行时字段直接。

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