NEST：弹性搜索改进查询

Question

使用弹性“数字”：“6.3.1”“lucene_version”：“7.3.1”NEST：6.1.0

我正在努力提高返回结果，因为我得到了太多不相关的记录并且看起来很糟糕。

 protected override CreateIndexDescriptor DefineIndex(string indexName)
    {
        return new CreateIndexDescriptor(indexName)
            .Settings(s => s
                .Analysis(a => a
                    .Analyzers(aa => aa
                        .Custom("my_analyzer", pa => pa
                            .Tokenizer("my_tokenizer")
                            .Filters("standard", "lowercase")
                        )
                    )
                    .Tokenizers(ta => ta
                        .EdgeNGram("my_tokenizer", t => t
                             .MinGram(2)
                             .MaxGram(17)
                             .TokenChars(TokenChar.Letter, TokenChar.Whitespace, TokenChar.Digit)
                            )
                    )
                )
            )
            .Mappings(ms => ms
                .Map<MySearch>(m => m
                    .Properties(p => p
                        .Text(s => s
                            .Name("Field1")
                            .Analyzer("my_analyzer")
                            .SearchAnalyzer("my_analyzer")
                            .Fields(fs => fs
                                .Keyword(ss => ss
                                    .Name("raw")
                                )
                            )
                        )
                    )
                ));
    }

查找搜索是

public void Lookup(string searchValue, int pageNumber, int pageSize)
    {
        var result = _client.Search<MyModel>(x => x
            .From((pageNumber - 1) * pageSize)
            .Size(pageSize)
            .Index("myindex")
            .Query(qq => qq
                .MultiMatch(mm => mm
                    .Query(searchValue.ToLowerInvariant().Trim())          
                    .Fields(f => f
                        .Field(ff => ff.Field1, 5.0)
                        .Field(ff => ff.Field2)
                        .Field(ff => ff.Field3)
                    )
                )
            )
        );
    }

现在我希望Field1具有更多相关性，所以我将它提升了5倍。

我正在搜索文本“alpha（beta delta）”

我目前的问题是'alpha'是我正在寻找的主要关键字。正如您所见，我需要搜索多个字段。我需要所有匹配'alpha'才能首先出现。 'beta'实际上只是很好的搜索匹配，如果它与'delta'。但是现在我拥有的东西，它会返回匹配'beta'匹配的匹配，因为它在我的数据集中是一个更通用的术语。

我如何制作'alpha'，或者我认为搜索中的第一个单词是搜索中最重要的值？我应该使用Term查询吗？

示例...现在......如果我搜索'alpha'...我得到的结果是文档中的field1是'prealpitate'。不确定为什么因为EdgeNGram应该从'边缘'而不是在中间开始。

Answer 1

好吧我现在不能测试，但应该是这样的（不要在这台笔记本电脑上测试）

第一个必须返回所有文档与alpha OR（beta和Delta）应该会提升doc与alpha和beta和delta（运算符和）最后应该会提升doc只有alpha当然你可以添加增强与alpha和（beta OR三角洲之间

希望它有所帮助

split your searchValue in a searchValue[]
.Bool(bo => bo.
.Must(Bool(bo => bo
              .Should(
                  sh => sh.Term(te => te.Field1, searchValue[0]),
                  sh => sh.Bool(
                      boo => boo
                         .Should(
                            sho => sho.Term(te => te.Field2, searchValue[1]),
                            sho => sho.Term(te => te.Field3, searchValue[2])
                          )
                       )
                   )
                )
            )
.Should(MultiMatch(mm => mm
                    .Query(searchValue.ToLowerInvariant().Trim())          
                    .Fields(f => f
                        .Field(ff => ff.Field1)
                        .Field(ff => ff.Field2)
                        .Field(ff => ff.Field3)
                    )
                    .Operator(Operator.And)
                    .Boost(15)
                )
)
.Should(Bool(bo => bo
                        .Must(ff => ff.Term(te => te.Field1, searchValue[0]))
                        .MustNot(ff => ff
                            .Bool(
                                boo => boo
                                    .Should(
                                        sh => sh.Term(te => te.Field2, searchValue[1]),
                                        sh => sh.Term(te => te.Field3, searchValue[2])
                                    )
                                )
                            )
                        .Boost(10)
                        )
                )
)