Redis搜尋技術深度解析與實作

– 11 分鐘閱讀

在資料量日益增長的今天，高效的搜尋功能對於應用程式至關重要。Redis 作為一個記憶體資料函式庫，提供豐富的資料結構和指令，使其成為實作快速搜尋的理想選擇。本文將探討如何在 Redis 中建構搜尋功能，從索引建立、查詢解析到結果排序，逐步解析 Redis 搜尋技術的核心概念和實作技巧。首先，我們會探討如何利用 SET 建立反向索引，並搭配 SINTER、SUNION 和 SDIFF 等指令實作基本的搜尋功能。接著，我們將探討如何利用 SORT 指令對搜尋結果進行排序，以及如何使用 ZSET 實作更複雜的複合排序需求。最後，我們將探討一些進階的搜尋技術，例如停用詞處理、同義詞搜尋等，並分析 Redis 搜尋功能。

在Redis中進行搜尋

在Redis中建立搜尋功能是組織和搜尋資訊的關鍵步驟。首先，我們來探討在Redis中進行搜尋的意義。

搜尋的基本理論

在檔案或文書處理軟體中搜尋特定的詞彙或片語時，軟體會掃描整個檔案以找到匹配的結果。當處理的檔案數量和大小增加時，搜尋的速度會明顯變慢。與此相反，網頁搜尋引擎能夠在龐大的資料函式庫中快速找到相關內容。Redis提供了一種解決方案，可以顯著提高搜尋效率。

反向索引（Inverted Index）

要實作快速搜尋，需要對檔案進行預處理，建立反向索引。反向索引是一種資料結構，能夠快速定位包含特定詞彙的檔案。Redis中的SET和ZSET資料結構非常適合用於建立反向索引。

建立反向索引的步驟

  1. 詞彙解析（Tokenization）：將檔案內容分解成個別的詞彙。
  2. 移除停用詞（Stop Words）：過濾掉常見但無實際意義的詞彙，如「the」、「and」等。
  3. 建立索引：為每個詞彙建立一個SET，包含所有包含該詞彙的檔案ID。

實作範例

假設我們有兩個檔案：docA 和 docB，內容分別為「lord of the rings」和「lord of the dance」。經過詞彙解析和停用詞移除後，我們可以建立以下反向索引：

  • lord：包含 docA 和 docB
  • rings：包含 docA
  • dance：包含 docB
  • of：包含 docA 和 docB

Redis中的實作

# 對docA建立索引
SADD ind:lord docA
SADD ind:of docA
SADD ind:rings docA

# 對docB建立索引
SADD ind:lord docB
SADD ind:of docB
SADD ind:dance docB

內容解密：

上述程式碼示範瞭如何使用Redis的SET資料結構建立反向索引。SADD命令用於將檔案ID加入到對應的詞彙SET中。這樣，當需要搜尋包含特定詞彙的檔案時，可以直接查詢對應的SET。

搜尋功能的實作

利用建立好的反向索引，可以快速實作搜尋功能。例如，要搜尋同時包含「lord」和「rings」的檔案，可以使用Redis的SINTER命令：

SINTER ind:lord ind:rings

內容解密：

SINTER命令用於計算多個SET的交集。在這個例子中，它會傳回同時包含「lord」和「rings」的檔案ID，即 docA。

圖表翻譯：

  graph LR
    A[原始內容] -->|詞彙解析|> B[詞彙列表]
    B -->|移除停用詞|> C[過濾後的詞彙]
    C -->|建立索引|> D[反向索引]
    D -->|搜尋|> E[搜尋結果]

圖表翻譯： 此圖示展示了從原始內容到搜尋結果的完整流程。首先對原始內容進行詞彙解析，生成詞彙列表。接著移除停用詞，得到過濾後的詞彙。然後，利用這些詞彙建立反向索引。最後，透過查詢反向索引實作快速搜尋。

隨著資料量的不斷增長和搜尋需求的多樣化，未來可以考慮引入更先進的搜尋技術，如自然語言處理（NLP）和機器學習（ML），來進一步提高搜尋的準確性和效率。同時，也可以探索使用Redis的更多功能，如Redis Stack中的搜尋模組，來簡化搜尋功能的實作。

最終，透過結合Redis的強大功能和適當的搜尋技術，可以建立一個高效、準確的搜尋系統，滿足不同場景下的搜尋需求。

Redis中的搜尋技術

在建構搜尋功能的過程中，其中一個挑戰是建立一個有用的停用詞（stop words）列表。不同的檔案集會有不同的詞頻統計，這可能會影響停用詞的選擇。在列表7.1中，我們包含了一個停用詞列表（來自http://www.textfixer.com/resources/），以及用於分詞和索引檔案的函式，這些函式會考慮要移除的停用詞。

