如何使用OpenSearch.Client查询并添加预设布尔子句简化查询？

我使用OpenSearch.Client库查询OpenSearch，当前执行的复杂查询如下：

var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => bq
            .Must(mq => {
                return mq.Term("field1", value1) && (
                    mq.Term("field2", value2) || mq.Term("field3", value3)
                );
            })
        )
    )
);

我希望加入一些通过外部逻辑计算得到的常量布尔子句，实现查询的部分短路效果。比如下面这段无法编译的逻辑：

bool requireSearchingIntoField1 = false; // 该值由外部逻辑计算得出
var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => bq
            .Must(mq => {
                return (!requireSearchingIntoField1 || mq.Term("field1", value1)) && (
                    mq.Term("field2", value2) || mq.Term("field3", value3)
                );
            })
        )
    )
);

我自己想到了用纯C#判断的实现方式：

bool requireSearchingIntoField1 = false; // 该值由外部逻辑计算得出
var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => bq
            .Must(mq => {
                var q = mq.Term("field2", value2) || mq.Term("field3", value3);
                if(requireSearchingIntoField1)
                {
                    q = q && q.Term("field1", value1);
                }
                
                return q;
            })
        )
    )
);

但我想知道有没有更优雅的实现方式，能让库或OpenSearch自动简化查询。

1. 链式追加Bool查询子句 #

利用OpenSearch.Client的Bool查询支持链式调用的特性，把条件拆分出来，逻辑更清晰，维护性更强：

bool requireSearchingIntoField1 = false; // 外部逻辑计算得出
var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => {
            // 先构建必有的基础查询子句
            var boolQuery = bq.Must(mq => mq.Term("field2", value2) || mq.Term("field3", value3));
            // 根据外部条件动态追加field1的查询
            if (requireSearchingIntoField1)
            {
                boolQuery = boolQuery.Must(mq => mq.Term("field1", value1));
            }
            return boolQuery;
        })
    )
);

2. 使用MatchAll查询实现短路逻辑 #

当不需要检查field1时，用MatchAll查询替代Term查询（MatchAll会匹配所有文档，等价于逻辑上的true），这样写更贴近你最初想表达的短路表达式，且OpenSearch会自动优化这类查询：

bool requireSearchingIntoField1 = false;
var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => bq
            .Must(mq => 
                (requireSearchingIntoField1 ? mq.Term("field1", value1) : mq.MatchAll()) 
                && (mq.Term("field2", value2) || mq.Term("field3", value3))
            )
        )
    )
);

3. 预构建子查询集合 #

如果需要处理更多动态条件，先把所有要添加的子查询放入集合，再传入Bool查询，扩展性更好：

bool requireSearchingIntoField1 = false;
var mustClauses = new List<Func<QueryContainerDescriptor<Document>, QueryContainer>>();

// 添加必选的子查询
mustClauses.Add(mq => mq.Term("field2", value2) || mq.Term("field3", value3));

// 根据外部条件添加可选子查询
if (requireSearchingIntoField1)
{
    mustClauses.Add(mq => mq.Term("field1", value1));
}

var response = openSearchClient.Search<Document>(s => s
    .Index(documentsIndexName)
    .Query(q => q
        .Bool(bq => bq.Must(mustClauses))
    )
);

这些方式都能让OpenSearch.Client生成更简洁的查询DSL，OpenSearch也会自动优化查询执行逻辑，避免不必要的条件判断。

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