sorting - Elasticsearch.Net用NEST计算自定义文档项目得分

Question

我有一个问题需要您的帮助。我在文档上的客户来源具有unitid字段。我想将当前的单位客户列为第一位。因此，我尝试使用脚本评分，但是所有文档项目的评分均被计算为0，但从未成功。成功得分后，我将按得分对结果进行排序。
这是我的过滤器脚本；

.ScriptScore(s => s
    .Script(ss => ss
        .Source($"doc['unitid'].value == params.unitid ? _score = 1 : _score = 0")
        .Params(new Dictionary<string, object>() { { "unitid", filter.UnitId } })
    )
)

这就是我的全部查询；

.Query(q => q
.Bool(b => b
    .Filter(m => m
        .Prefix(t => t.CustomerName, filter.CustomerName?.ToUpper()) && m
        .Terms(t => t
            .Field(f => f.CustomerTypeId)
            .Terms(new List<int> { 2, 3 })
        ) && m
        .ScriptScore(s => s
            .Script(ss => ss
                .Source($"doc['unitid'].value == params.unitid ? _score = 1 : _score = 0")
                .Params(new Dictionary<string, object>() { { "unitid", 272 } })
            )
        )
    )
))
.Aggregations(a => a
    .Terms("distinct_accounts", c => c
        .Field(x => x.AccountId
            .Suffix("keyword")
        )
    ))
.Sort(s => s
    .Descending("_score")
    .Descending(a => a.ModifyDate));

结果，我在哪里做错了，请您能帮我吗？

Answer 1

脚本分数查询的源脚本需要返回分数值，而不是将其分配给诸如_score之类的变量

.ScriptScore(s => s
    .Script(ss => ss
        .Source($"doc['unitid'].value == params.unitid ? 1 : 0")
        .Params(new Dictionary<string, object>() { { "unitid", filter.UnitId } })
    )
)

编辑:
刚刚注意到，脚本分数查询没有 .Query()部分，但是它需要一个完整的查询。另外，查询是 inside a bool query filter clause, meaning that scoring is ignored。
通常，通过提高特定查询的得分，可以对您要解决的潜在问题进行更多思考，从而为某些文档提供比其他文档更高的分数。例如

var client = new ElasticClient();

var filter = new 
{
    CustomerName = "foo",
    UnitId = 1
};

var response = client.Search<Product>(s => s
    .Query(q => q
        .Bool(b => b
            .Should(s => s
                .Term(t => t
                    .Boost(10)
                    .Field("unitid")
                    .Value(filter.UnitId)
                )
            )
            .Filter(fi => fi
                .Prefix(t => t.CustomerName, filter.CustomerName?.ToUpper()), 
                    fi => fi
                .Terms(t => t
                    .Field(f => f.CustomerTypeId)
                    .Terms(new List<int> { 2, 3 })
                )
            )
        )
    )
    .Aggregations(a => a
        .Terms("distinct_accounts", c => c
            .Field(x => x.AccountId
                .Suffix("keyword")
            )
        )
    )
    .Sort(s => s
        .Descending("_score")
        .Descending(a => a.ModifyDate)
    )
);

产生查询

{
  "aggs": {
    "distinct_accounts": {
      "terms": {
        "field": "accountId.keyword"
      }
    }
  },
  "query": {
    "bool": {
      "filter": [{
          "prefix": {
            "customerName": {
              "value": "FOO"
            }
          }
        },
        {
          "terms": {
            "customerTypeId": [
              2,
              3
            ]
          }
        }
      ],
      "should": [{
        "term": {
          "unitid": {
            "value": 1,
            "boost": 10.0
          }
        }
      }]
    }
  },
  "sort": [{
      "_score": {
        "order": "desc"
      }
    },
    {
      "modifyDate": {
        "order": "desc"
      }
    }
  ]
}

在这里，如果文档的 unitid值为1，则其分数会提高十倍。我认为无论如何实际上都不需要提高，因为 unitid值不为1的文档将没有分数，而其他查询位于过滤器分数中，因此不会对分数有所贡献。在存在 unitid子句的情况下，在 should子句中对 filter进行术语查询时，此查询可作为增强信号，因为文档不需要与要返回的查询匹配，但如果匹配，则 should子句中的分数将被添加到其他查询的分数中以形成总体分数，我认为这将达到您想要的目标。