NEST FunctionScore() returns all indexed items before adding functions, throws exceptions after adding them

Question

Alright, so the query works perfectly in Sense in Chrome. I use the following query:

{
"size":127,
"query": {
    "function_score": {
        "query": {
            "bool": {
                "must": [
                    {
                        "prefix": {
                            "name": {
                                "value": "incomp"
                            }
                        }
                    },
                    {
                        "match": {
                            "name": "a word that is"
                        }
                    }
                ]
            }
        },
        "functions": [
            {
                "exp": {
                    "date": {
                        "origin": "now/d",
                        "scale": "3w",
                        "offset": "10d",
                        "decay": "0.88"
                    }
                }
            }
        ]
    }
}
}

In short, I match on the indexed "name" property of a custom type in ES, giving priority to recently added items and supporting "suggestions as you type" - thus the prefix query. It works perfectly well, tuned as it is, so my next step would be to reproduce in NEST.

However, I'm facing some issues with the .NET NEST code below:

var results4 = _client.Search<customDataType>(
s => s.Size(5030)
.Query(q => q
    .FunctionScore(fs => fs
        .Name("another_named_query")
        .BoostMode(FunctionBoostMode.Multiply)
        .ScoreMode(FunctionScoreMode.Multiply)
        .Query(qu => qu
            .Bool(b => b
                .Must(m => m
                    .Prefix(p => p
                        .Field(ff => ff.Name)
                        .Value(prefixVal)))
                .Must(m2 => m2
                    .Match(mh => mh
                        .Field(f2 => f2.Name)
                        .Query(stringBeforePrefixVal)))))                                  
        /*.Functions( fcs => fcs.ExponentialDate(
            exp => exp
            .Origin(DateMath.Now)
            .Scale(new Time(1814400000))
            .Offset(new Time(864000000))
            .Decay(0.88d))
        )*/)));

I can't figure out why any attempt to use the "FunctionScore" method results in what a MatchAll() would do - all records are returned.

Meanwhile, when adding the Functions (commented above) I get an UnexpectedElasticsearchClientException with a NullReference inner exception at Nest.FieldResolver.Resolve(Field field) in C:\code\elasticsearch-net\src\Nest\CommonAbstractions\Infer\Field\FieldResolver.cs:line 31.

I'm baffled by all of this, and there don't seem to be similar problems that I can use as a starting point. Is there anything I can do to get the query above running, or should I resort to manually doing a restful API call?

Answer 1

Almost correct, but you're missing the field on which the exponential date decay function should run. Assuming your POCO looks like

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

    public DateTime Date { get; set; }
}

the query would be

var prefixVal = "incomp";
var stringBeforePrefixVal = "a word that is";

var results4 = client.Search<customDataType>(s => s
    .Size(5030)
    .Query(q => q
        .FunctionScore(fs => fs
            .Name("another_named_query")
            .BoostMode(FunctionBoostMode.Multiply)
            .ScoreMode(FunctionScoreMode.Multiply)
            .Query(qu => qu
                .Bool(b => b
                    .Must(m => m
                        .Prefix(p => p
                            .Field(ff => ff.Name)
                            .Value(prefixVal)))
                    .Must(m2 => m2
                        .Match(mh => mh
                            .Field(f2 => f2.Name)
                            .Query(stringBeforePrefixVal)))))
            .Functions(fcs => fcs
                .ExponentialDate(exp => exp
                    .Field(f => f.Date)
                    .Origin("now/d")
                    .Scale("3w")
                    .Offset("10d")
                    .Decay(0.88)
                )
            )
        )
    )
);

which yields

{
  "size": 5030,
  "query": {
    "function_score": {
      "_name": "another_named_query",
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "name": {
                  "query": "a word that is"
                }
              }
            }
          ]
        }
      },
      "functions": [
        {
          "exp": {
            "date": {
              "origin": "now/d",
              "scale": "3w",
              "offset": "10d",
              "decay": 0.88
            }
          }
        }
      ],
      "score_mode": "multiply",
      "boost_mode": "multiply"
    }
  }
}

You can take advantage of operator overloading in NEST to shorten the bool query further, by &&ing the prefix and match query

var results4 = client.Search<customDataType>(s => s
    .Size(5030)
    .Query(q => q
        .FunctionScore(fs => fs
            .Name("another_named_query")
            .BoostMode(FunctionBoostMode.Multiply)
            .ScoreMode(FunctionScoreMode.Multiply)
            .Query(qu => qu
                .Prefix(p => p
                    .Field(ff => ff.Name)
                    .Value(prefixVal)
                ) && qu  
                .Match(mh => mh
                    .Field(f2 => f2.Name)
                    .Query(stringBeforePrefixVal)
                )
            )
            .Functions(fcs => fcs
                .ExponentialDate(exp => exp
                    .Field(f => f.Date)
                    .Origin("now/d")
                    .Scale("3w")
                    .Offset("10d")
                    .Decay(0.88)
                )
            )
        )
    )
);