python - Whoosh NestedChildren 搜索未返回所有结果

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 那里得到的答案:

<小时/>

I'm making a search index which must support nested hierarchies of data.

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

TL;DR:您使用了错误的查询类型。让我知道您想做什么，我可以告诉您如何做:)

关于嵌套子项

(注意，我发现了一个bug，见文末)

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

NestedChildren 是关于搜索某些 parent ，但将他们的 child 作为命中。

第一个参数是匹配“父”类的所有文档的查询(例如“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 上修复，我必须发布新版本。

干杯，

马特