Elasticsearch在NEST创建查询不工作

Question

我试着从Kibana开发中重新查询到NEST但它不给我相同的结果。

我在Kibana运行查询工作完全返回1个结果

这里是我的Kibana查询：

GET /cats/_doc/_search
{   
"query":{
    "bool" : {     
        "minimum_should_match" :3,
        "should": [
           {"term" : { "name" : "cats" }},
           {"term" : { "name" : "are" }},
           {"term" : { "name" : "craze" }}

         ]
      }
   }
}

当我创建在NEST它返回时我的minimum_should_match更改为1除了没有结果的查询（其然后返回2次的结果）

这里是我的NEST查询：

        string[] tmp = "Cats are craze".ToLower().Split(new string[] { " " }, StringSplitOptions.None);

        var cats = ElasticMain.Search<dynamic>(s => s.From(from).Size(20).Query(
                  q => q.Bool(
                      b => b.MinimumShouldMatch(tmp.Length).Should(
                          l => l.Terms(
                              t => t.Name("name").Field("name").Terms(tmp)))

               )));

我究竟做错了什么？

Answer 1

你是不是建设NEST相同的查询，你在Kibana有;前者是利用terms查询，而后者是用在term查询bool第3个should查询。这两个查询以最小的应该匹配组合的语义是不同的。

在NEST同样的查询是

var client = new ElasticClient();

string[] tmp = "Cats are craze".ToLower().Split(new string[] { " " }, StringSplitOptions.None);
var from = 0;

var searchResponse = client.Search<dynamic>(s => s
    .From(from)
    .Size(20)
    .Query(q => q
        .Bool(b =>
        {
            b.MinimumShouldMatch(tmp.Length);
            var shouldQueries = 
                new List<Func<QueryContainerDescriptor<dynamic>, QueryContainer>>(tmp.Length);

            for (var i = 0; i < tmp.Length; i++)
            {
                var value = tmp[i];              
                shouldQueries.Add(qc => qc.Term(t => t
                    .Field("name")
                    .Value(value)
                ));
            }

            b.Should(shouldQueries);

            return b;
        })
    )
);

它建立以下查询

{
  "from": 0,
  "query": {
    "bool": {
      "minimum_should_match": 3,
      "should": [
        {
          "term": {
            "name": {
              "value": "cats"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "are"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "craze"
            }
          }
        }
      ]
    }
  },
  "size": 20
}

当必须匹配should条款的数目等于minimum_should_match在这个例子中，它有效地是相同的话说，他们都是must条款（不minimum_should_match）

var client = new ElasticClient();

string[] tmp = "Cats are craze".ToLower().Split(new string[] { " " }, StringSplitOptions.None);
var from = 0;

var searchResponse = client.Search<dynamic>(s => s
    .From(from)
    .Size(20)
    .Query(q => 
        tmp.Aggregate((QueryContainer)null, (qc, v) => qc && q.Term("name", v))
    )
);

这需要operator overloading on NEST queries的优势&&在一起，以构建查询

{
  "from": 0,
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "name": {
              "value": "cats"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "are"
            }
          }
        },
        {
          "term": {
            "name": {
              "value": "craze"
            }
          }
        }
      ]
    }
  },
  "size": 20
}