基于Qualifiers多条件组的Elasticsearch文档匹配查询求助

问题背景 #

我的问题与Stack Overflow上的类似场景核心逻辑一致，但因文档结构差异无法直接复用方案。当前Elasticsearch中文档结构如下：

{
    "locale": "en_US", 
    "type": "bla",
    "qualifiers": [
         {
             "criteria": [
                {
                    "type": "year_range",
                    "lower": 2024,
                    "upper": 2027
                },
                {
                    "type": "ids",
                    "values": [1,20]
                },
                {
                    "type": "string_range_term",
                    "lower": "123455",
                    "upper": "zzzzzz"
                }
            ]
        },
        {
             "criteria": [
                {
                    "type": "year_range",
                    "lower": 2010,
                    "upper": 2012
                }
            ]
        }
    ]
}

输入参数固定包含year、id、term，匹配规则：

• 至少有一个qualifier下的所有criteria全部匹配，才返回文档；
• 输入参数覆盖所有可能的匹配维度；
• 文档中存在对应类型的criteria则必须匹配，无对应类型则忽略。

匹配示例：

• 输入year:2011、id:10、term:aaaa → 匹配（第二个qualifier的year_range符合）；
• 输入year:2013、id:1、term:zzzzzz → 不匹配（year不符合）；
• 输入year:2025、id:20、term:zzzzzz → 匹配（第一个qualifier的所有criteria均符合）；
• 输入year:2025、id:50、term:zzzzzz → 不匹配（id不符合）。

当前数据结构与数据库一致，数据库可正常运行，但为提升筛选速度需迁移至Elasticsearch，已卡4天，需用Java Rest Client实现查询方案。

解决方案 #

方案一：保留原结构的查询实现 #

前提配置

需先确保索引映射中，qualifiers和qualifiers.criteria均设置为nested类型，否则数组嵌套的匹配逻辑会失效。

查询逻辑

用bool查询嵌套多层nested查询：

1. 用should包裹多个nested查询，每个nested对应一个qualifier的完整匹配条件；
2. 每个qualifier的匹配条件用must组合对应类型的criteria校验；
3. 设置minimum_should_match: 1，确保至少匹配一个qualifier。

示例DSL（以输入year:2025、id:20、term:zzzzzz为例）

