c# - 跨多种类型的 ElasticSearch NEST 查询

Question

给定以下 POCO:

public class Dog
{
    public string Name { get; set; }
}

public class Cat
{
    public string Name { get; set; }
    public bool Enabled { get; set; }
}

我想执行一个返回所有狗的查询，并且只返回已启用的猫。

elastic 文档提供了以下示例，但没有详细说明如何使用带有查询或过滤器上下文的 Bool 来搜索多种类型的特定字段值:

.Search<object>(s => s
    .Size(100)
    .Type(Types.Type(typeof(Dog), typeof(Cat)))                
    .Query(...)

如何执行我的查询？提前致谢

Answer 1

我们可以查询元数据 _type 字段并将其与其他字段的查询相结合。这是一个例子。我们将创建 100 只猫和 100 只狗，将每只偶数猫设置为禁用

void Main()
{
    var pool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
    var defaultIndex = "pets";
    var connectionSettings = new ConnectionSettings(pool)
            .DefaultIndex(defaultIndex);

    var client = new ElasticClient(connectionSettings);

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

    client.CreateIndex(defaultIndex, ci => ci
        .Mappings(m => m
            .Map<Dog>(d => d.AutoMap())
            .Map<Cat>(c => c.AutoMap())
        )
    );

    var dogs = Enumerable.Range(1, 100).Select(i => new Dog
    {
        Name = $"Dog {i}"
    });

    client.IndexMany(dogs);

    var cats = Enumerable.Range(1, 100).Select(i => new Cat
    {
        Name = $"Cat {i}",
        Enabled = i % 2 == 0 ? false : true
    });

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

    client.Search<object>(s => s
        .Size(100)
        .SearchType(SearchType.Count)
        .Type(Types.Type(typeof(Dog), typeof(Cat)))
        .Query(q => 
            (+q.Term("_type", "cat") && +q.Term("enabled", true)) ||
            +q.Term("_type", "dog")
        )
    );
}

搜索查询利用了运算符重载；一元 + 运算符意味着查询将包装在 bool 查询 filter 中，类似地，&& 将包装到一个 bool 查询 must (或 filter 在这种情况下，因为我们也使用 + 一元运算符来使它是一个过滤器)，并且 || 将包装到一个 bool 查询 should 中。结果执行的查询看起来像

{
  "size": 100,
  "query": {
    "bool": {
      "should": [
        {
          "bool": {
            "filter": [
              {
                "term": {
                  "_type": {
                    "value": "cat"
                  }
                }
              },
              {
                "term": {
                  "enabled": {
                    "value": true
                  }
                }
              }
            ]
          }
        },
        {
          "bool": {
            "filter": [
              {
                "term": {
                  "_type": {
                    "value": "dog"
                  }
                }
              }
            ]
          }
        }
      ]
    }
  }
}

产生

{
  "took" : 3,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "failed" : 0
  },
  "hits" : {
    "total" : 150,
    "max_score" : 0.0,
    "hits" : [ ]
  }
}

这只是一个计数，但如果您要查看文档，将会启用所有狗，只有猫