停用詞列表與分詞函式實作

STOP_WORDS = set('''able about across after all almost also am among
an and any are as at be because been but by can cannot could dear did
do does either else ever every for from get got had has have he her
hers him his how however if in into is it its just least let like
likely may me might most must my neither no nor not of off often on
only or other our own rather said say says she should since so some
than that the their them then there these they this tis to too twas us
wants was we were what when where which while who whom why will with
would yet you your'''.split())

WORDS_RE = re.compile("[a-z']{2,}")
def tokenize(content):
    words = set()
    for match in WORDS_RE.finditer(content.lower()):
        word = match.group().strip("'")
        if len(word) >= 2:
            words.add(word)
    return words - STOP_WORDS

def index_document(conn, docid, content):
    words = tokenize(content)
    pipeline = conn.pipeline(True)
    for word in words:
        pipeline.sadd('idx:' + word, docid)
    return len(pipeline.execute())

內容解密：

  1. 停用詞列表：我們預先定義了一個停用詞集合，這些詞在搜尋過程中通常被忽略，因為它們對搜尋結果的相關性幫助不大。
  2. 正規表示式提取詞彙：使用WORDS_RE正規表示式來提取檔案中的詞彙，要求詞彙至少包含兩個字元。
  3. 分詞函式（tokenize）：該函式將檔案內容轉換為小寫，並提取詞彙，去除停用詞後傳回剩餘的詞彙集合。
  4. 索引函式（index_document）：該函式將提取的詞彙與檔案ID建立關聯，將檔案ID新增到對應詞彙的SET中。

從索引中移除檔案

當檔案內容隨時間變化時，我們需要更新索引。一個簡單的方法是在重新索引之前，先將檔案從索引中移除。我們可以透過儲存檔案被索引的詞彙列表來實作這一點，並在重新索引之前進行清理。

基本搜尋功能

在Redis中進行單詞搜尋非常簡單，只需取得該單詞對應的SET中的檔案ID。如果需要搜尋多個單詞的交集，可以使用SINTER或SINTERSTORE命令直接取得這些SET的交集。

def _set_common(conn, method, names, ttl=30, execute=True):
    id = str(uuid.uuid4())
    pipeline = conn.pipeline(True) if execute else conn
    names = ['idx:' + name for name in names]
    getattr(pipeline, method)('idx:' + id, *names)
    pipeline.expire('idx:' + id, ttl)
    if execute:
        pipeline.execute()
    return id

內容解密：

  1. 臨時SET的建立：使用UUID生成一個唯一的臨時SET識別符號。
  2. 事務管道：設定一個事務管道，以確保操作的原子性。
  3. SET操作：根據傳入的方法引數，執行相應的SET操作（如交集、並集、差集）。
  4. 過期時間設定：為臨時SET設定過期時間，預設為30秒，以避免佔用過多記憶體。

搜尋的多樣性需求

在實際應用中，我們可能需要進行同義詞搜尋、排除某些詞彙的搜尋等。Redis提供了SUNION、SDIFF等命令來支援這些複雜的搜尋需求。

  1. 最佳化分詞技術：進一步最佳化分詞技術，以提高搜尋的準確性。
  2. 擴充套件搜尋功能：增加更多的搜尋功能，如模糊搜尋、範圍搜尋等。
  3. 效能最佳化：持續最佳化搜尋效能，以滿足大規模資料的需求。

安全性考量

  1. 資料驗證：確保輸入資料的合法性和安全性。
  2. 許可權控制：對搜尋功能進行許可權控制，以防止未授權存取。
  3. 資料備份：定期備份搜尋索引，以防止資料丟失。

技術選型考量

  1. Redis的優勢：Redis提供了高效的記憶體資料函式庫，適合於實時搜尋場景。
  2. 擴充套件性：考慮到未來資料量的增長，需要設計可擴充套件的搜尋架構。
  3. 相容性：確保搜尋功能與現有系統的相容性。

實際應用場景

  1. 電子商務平台：在電子商務平台中實作商品的快速搜尋。
  2. 檔案管理系統：在檔案管理系統中實作檔案的快速檢索。
  3. 社交媒體：在社交媒體平台中實作內容的快速搜尋。

在Redis中實作搜尋功能

隨著現代應用程式對搜尋功能需求的日益增加，如何高效地實作搜尋功能成為了開發者們關注的焦點。Redis作為一個高效能的鍵值資料函式庫，可以被用來實作搜尋功能。本文將介紹如何在Redis中實作搜尋功能，包括索引的建立、搜尋查詢的解析和執行，以及搜尋結果的排序。

