Elastic .Nest Equivelent de field_value_factor

Question

J'ai besoin de réviser une méthode qui construit un SearchDescriptor en utilisant .Nest afin que le score soit plus élevé pour résultats de recherche de produits pour les articles ayant un prix contractuel (valeur de zéro).

J'ai capturé la version sérialisée de la requête ajoutée "field_value_factor" pour retourner les résultats dans l'ordre désiré. Je n'ai pas déterminé comment réaliser ceci dans l'instruction de requête .Nest.

Quelqu'un peut-il recommander comment réviser les instructions client .NEST pour produire le même descripteur de recherche?

Merci

Voici la requête que nous voulons réaliser où vous verrez field_value_factor en bas:

{ 
     "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" 
      } 
     } 
    } 
} 

est inférieure à la méthode actuelle qui construit le SearchDescriptor:

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

Votre requête JSON n'est pas valide. field_value_factor est une fonction d'une requête function_score. Dans 1.x NEST, cela ressemblerait

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

qui produit la requête

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