带C＃嵌套客户端的elasticsearch空数组搜索查询

Question

I have a model in elasticsearch like this:

"hits": [
{
  "_index": "post",
  "_type": "postmodel",
  "_source": {
    "projectId": "2",
    "language": "en",
    "postDate": "2017-06-11T08:39:32Z",
    "profiles": [
      {
        "label": "Emotional",
        "confidence": 1
      }
    ]
  }
},
{
  "_index": "post",
  "_type": "postmodel",
  "_source": {
    "projectId": "3",
    "language": "en",
    "postDate": "2017-06-11T08:05:01Z",
    "profiles": []
  }
},
...

By using c# Nest API, i want to fetch the postmodels that has empty profiles (the second post in the example data above). I have tried many ways to write the right query but i've ended up with this query below and still it doesnt give me the right results. My current code looks like this:

var postModels = await _elasticClient.SearchAsync<PostModel>(s => s
        .Index("post")
        .Query(q =>
        {
            QueryContainer query = new QueryContainer();

            query = query && q.Match(m => m.Field(f => f.ProjectId)
            .Query("3"));

            query = query && q.Nested(n => n.Path(p => p.Profiles)
                        .Query(qn => qn.Bool(b => b.Must(bm => bm.Match(m => m
                        .Field(f => f.Profiles).Query(null))))));

            return query;
        }));

I would be happy if someone can help me with this problem. Thank you in advance.

Answer 1

Here's a complete example of how you can accomplish it with an exists query in a must_not clause

private static void Main()
{
    var defaultIndex = "post";

    var settings = new ConnectionSettings(new Uri("http://localhost:9200"))
        .DefaultIndex(defaultIndex);

    var client = new ElasticClient(settings);

    if (client.IndexExists(defaultIndex).Exists)
        client.DeleteIndex(defaultIndex);

    client.CreateIndex(defaultIndex, c => c
        .Settings(s => s
            .NumberOfShards(1)
            .NumberOfReplicas(0)
        )
        .Mappings(m => m
            .Map<PostModel>(mm => mm
                .AutoMap()
                .Properties(p => p
                    .Nested<Profile>(np => np
                        .Name(n => n.Profiles)
                        .AutoMap()
                    )
                )
            )
        )
    );

    var posts = new List<PostModel>
    {
        new PostModel
        {
            ProjectId = "2",
            Language = "en",
            PostDate = new DateTime(2017, 6, 11, 8, 39, 32, DateTimeKind.Utc),
            Profiles = new List<Profile>
            {
                new Profile
                {
                    Label = "Emotional",
                    Confidence = 1
                }
            }
        },
        new PostModel
        {
            ProjectId = "3",
            Language = "en",
            PostDate = new DateTime(2018, 1, 1, 0, 0, 0, DateTimeKind.Utc),
            Profiles = new List<Profile>
            {
                new Profile
                {
                    Label = "Lazy",
                    Confidence = 3
                }
            }
        },
        new PostModel
        {
            ProjectId = "3",
            Language = "en",
            PostDate = new DateTime(2017, 6, 11, 8, 5, 1, DateTimeKind.Utc),
            Profiles = new List<Profile>()
        }
    };

    client.IndexMany(posts);
    client.Refresh(defaultIndex);

    var postModels = client.Search<PostModel>(s => s
        .Query(q =>
        {
            QueryContainer query = q
                .Match(m => m
                    .Field(f => f.ProjectId)
                    .Query("3")
                );

            query = query && q
                .Bool(b => b
                    .MustNot(bm => bm
                        .Nested(n => n
                            .Path(p => p.Profiles)
                            .Query(qn => qn
                                .Exists(m => m
                                    .Field(f => f.Profiles)
                                )
                            )
                        )               
                    )           
            );

            return query;
        }));
}

public class Profile 
{
    public string Label { get; set; }

    public int Confidence { get; set; }

}

public class PostModel
{
    public string ProjectId { get; set; }

    public string Language { get; set; }

    public DateTime PostDate { get; set; }

    public List<Profile> Profiles { get; set; }
}

This returns just the one document with projectId 3 and no profiles

{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 0.47000363,
    "hits" : [
      {
        "_index" : "post",
        "_type" : "postmodel",
        "_id" : "qeNF72ABeLoaZkUgC2Xh",
        "_score" : 0.47000363,
        "_source" : {
          "projectId" : "3",
          "language" : "en",
          "postDate" : "2017-06-11T08:05:01Z",
          "profiles" : [ ]
        }
      }
    ]
  }
}

With operator overloading on queries, the query can be expressed more succinctly

var postModels = client.Search<PostModel>(s => s
    .Query(q => q
        .Match(m => m
            .Field(f => f.ProjectId)
            .Query("3")
        ) && !q
        .Nested(n => n
            .Path(p => p.Profiles)
            .Query(qn => qn
                .Exists(m => m
                    .Field(f => f.Profiles)
                )
            )
        )               
    )
);