Dynamic 嵌套弹性-构建动态嵌套查询

我必须使用Nest查询嵌套对象，但是查询是以动态方式构建的。下面的代码演示了如何以静态方式对嵌套的“书籍”进行查询

QueryContainer qry;
         qry = new QueryStringQuery()
         {
             DefaultField = "name",
             DefaultOperator = Operator.And,
             Query = "salman"
         };

         QueryContainer qry1 = null;

         qry1 = new RangeQuery() // used to search for range ( from , to)
         {
             Field = "modified",
             GreaterThanOrEqualTo = Convert.ToDateTime("21/12/2015").ToString("dd/MM/yyyy"),
         };

         QueryContainer all = qry && qry1;

            var results = elastic.Search<Document>(s => s
               .Query(q => q
                    .Bool(qb => qb
                        .Must(all)))
                .Filter(f =>
                        f.Nested(n => n
                             .Path("books")
                                .Filter(f3 => f3.And(
                                            f1 => f1.Term("book.isbn", "122"),
                                            f2 => f2.Term("book.author", "X"))

                                        )
                                )
                        )   

                );

QueryContainer-qry；
qry=newquerystringquery（）
{
DefaultField=“name”，
DefaultOperator=运算符。和，
Query=“salman”
};
QueryContainer qry1=null；
qry1=new RangeQuery（）//用于搜索范围（从、到）
{
Field=“已修改”，
GreaterThanOrEqualTo=转换为当前时间（“2015年12月21日”）。转换为字符串（“2015年12月21日”），
};
QueryContainer all=qry&&qry1；
var results=elastic.Search（s=>s
.Query（q=>q
.Bool（qb=>qb
.必须（全部）））
.Filter（f=>
f、 嵌套（n=>n
.Path（“书籍”）
.Filter（f3=>f3.And(
f1=>f1.术语（“图书isbn”，“122”），
f2=>f2.术语（“书的作者”，“X”））
)
)
)   
);

问题是我需要以动态方式组合多个查询（使用And、OR运算符）来查询“books”。例如，获取满足以下条件的书籍：

条件1：有作者“X”和isbn“1”的书籍

条件2：有作者“X”和isbn“2”的书籍

条件3：有作者“Z”和isbn“3”的书籍

其他条件：

现在，如果：
条件1和条件2或条件3

假设我有包含以下属性的类名过滤器选项：

字段名

价值观

操作员（将合并下一个过滤器）

我将循环给定的FilterOptions数组来构建查询

问题:

我应该使用什么来构建嵌套查询？它是一个FilterDesciptor，如何将它们结合起来，将嵌套查询添加到搜索方法中

---

请推荐任何有价值的链接或示例？

在

条件1

和

条件2

的特定情况下，您可能不会得到任何结果，因为这些是独占条件。但是我现在假设，你想要得到符合这两个条件的结果。您已经选择了嵌套式，这绝对是一种方式。使用嵌套类型，可以组合单个书本的参数

组合嵌套查询

对于您的用例，我将使用带有

must

或

should

子句的

bool

查询类型。 要获取条件1或条件2的图书，查询如下：

POST /books/_search
{
   "query": {
      "bool": {
         "should": [
            {
               "nested": {
                  "path": "books",
                  "query": {
                     "bool": {
                        "must": [
                           {
                              "match": {
                                 "books.isbn": "2"
                              }
                           },
                           {
                              "match": {
                                 "books.author": "X"
                              }
                           }
                        ]
                     }
                  }
               }
            },
            {
               "nested": {
                  "path": "books",
                  "query": {
                     "bool": {
                        "must": [
                           {
                              "match": {
                                 "books.isbn": "1"
                              }
                           },
                           {
                              "match": {
                                 "books.author": "X"
                              }
                           }
                        ]
                     }
                  }
               }
            }
         ]
      }
   }
}

你能解释一下，为什么你的书是嵌套的吗？无需将它们嵌套在顶级结构中，而是直接作为索引/类型中的顶级对象进行索引，就可以简化查询

未分析

您必须提醒的另一个注意事项是：如果您想获得作者和ISBN的精确匹配，您必须确保ISBN和author字段设置为

not_analysis

。否则，它们会被分析并分解成多个部分，你的匹配将不会很好地工作

例如，如果您有一个带破折号的ISBN编号，则它将被拆分为多个部分：

978-3-16-148410-0

将被索引为：

978
3
16
148410
0

使用完全相同的ISBN号进行搜索会得到所有在ISBN号中有一个子编号的书籍。如果要防止出现这种情况，请使用

not\u analysisd

索引类型，并：

然后要处理未分析的

isbn字段，您必须调用它：

books.isbn.raw

希望这能有所帮助。
我同意paweloque的观点，你的前两个条件似乎是矛盾的，如果你把它们放在一起，它们就不起作用了。忽略这一点，下面是我的解决方案。我以这样一种方式实现了这一点，它允许超过您拥有的三个特定条件。我也觉得它更适合
bool
语句

QueryContainer andQuery = null;
QueryContainer orQuery = null;
foreach(var authorFilter in FilterOptions.Where(f=>f.Operator==Operator.And))
{
    andQuery &= new TermQuery
    {
        Field = authorFilter.FieldName,
        Value = authorFilter.Value
    };
}
foreach(var authorFilter in FilterOptions.Where(f=>f.Operator==Operator.Or))
{
    orQuery |= new TermQuery
    {
        Field = authorFilter.FieldName,
        Value = authorFilter.Value
    };
}

之后，在
.Nested
调用中，我将放置：

.Path("books")
    .Query(q=>q
        .Bool(bq=>bq
            .Must(m=>m.MatchAll() && andQuery)
            .Should(orQuery)
    ))

实际上，当查询不能满足预期的结果时，我进入了嵌套对象，这两个条件都在书本上执行。此链接将澄清我的问题：[如何使用NEST构建此查询？我一直在搜索此答案，因为两天了…谢谢..节省了我的时间
.Path("books")
    .Query(q=>q
        .Bool(bq=>bq
            .Must(m=>m.MatchAll() && andQuery)
            .Should(orQuery)
    ))