建立索引

為了實作搜尋功能，首先需要對檔案進行索引。索引的建立是透過對檔案內容進行分詞（tokenization），然後將這些詞彙與檔案ID進行對映來實作的。以下是建立索引的程式碼範例：

def index_document(conn, doc_id, content):
    words = tokenize(content)
    pipeline = conn.pipeline(True)
    for word in words:
        pipeline.sadd('idx:' + word, doc_id)
    return len(pipeline.execute())

內容解密：

上述程式碼定義了一個名為index_document的函式，用於將給定的檔案內容進行索引。首先，函式呼叫tokenize函式對檔案內容進行分詞，得到一個詞彙列表。然後，使用Redis的pipeline機制，將每個詞彙與檔案ID的對映關係新增到對應的SET中。這樣，當需要搜尋包含特定詞彙的檔案時，就可以直接從對應的SET中取得相關檔案ID。

搜尋查詢的解析和執行

有了索引之後，就可以實作搜尋功能了。搜尋功能的實作包括兩個主要步驟：搜尋查詢的解析和執行。

搜尋查詢的解析

搜尋查詢的解析是將使用者輸入的查詢字串轉換為可執行的搜尋操作的過程。以下是查詢解析的程式碼範例：

QUERY_RE = re.compile("[+-]?[a-z']{2,}")
def parse(query):
    unwanted = set()
    all = []
    current = set()
    for match in QUERY_RE.finditer(query.lower()):
        word = match.group()
        prefix = word[:1]
        if prefix in '+-':
            word = word[1:]
        else:
            prefix = None
        word = word.strip("'")
        if len(word) < 2 or word in STOP_WORDS:
            continue
        if prefix == '-':
            unwanted.add(word)
            continue
        if current and not prefix:
            all.append(list(current))
            current = set()
        current.add(word)
    if current:
        all.append(list(current))
    return all, list(unwanted)

內容解密：

這個函式首先定義了一個正規表示式QUERY_RE，用於匹配查詢字串中的詞彙。然後，函式遍歷查詢字串中的每個詞彙，根據詞彙字首（+/-）進行不同的處理。如果詞彙前有’-’，則將其視為不需要的詞彙；如果詞彙前有’+’，則將其視為與前一個詞彙是同義詞。最終，函式傳回一個包含所有需要交集的詞彙列表和一個不需要的詞彙列表。

搜尋查詢的執行

查詢解析完成後，就可以執行搜尋操作了。以下是執行搜尋操作的程式碼範例：

def parse_and_search(conn, query, ttl=30):
    all, unwanted = parse(query)
    if not all:
        return None
    to_intersect = []
    for syn in all:
        if len(syn) > 1:
            to_intersect.append(union(conn, syn, ttl=ttl))
        else:
            to_intersect.append(syn[0])
    if len(to_intersect) > 1:
        intersect_result = intersect(conn, to_intersect, ttl=ttl)
    else:
        intersect_result = to_intersect[0]
    if unwanted:
        unwanted.insert(0, intersect_result)
        return difference(conn, unwanted, ttl=ttl)
    return intersect_result

內容解密：

這個函式首先呼叫parse函式解析查詢字串，得到需要交集的詞彙列表和不需要的詞彙列表。然後，對於需要交集的詞彙列表中的每個同義詞列表，如果列表中有多個詞彙，則執行union操作；否則，直接使用該詞彙。接著，對所有需要交集的結果執行intersect操作。如果存在不需要的詞彙，則執行difference操作以排除這些詞彙。最終，函式傳回搜尋結果。

搜尋結果的排序

搜尋結果的排序是根據一定的規則對搜尋結果進行排序，以提供更有用的資訊給使用者。以下是搜尋結果排序的一般思路：

  • 相關性排序：根據檔案與查詢的相關程度進行排序。相關程度可以透過多種因素來評估，例如查詢詞彙在檔案中的出現頻率、位置等。

由於原始程式碼中沒有直接提供排序的實作細節，以下是一般的排序思路：

  1. 計算相關性得分：為每個搜尋結果計算一個相關性得分。這個得分可以根據多種因素，例如詞頻、詞彙位置等。
  2. 排序：根據相關性得分對搜尋結果進行排序。
def sort_results(conn, results, score_func, desc=True):
    # 假設score_func是一個函式，能夠根據檔案ID計算其相關性得分
    scores = {doc_id: score_func(doc_id) for doc_id in results}
    return sorted(scores, key=scores.get, reverse=desc)

內容解密：

