Question

我正在制作一个搜索索引，它必须支持嵌套的数据层次结构。出于测试目的，我正在制作一个非常简单的模式：

test_schema = Schema(
    name_ngrams=NGRAMWORDS(minsize=4, field_boost=1.2),
    name=TEXT(stored=True),
    id=ID(unique=True, stored=True),
    type=TEXT
)

对于测试数据我正在使用这些：

test_data = [
    dict(
        name=u'The Dark Knight Returns',
        id=u'chapter_1',
        type=u'chapter'),
    dict(
        name=u'The Dark Knight Triumphant',
        id=u'chapter_2',
        type=u'chapter'),
    dict(
        name=u'Hunt The Dark Knight',
        id=u'chapter_3',
        type=u'chapter'),
    dict(
        name=u'The Dark Knight Falls',
        id=u'chapter_4',
        type=u'chapter')
]

parent = dict(
    name=u'The Dark Knight Returns',
    id=u'book_1',
    type=u'book')

我已将所有（5）文档添加到索引中，如下所示

with index_writer.group():
    index_writer.add_document(
        name_ngrams=parent['name'],
        name=parent['name'],
        id=parent['id'],
        type=parent['type']
    )
    for data in test_data:
        index_writer.add_document(
            name_ngrams=data['name'],
            name=data['name'],
            id=data['id'],
            type=data['type']
        )

因此，要获得一本书的所有章节，我已经创建了一个使用NestedChildren搜索的函数：

def search_childs(query_string):
    os.chdir(settings.SEARCH_INDEX_PATH)
    # Initialize index
    index = open_dir(settings.SEARCH_INDEX_NAME, indexname='test')
    parser = qparser.MultifieldParser(
        ['name',
         'type'],
        schema=index.schema)
    parser.add_plugin(qparser.FuzzyTermPlugin())
    parser.add_plugin(DateParserPlugin())

    myquery = parser.parse(query_string)

    # First, we need a query that matches all the documents in the "parent"
    # level we want of the hierarchy
    all_parents = And([parser.parse(query_string), Term('type', 'book')])

    # Then, we need a query that matches the children we want to find
    wanted_kids = And([parser.parse(query_string),
                       Term('type', 'chapter')])
    q = NestedChildren(all_parents, wanted_kids)
    print q

    with index.searcher() as searcher:
        #these results are the parents
        results = searcher.search(q)
        print "number of results:", len(results)
        if len(results):
            for result in results:
                print(result.highlights('name'))
                print(result)
            return results

但是对于我的测试数据，如果我搜索“dark knigth”，那么当它必须是4个搜索结果时，我只得到3个结果。

我不知道是否因为与书名相同而排除了遗漏的结果，但它根本没有显示在搜索结果中

我知道所有项目都在索引中，但我不知道我在这里缺少什么。

有什么想法吗？

Answer 1

原来我使用的是NestedChildren错误。以下是我在Google网上论坛中从Matt Chaput获得的答案：

我正在制作一个必须支持嵌套数据层次结构的搜索索引。

NestedChildren的第二个参数不是你想象的那样。

TL; DR：您使用的是错误的查询类型。让我知道你要做什么，我可以告诉你如何做到这一点：）

关于嵌套儿童

（注意，我发现了一个错误，请看结束）

NestedChildren很难理解，但希望我能尝试更好地解释它。

NestedChildren是关于搜索某些父母，但是将他们的孩子作为命中。

第一个参数是匹配“父”类的所有文档的查询（例如“type：book”）。第二个参数是一个查询，它匹配与您的搜索条件匹配的父类的所有文档（例如“type：book AND name：dark”）。

在您的示例中，这意味着搜索某本书，但将其章节作为搜索结果。

这本身并不是非常有用，但是你可以将它与对孩子的查询结合起来进行复杂的查询，例如“在他们的名字中用'狩猎'给我看章节，在他们名字中有'黑暗'的书中“：

# Find the children of books matching the book criterion
all_parents = query.Term("type", "book")
wanted_parents = query.Term("name", "dark")
children_of_wanted_parents = query.NestedChildren(all_parents, wanted_parents)

# Find the children matching the chapter criterion
wanted_chapters = query.And([query.Term("type", "chapter"),
                             query.Term("name", "hunted")])

# The intersection of those two queries are the chapters we want
complex_query = query.And([children_of_wanted_parents,
                           wanted_children])

或者，至少，它应该如何运作。但是我刚刚在NestedChildren的skip_to（）方法的实现中发现了一个错误，它使上面的例子不起作用:( :( :(现在修复了Bitbucket上的bug，我将不得不发布一个新版本。

干杯，

马特

Whoosh NestedChildren搜索不返回所有结果

1 个答案: