Question

使用弹性“ number”：“ 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'，或者我认为搜索中的第一个单词是搜索中最重要的值？我应该使用术语查询吗？

示例...现在...如果我搜索'alpha'...我会返回结果，其中文档中的field1是'prealpitate'。不知道为什么，因为EdgeNGram应该从“边缘”开始而不是在中间。

Answer 1

好，我现在无法测试，但应该是这样的（在此Labtop上无法测试）

第一个必须返回所有带有alpha OR（beta和Delta）的文档应该使用alpha AND beta AND delta（运算符and）来增强文档最后一个应该仅使用Alpha增强文档当然，您可以在之间添加alpha AND（βOR delta）来增强效果

希望有帮助

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)
                        )
                )
)

NEST：Elastic Search改善查询

1 个答案: