ElasticSearch requête NEST sur plusieurs types

Question

Compte tenu de la Poços suivante:

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

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

Je voudrais effectuer une requête qui retourne tous les chiens et chats seulement qui sont activés.

Les élastiques docs fournissent l'exemple suivant, mais aucun détail sur la façon d'utiliser un Bool avec contexte de la requête ou le filtre pour rechercher des valeurs de champ spécifiques sur plusieurs types:

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

Comment puis-je effectuer ma requête? , Merci d'avance

Answer 1

Nous pouvons interroger sur le champ de métadonnées _type et combiner cela avec des requêtes sur d'autres domaines. Voici un exemple. Nous allons créer 100 chats et 100 chiens, même le réglage de chaque chat à être désactivé

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") 
     ) 
    ); 
} 

La requête de recherche profite d'une surcharge de l'opérateur; l'opérateur + unaire signifie que la requête sera enveloppé dans une bool requête filter et de même, && se terminera dans une bool requête must (ou filter dans ce cas, nous utilisons aussi le + opérateur unaire pour en faire un filtre), et || va envelopper dans une requête boolshould. La requête exécutée résultant ressemble

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

qui donne

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

Ceci est seulement un compte, mais si vous deviez regarder les documents, ce serait tous les chiens et seuls les chats qui sont activés