带二次排序的 GAE 文本搜索

Question

我使用下面的解决方案来代替 GAE 上的全文搜索，返回一个已排序的结果集，首先按关键字相关性，其次按日期（尽管第二次排序可能是任何实际排序）。它感觉有点笨重，我担心大规模的性能，所以我正在寻找优化建议或完全不同的方法。

二次排序对我的用例很重要，因为给定的搜索可能会具有相同相关性的多个结果（通过关键字匹配的数量来衡量），但保留原始查询顺序现在会增加很多复杂性。有什么想法吗？

第 1 步：获取与每个搜索词匹配的键列表

results_key_list = []
search_terms = ['a','b','c'] #User's search query, split into a list of strings

#query each search term and add the results to a list
#yields a list of keys with frequency of occurance indicating relevance     
for item in search_terms:
    subquery = SomeEntity.all(keys_only=True)                   
    subquery.filter('SearchIndex = ', item) #SearchIndex is a StringListProperty
    #more filters...            
    subquery.order('-DateCreated')                  
    for returned_item in subquery:
        results_key_list.append(str(returned_item))     

第 2 步：按频率对列表进行分组，同时保持原始顺序

#return a dictionary of keys, with their frequency of occurrence            
grouped_results = defaultdict(int)              
for key in results_key_list:
    grouped_results[key] += 1               

sorted_results = []
known = set()

#creates an empty list for each match frequency 
for i in range(len(search_terms)):
    sorted_results.append([])

#using the original results ordering, 
#construct an array of results grouped and ordered by descending frequency  
for key in results_key_list:
    if key in known: continue
    frequency = grouped_results[key]
    sorted_results[len(search_terms) - frequency].append(key)
    known.add(key)          

#combine into a single list
ordered_key_list = []   
for l in sorted_results:
    ordered_key_list.extend(l)  

del ordered_key_list[:offset]
del ordered_key_list[limit:]    
result = SomeEntity.get(ordered_key_list)

Answer 1

search_terms = ['a','b','c'] #User's search query, split into a list of strings

您可以按照出现的顺序累积按键
并且可以一次性建立所有关键频率。
利用排序稳定性通过降低频率然后按出现顺序进行排序：

keys_in_order_of_appearance = []
key_frequency = defaultdict(int)

for item in search_terms:
    subquery = SomeEntity.all(keys_only=True)                   
    subquery.filter('SearchIndex = ', item) #SearchIndex is a StringListProperty
    #more filters...            
    subquery.order('-DateCreated')                  
    for returned_item in subquery:
        key = str(returned_item)
        if key not in key_frequency:
            key_order_of_appearance.append(key)
        key_frequency[key] += 1

keys = keys_in_order_of_appearance[:]   # order of appearance kept as secondary sort
keys.sort(key=key_frequency.__getitem__, reverse=True) # descending freq as primary sort
result = SomeEntity.get(ordered_key_list)

Answer 2

在步骤 1 中，您将迭代查询对象。这会导致每返回 20 个对象需要一次 fetch RPC，这在时间上效率低下。相反，对 Query 对象调用 fetch(n)，其中 n 是要返回的最大结果数 - 这仅执行一次 RPC。它还具有限制搜索结果数量的好处 - 现在，如果我搜索“I”，您的应用程序将在处理步骤 1 中的几乎每条记录时陷入困境。

也完全没有必要将键转换为字符串 - 您可以将键添加到集合中就好了。

不过，就其价值而言，我个人认为“或”搜索特别无用。我意识到您会首先对与所有术语匹配的项目进行排名，但后面不可避免地会出现一堆堆不相关的结果。您只需对每个搜索词使用等式过滤器执行一次查询即可进行“与”搜索。