Elasticsearch muss nach mehreren Typen mit typspezifischer Where-Klausel suchen

Question

Ich habe einen Es-Index mit mehreren Typen und jeder Typ bietet eigene Filterparameter. Jetzt erstellen wir eine globale Suche in Es für mehrere Typen und ich bin etwas verwirrt, wie man die type where-Klausel verwendet, die in NEST enthalten sein soll. Elasticsearch -> Typ 1 (wobei x = 1) -> Typ 2 (wobei y = 1)

Jetzt bauen wir eine Suchabfrage

var result = client.Search<ISearchDto>(s => s 
 
       .From(from) 
 
       .Size(PageSize) 
 
       .Types(lstTypes) 
 
       .Query(q => q.QueryString(qs => qs.Query(query))) 
 
       );

* lstTypes haben Typ 1 und Typ 2

Nun, wie kann ich die Where-Klausel für alle Typ-1-Elemente mit x = 1 und für alle Typ-2-Elemente mit y = 1 in NEST hinzufügen.

Hoffe, die Frage ist klar, jede Hilfe zu diesem wird sehr geschätzt.

Answer 1

Sie können auf das _type Meta-Feld auf die gleiche Weise abfragen, wie Sie in einem anderen Feld abfragen. Um verschiedene Abfragen durchführen, basierend auf Art innerhalb einer Suchabfrage können Sie eine bool Abfrage mit mehreren Klauseln verwenden

client.Search<ISearchDto>(s => s 
    .From(from) 
    .Size(pageSize) 
    .Type(Types.Type(typeof(FirstSearchDto), typeof(SecondSearchDto))) 
    .Query(q => q 
     .Bool(b => b 
      .Should(sh => sh 
       .Bool(bb => bb 
        .Filter(
         fi => fi.Term("_type", "firstSearchDto"), 
         fi => fi.Term(f => f.X, 1) 
        ) 
       ), sh => sh 
       .Bool(bb => bb 
        .Filter(
         fi => fi.Term("_type", "secondSearchDto"), 
         fi => fi.Term(f => f.Y, 1) 
        ) 
       ) 
      ) 
     ) 
    ) 
); 

Wir haben eine bool Abfrage mit 2 should Klauseln; Jede should -Klausel ist eine bool Abfrage mit der Konjunktion von 2 filter Klauseln, eine für _type und die andere für die Eigenschaft für jeden Typ jeweils abgefragt werden.

NEST unterstützt Betreiber Überlastung so kann diese Abfrage mehr mit

client.Search<ISearchDto>(s => s 
    .From(from) 
    .Size(pageSize) 
    .Type(Types.Type(typeof(FirstSearchDto), typeof(SecondSearchDto))) 
    .Query(q => (+q 
     .Term("_type", "firstSearchDto") && +q 
     .Term(f => f.X, 1)) || (+q 
     .Term("_type", "secondSearchDto") && +q 
     .Term(f => f.Y, 1)) 
    ) 
); 

Sowohl der folgenden Abfrage produzieren kurz und bündig geschrieben wird

{ 
    "from": 0, 
    "size": 20, 
    "query": { 
    "bool": { 
     "should": [ 
     { 
      "bool": { 
      "filter": [ 
       { 
       "term": { 
        "_type": { 
        "value": "firstSearchDto" 
        } 
       } 
       }, 
       { 
       "term": { 
        "x": { 
        "value": 1 
        } 
       } 
       } 
      ] 
      } 
     }, 
     { 
      "bool": { 
      "filter": [ 
       { 
       "term": { 
        "_type": { 
        "value": "secondSearchDto" 
        } 
       } 
       }, 
       { 
       "term": { 
        "y": { 
        "value": 1 
        } 
       } 
       } 
      ] 
      } 
     } 
     ] 
    } 
    } 
}