ElasticSearch结合了条款和匹配查询

Question

I have worked out the elasticsearch query I need via Console, and it works as expected:

                    "query": {
                    "bool": {
                        "must": [
                        { "terms": { "color": ["red", "blue"]
                            }
                        },
                        { "match": { "availability":   "in stock" }} 
                        ]
                    }
               }

I now need to do this using the nest client. I have currently tried:

                nestClient.Search<Item>(
                s => s.From(query.Page).Size(query.PageSize)
                    .Query(
                        q => q.Bool(
                            b => b.Must(
                                ss => ss.Terms(t => t.Field(f => f.Color).Terms<string>(query.Color)),
                                ss => ss.Match(m => m.Field(f => f.Availability == "in stock"))))).TypedKeys(null));

But when looking at the outputted JSON in fiddler it seems to be ignoring the query and using:

{"from":0,"size":24}

If I remove the match part of the nest query then the outputted JSON DSL is correctly using the Terms query.

Is it possible to do what I am looking for in one pass?

Answer 1

The query value for the match query needs to be passed to the .Query(...) method

var query = new {
    Page = 0,
    PageSize = 10,
    Color = new [] { "red", "yellow" }
};

nestClient.Search<Item>(s => s
    .From(query.Page)
    .Size(query.PageSize)
    .Query(q => q
        .Bool(b => b
            .Must(
                ss => ss.Terms(t => t.Field(f => f.Color).Terms<string>(query.Color)),
                ss => ss.Match(m => m.Field(f => f.Availability).Query("in stock"))
            )
        )
    )
    .TypedKeys(null)
);

This can be shortened further using operator overloading on the base query type , to construct a bool query more succinctly

nestClient.Search<Item>(s => s
    .From(query.Page)
    .Size(query.PageSize)
    .Query(q => q
        .Terms(t => t.Field(f => f.Color).Terms<string>(query.Color)) && q
        .Match(m => m.Field(f => f.Availability).Query("in stock"))
    )
    .TypedKeys(null)
);

Both will produce the following query

{
  "from": 0,
  "size": 10,
  "query": {
    "bool": {
      "must": [
        {
          "terms": {
            "color": [
              "red",
              "yellow"
            ]
          }
        },
        {
          "match": {
            "availability": {
              "query": "in stock"
            }
          }
        }
      ]
    }
  }
}

Additionally, with term-level queries like terms query, the answer to the query is typically yes or no eg does this term match exactly, is this number in this range of numbers, etc. With predicates like this, you typically don't need the relevancy scoring phase to be executed for these queries, which you can forgo by having them execute in a filter context, such as the filter clause of a bool query. Putting this together with operator overloading

nestClient.Search<Item>(s => s
    .From(query.Page)
    .Size(query.PageSize)
    .Query(q => q
        .Terms(t => t.Field(f => f.Color).Terms<string>(query.Color)) && +q
        .Match(m => m.Field(f => f.Availability).Query("in stock"))
    )
    .TypedKeys(null)
);

which yields

{
  "from": 0,
  "size": 10,
  "query": {
    "bool": {
      "must": [
        {
          "terms": {
            "color": [
              "red",
              "yellow"
            ]
          }
        }
      ],
      "filter": [
        {
          "match": {
            "availability": {
              "query": "in stock"
            }
          }
        }
      ]
    }
  }
}