Elastic .Nest Equivalent von field_value_factor

Question

Ich muss eine Methode überarbeiten, die einen SearchDescriptor mit .Nest erstellt, so dass das Ergebnis für Produktsuchergebnisse für Artikel mit einem Vertragspreis (Wert von Null) höher ist.

Ich erfasst die serialisierte Version der Abfrage hinzugefügt "field_value_factor", um die Ergebnisse in der gewünschten Reihenfolge zurückzugeben. Ich habe nicht bestimmt, wie dies in der .Nest-Abfrageanweisung erreicht wird.

Kann jemand empfehlen, die .NEST-Clientanweisungen zu überarbeiten, um denselben Suchdeskriptor zu erstellen?

Danke

Unten ist die Abfrage, die wir erreichen wollen, wo Sie field_value_factor am Boden sehen:

{ 
     "from": 0, 
    "size": 3000, 
    "sort": [ 
    { 
     "_score": { 
     "order": "desc" 
     } 
    }, 
    { 
     "priceStatus": { 
     "order": "asc" 
     } 
    }, 
    { 
     "unitPrice": { 
     "order": "asc" 
     } 
    } 
    ], 
    "aggs": { 
    "PriceStatus": { 
     "terms": { 
     "field": "priceStatus", 
     "size": 5 
     } 
    }, 
    "VendorName": { 
     "terms": { 
     "field": "vendorName", 
     "size": 5 
     } 
    }, 
    "CatalogName": { 
     "terms": { 
     "field": "catalogName", 
     "size": 5 
     } 
    }, 
    "ManufacturerName": { 
     "terms": { 
     "field": "manufacturerName", 
     "size": 5 
     } 
    }, 
    "IsGreen": { 
     "terms": { 
     "field": "isGreen", 
     "size": 5 
     } 
    }, 
    "IsValuePack": { 
     "terms": { 
     "field": "isValuePack", 
     "size": 5 
     } 
    }, 
    "UnitOfMeasure": { 
     "terms": { 
     "field": "unitOfMeasure", 
     "size": 5 
     } 
    }, 
    "Attributes": { 
     "nested": { 
     "path": "attributes" 
     }, 
     "aggs": { 
     "TheAttributeName": { 
      "terms": { 
      "field": "attributes.name", 
      "size": 10 
      }, 
      "aggs": { 
      "TheAttributeValue": { 
       "terms": { 
       "field": "attributes.value", 
       "size": 5 
       } 
      } 
      } 
     } 
     } 
    } 
    }, 
    "query": { 
    "function_score": { 
     "query": { 
     "bool": { 
      "should": [ 
      { 
       "multi_match": { 
       "type": "phrase", 
       "query": "pen", 
       "slop": 3, 
       "boost": 16.0, 
       "fields": [ 
        "itemNumber*^4", 
        "shortDescription*^4", 
        "subCategory1Name*^1.5", 
        "subCategory2Name*^2.0", 
        "categoryName*^0.9", 
        "longDescription*^0.6", 
        "catalogName*^0.30", 
        "manufactureName*^0.20", 
        "vendorName*^0.15", 
        "upcCode*^0.10" 
       ] 
       } 
      }, 
      { 
       "multi_match": { 
       "query": "pen", 
       "boost": 15.0, 
       "minimum_should_match": "75%", 
       "fields": [ 
        "itemNumber*^4", 
        "shortDescription*^4", 
        "subCategory1Name*^1.5", 
        "subCategory2Name*^2.0", 
        "categoryName*^0.9", 
        "longDescription*^0.6", 
        "catalogName*^0.30", 
        "manufactureName*^0.20", 
        "vendorName*^0.15", 
        "upcCode*^0.10" 
       ] 
       } 
      }, 
      { 
       "multi_match": { 
       "query": "pen", 
       "fuzziness": 1.0, 
       "slop": 2, 
       "minimum_should_match": "75%", 
       "fields": [ 
        "itemNumber*^4", 
        "shortDescription*^4", 
        "subCategory1Name*^1.5", 
        "subCategory2Name*^2.0", 
        "categoryName*^0.9", 
        "longDescription*^0.6", 
        "catalogName*^0.30", 
        "manufactureName*^0.20", 
        "vendorName*^0.15", 
        "upcCode*^0.10" 
       ] 
       } 
      } 
      ] 
     } 
     }, 
     "filter": { 
     "bool": { 
      "must": [ 
      { 
       "terms": { 
       "catalogId": [ 
        "fbb3dd2c-f81c-4ff3-bd5b-9c2cffc51540" 
       ] 
       } 
      } 
      ] 
     } 
     }, 
      "field_value_factor": { 
       "field": "priceStatus", 
       "factor": -1, 
       "modifier": "none" 
      } 
     } 
    } 
} 

Im Folgenden finden Sie die aktuelle Methode, die das SearchDescriptor baut:

private SearchDescriptor<SearchItem> BuildSearchDescriptor(
     string searchTerm, 
     IList<Guid> catalogIds, 
     int from, 
     int size, 
     string index, 
     string preference, 
     int attrSize, 
     int valueSize, 
     Dictionary<string, string[]> filterProps, 
     Dictionary<string, string[]> filterAttrs, 
     Guid? categoryId) 
    { 
     var searchDescriptor = new SearchDescriptor<SearchItem>() 
      .From(from) 
      .Size(size) 
      .Query(q => 
       q.Filtered(fd => BuildFilterTerms(fd, filterProps, filterAttrs, catalogIds, categoryId) 
        .Query(iq => BuildQueryContainer(iq, searchTerm)) 
       )      
      ) 
      .Index(index) 
      .Preference(preference) 
      .Aggregations(agg => BuildAggregationDescriptor(agg, attrSize, valueSize, catalogIds.Count))   
      .Sort(sort => sort.OnField("_score").Descending()) 
      .SortAscending(p=> p.PriceStatus) 
      .SortAscending(p => p.UnitPrice); 

     // Debug the raw string that will post to the ES servers i.e. use this in postman 
     //var str = System.Text.Encoding.UTF8.GetString(client.Serializer.Serialize(searchDescriptor)); 

     return searchDescriptor; 
    } 

Answer 1

Ihre JSON-Abfrage ist nicht gültig. field_value_factor ist eine Funktion einer function_score Abfrage. In NEST 1.x, würde dies aussehen

var response = client.Search<Document>(x => x 
    .Query(q => q 
     .FunctionScore(fs => fs 
      .Functions(fu => fu 
       .FieldValueFactor(fvf => fvf 
        .Field(f => f.PriceStatus) 
        .Factor(-1) 
        .Modifier(FieldValueFactorModifier.None) 
       ) 
      ) 
     ) 
    ) 
); 

public class Document 
{ 
    public string Title { get; set; } 

    public int PriceStatus { get; set; } 
} 

, die die Abfrage

{ 
    "query": { 
    "function_score": { 
     "functions": [ 
     { 
      "field_value_factor": { 
      "field": "PriceStatus", 
      "factor": -1.0, 
      "modifier": "none" 
      } 
     } 
     ] 
    } 
    } 
}