{
  "query": {
    "bool": {
      "should": [
        {
          "nested": {
            "path": "qualifiers",
            "query": {
              "bool": {
                "must": [
                  {
                    "nested": {
                      "path": "qualifiers.criteria",
                      "query": {
                        "bool": {
                          "must": [
                            {"term": {"qualifiers.criteria.type": "year_range"}},
                            {"range": {"qualifiers.criteria.lower": {"lte": 2025}}},
                            {"range": {"qualifiers.criteria.upper": {"gte": 2025}}}
                          ]
                        }
                      }
                    }
                  },
                  {
                    "nested": {
                      "path": "qualifiers.criteria",
                      "query": {
                        "bool": {
                          "must": [
                            {"term": {"qualifiers.criteria.type": "ids"}},
                            {"terms": {"qualifiers.criteria.values": [20]}}
                          ]
                        }
                      }
                    }
                  },
                  {
                    "nested": {
                      "path": "qualifiers.criteria",
                      "query": {
                        "bool": {
                          "must": [
                            {"term": {"qualifiers.criteria.type": "string_range_term"}},
                            {"range": {"qualifiers.criteria.lower": {"lte": "zzzzzz"}}},
                            {"range": {"qualifiers.criteria.upper": {"gte": "zzzzzz"}}}
                          ]
                        }
                      }
                    }
                  }
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "qualifiers",
            "query": {
              "bool": {
                "must": [
                  {
                    "nested": {
                      "path": "qualifiers.criteria",
                      "query": {
                        "bool": {
                          "must": [
                            {"term": {"qualifiers.criteria.type": "year_range"}},
                            {"range": {"qualifiers.criteria.lower": {"lte": 2025}}},
                            {"range": {"qualifiers.criteria.upper": {"gte": 2025}}}
                          ]
                        }
                      }
                    }
                  }
                ]
              }
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

说明：该方案需根据文档中qualifiers的数量动态生成should内的查询，若qualifiers数量较多，查询复杂度会上升，性能可能受影响。

方案二：优化数据结构（推荐） #

调整文档结构，将criteria按类型扁平化，更适配Elasticsearch的检索特性，提升查询性能：

{
    "locale": "en_US", 
    "type": "bla",
    "qualifiers": [
         {
             "year_range": {"lower": 2024, "upper": 2027},
             "ids": [1,20],
             "string_range_term": {"lower": "123455", "upper": "zzzzzz"}
         },
         {
             "year_range": {"lower": 2010, "upper": 2012}
         }
    ]
}

示例DSL

{
  "query": {
    "bool": {
      "should": [
        {
          "nested": {
            "path": "qualifiers",
            "query": {
              "bool": {
                "must": [
                  {"range": {"qualifiers.year_range.lower": {"lte": 2025}}},
                  {"range": {"qualifiers.year_range.upper": {"gte": 2025}}},
                  {"terms": {"qualifiers.ids": [20]}},
                  {"range": {"qualifiers.string_range_term.lower": {"lte": "zzzzzz"}}},
                  {"range": {"qualifiers.string_range_term.upper": {"gte": "zzzzzz"}}}
                ]
              }
            }
          }
        },
        {
          "nested": {
            "path": "qualifiers",
            "query": {
              "bool": {
                "must": [
                  {"range": {"qualifiers.year_range.lower": {"lte": 2025}}},
                  {"range": {"qualifiers.year_range.upper": {"gte": 2025}}}
                ]
              }
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

Java Rest Client 实现示例（方案二） #

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.NestedQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class QualifierSearchClient {
    public static void matchDocuments(RestHighLevelClient client, int year, int id, String term) throws IOException {
        // 构建第一个qualifier的全条件匹配
        BoolQueryBuilder firstQualifierQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.rangeQuery("qualifiers.year_range.lower").lte(year))
                .must(QueryBuilders.rangeQuery("qualifiers.year_range.upper").gte(year))
                .must(QueryBuilders.termsQuery("qualifiers.ids", id))
                .must(QueryBuilders.rangeQuery("qualifiers.string_range_term.lower").lte(term))
                .must(QueryBuilders.rangeQuery("qualifiers.string_range_term.upper").gte(term));

        NestedQueryBuilder firstNested = QueryBuilders.nestedQuery("qualifiers", firstQualifierQuery, org.elasticsearch.index.query.QueryBuilders.QueryRewriteContext.DEFAULT);

        // 构建第二个qualifier的year条件匹配
        BoolQueryBuilder secondQualifierQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.rangeQuery("qualifiers.year_range.lower").lte(year))
                .must(QueryBuilders.rangeQuery("qualifiers.year_range.upper").gte(year));

        NestedQueryBuilder secondNested = QueryBuilders.nestedQuery("qualifiers", secondQualifierQuery, org.elasticsearch.index.query.QueryBuilders.QueryRewriteContext.DEFAULT);

        // 总查询：至少匹配一个qualifier
        BoolQueryBuilder totalQuery = QueryBuilders.boolQuery()
                .should(firstNested)
                .should(secondNested)
                .minimumShouldMatch(1);

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().query(totalQuery);
        SearchRequest request = new SearchRequest("your_index_name").source(sourceBuilder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 处理查询结果
        System.out.println("匹配文档数：" + response.getHits().getTotalHits().value);
    }
}

说明：实际使用时需根据输入参数和文档中qualifiers的结构动态生成should内的查询，避免硬编码。

关键注意事项 #

1. 无论哪种方案，qualifiers字段必须设置为nested类型，否则数组元素的匹配会出现交叉匹配错误；
2. 方案二虽需调整数据结构，但查询层级更少、逻辑更简洁，长期来看性能和维护性更优；
3. 动态生成查询时，需注意过滤掉文档中不存在的criteria类型，避免无效查询条件。

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