這個函式接受搜尋結果和一個用於計算相關性得分的函式作為輸入。首先，它為每個搜尋結果計算相關性得分。然後，根據這些得分對搜尋結果進行排序。排序的方向（升序或降序）可以透過desc引數控制。

未來，可以考慮進一步最佳化搜尋功能的實作，例如：

  • 使用更先進的演算法：例如，使用TF-IDF（詞頻-逆向檔案頻率）等更先進的演算法來計算相關性得分。
  • 支援更複雜的查詢：例如，支援布林查詢、短語查詢等更複雜的查詢型別。
  • 最佳化效能：透過最佳化索引結構、查詢執行計劃等來進一步提高搜尋功能的效能。

這些改進可以進一步提高搜尋功能的效率和準確性，從而提供更好的使用者經驗。

搜尋導向應用程式的進階技術

在前一章節中，我們探討瞭如何利用 Redis 進行基本的搜尋功能。在本章節中，我們將進一步探討如何利用 Redis 實作更複雜的搜尋和排序功能。

7.1 利用 Redis SORT 命令進行搜尋結果排序

在某些應用場景中，我們需要根據文章的更新時間或其他屬性對搜尋結果進行排序。Redis 的 SORT 命令可以幫助我們實作這一功能。

7.1.1 使用 HASH 儲存文章資訊

對於每篇文章，我們可以使用一個 HASH 來儲存相關資訊，包括標題、建立時間、更新時間和檔案 ID。以下是一個範例：


### 文章資訊 HASH 結構
- `kb:doc:276`:
  - `id`: 276
  - `created`: 1324114412
  - `updated`: 1327562777
  - `title`: "Troubleshooting..."

7.1.2 利用 SORT 命令進行排序

利用 Redis 的 SORT 命令，我們可以根據 HASH 中的欄位對搜尋結果進行排序。以下是一個範例程式碼：

def search_and_sort(conn, query, id=None, ttl=300, sort="-updated", start=0, num=20):
    desc = sort.startswith('-')
    sort = sort.lstrip('-')
    by = "kb:doc:*->" + sort
    alpha = sort not in ('updated', 'id', 'created')
    
    if id and not conn.expire(id, ttl):
        id = None
    
    if not id:
        id = parse_and_search(conn, query, ttl=ttl)
    
    pipeline = conn.pipeline(True)
    pipeline.scard('idx:' + id)
    pipeline.sort('idx:' + id, by=by, alpha=alpha, desc=desc, start=start, num=num)
    results = pipeline.execute()
    
    return results[0], results[1], id

#### 內容解密：

此函式用於執行搜尋並對結果進行排序。它接受查詢字串、快取 ID、排序欄位、起始位置和結果數量等引數。函式首先判斷是否需要重新執行搜尋，然後利用 Redis 的 SORT 命令對結果進行排序，並傳回結果數量、排序後的結果和快取 ID。

7.2 利用 ZSET 進行複合排序

在某些情況下，我們需要根據多個屬性進行複合排序。Redis 的 ZSET 資料結構可以幫助我們實作這一功能。

7.2.1 使用 ZSET 儲存排序相關資訊

我們可以利用 ZSET 儲存文章的更新時間和投票數，分別作為不同的排序依據。以下是一個範例：


### 更新時間 ZSET
- `updated:zset`:
  - `276`: 1327562777

### 投票數 ZSET
- `votes:zset`:
  - `276`: 10

7.2.2 利用 ZINTERSTORE 進行複合排序

透過將搜尋結果 SET 與更新時間 ZSET 和投票數 ZSET 進行交集運算，並指定聚合函式為 MAX，我們可以實作根據多個屬性進行複合排序。

# 範例程式碼待補充

#### 內容解密：

此段落將詳細介紹如何利用 ZINTERSTORE 命令進行複合排序。我們將利用 ZSET 儲存多個排序屬性，並透過交集運算和聚合函式實作複合排序。

圖表翻譯：

  graph LR
    A[搜尋結果 SET] -->|交集運算|> B[更新時間 ZSET]
    A -->|交集運算|> C[投票數 ZSET]
    B -->|ZINTERSTORE|> D[複合排序結果 ZSET]
    C -->|ZINTERSTORE|> D

此圖表展示瞭如何利用 ZINTERSTORE 命令將搜尋結果 SET 與更新時間 ZSET 和投票數 ZSET 進行交集運算，從而實作複合排序。

隨著 Redis 功能的不斷演進，我們可以期待更多高效的搜尋和排序技術的出現。未來，我們可以考慮利用 Redis 的新功能來進一步最佳化搜尋導向應用程式的效能。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。