Redis实战之文本检索

最新推荐文章于 2023-08-29 22:46:32 发布
最新推荐文章于 2023-08-29 22:46:32 发布
阅读量1k 收藏 1
点赞数
分类专栏： redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010601662/article/details/78204111
版权

问题

检索包含特定单词，但不包含其他特定单词的文本。

约定：
检索语句中，+表示为前一个字的同义词，-表示检索结果中不得包含该词。

如：“你+您-可-以搜索”，表示检索包含“你”（“您”）、“搜”、“索”，且不包含“可”、“以”的所有文本。

思路

1、建立反向索引（类似于书本末尾的索引），即从每个被索引的文档中抽取部分单词，并为每个单词创建一个集合set（key=idx:单词），用来记录单词所包括含于的文档。如，idx:ring docA docB docC
2、并集运算，对同义词按组进行并集运算，检索至少包括其中一个的所有文本。如，sunionstore idx:并集ID idx:你 idx:您
3、交集运算，检索同时包括特定单词的文本。如，sinterstore idx:交集ID idx:并集ID idx:搜 idx:索
4、差集运算，从交集运算结果中剔除包含特定单词的记录。如，sdiffstore idex:差集ID idx:交集ID idx:可 idx:以

索引更新

若文本内容可变，则需为文本删除无效索引并添加新索引 —>>> 可使用json编码的列表存储文本中已建立索引的单词，然后使用set命令将列表存储到一个键里。

实现

//---------------------------------------------------------------SearchManager.h

#ifndef _SEARCHMANAGER_H_
#define _SEARCHMANAGER_H_

struct redisContext;

class SearchManager
{
public:

    // @param   strDir                                          [in]    文件搜索目录
    SearchManager(QString &strDir);
    ~SearchManager();

    // @param   strQuery                                        [in]    检索条件 字可带前缀：+表示为前一个字的同义词，-表示检索结果中不得包含该词
    // @param   varPKValue                                      [out]   运算结果集 idx:nID
    // @param   nTTL                                            [in]    运算结果有效时间
    bool parse_and_search(QString &strQuery, QVariant &varPKValue, int nTTL = 30);

private:

    // 连接Redis
    // @param   strHost                                         [in]    Redis服务器IP
    // @param   nPort                                           [in]    Redis服务器Port
    int _initRedisConnect(QString &strHost = QString("127.0.0.1"), int nPort = 6001);

    // 获取目录下所有文件及文件内单词
    // @param   strDir                                          [in]    文件搜索目录
    bool _tokenize(QString &strDir);

    // 为目录下所有文件内单词建立反向索引 索引键值形式为 idx:单词
    // @param   strDir                                          [in]    文件搜索目录
    bool _index_document(QString &strDir);

    // 通用函数 执行交集/并集/差集运算
    // @param   strMethod                                       [in]    交集/并集/差集运算名称
    // @param   vecWord                                         [in]    单词集合
    // @param   nID                                             [out]   运算结果集 idx:nID
    // @param   nTTL                                            [in]    运算结果有效时间
    bool _set_common(QString &strMethod, QVector<QString> &vecWord, qint64 &nID, int nTTL = 30);

    // 执行交集运算
    // @param   vecWord                                         [in]    单词集合
    // @param   nID                                             [out]   运算结果集 idx:nID
    // @param   nTTL                                            [in]    运算结果有效时间
    bool _intersect(QVector<QString> &vecWord, qint64 &nID, int nTTL = 30);

    // 执行并集运算
    // @param   vecWord                                         [in]    单词集合
    // @param   nID                                             [out]   运算结果集 idx:nID
    // @param   nTTL                                            [in]    运算结果有效时间
    bool _union(QVector<QString> &vecWord, qint64 &nID, int nTTL = 30);

    // 执行差集运算
    // @param   vecWord                                         [in]    单词集合
    // @param   nID                                             [out]   运算结果集 idx:nID
    // @param   nTTL                                            [in]    运算结果有效时间
    bool _difference(QVector<QString> &vecWord, qint64 &nID, int nTTL = 30);

    // 对检索条件进行分析 获取需要进行交集/并集/差集运算的单词
    // @param   strQuery                                        [in]    检索条件 字可带前缀：+表示为前一个字的同义词，-表示检索结果中不得包含该词
    // @param   vecAll                                          [out]   运算结果集 idx:nID
    // @param   vecUnWanted                                     [out]   运算结果有效时间
    bool _parse(QString &strQuery, QVector<QVector<QString>> &vecAll, QVector<QString> &vecUnWanted);


private:

    redisContext *m_pRedisContext;                      // Redis连接对象

    QMap<QString, QVector<QString>> m_mapFileName2Word; // key:文本文件名称 value:文本中建立索引的单词
};

#endif
//---------------------------------------------------------------SearchManager.cpp

#include "stdafx.h"
#include "SearchManager.h"
#include "redis-3.0\deps\hiredis\hiredis.h"
#include "redis-3.0\src\Win32_Interop\Win32_APIs.h"

SearchManager::SearchManager(QString &strDir)
{
    //1、连接Redis
    _initRedisConnect();

    //2、建立反向索引
    _index_document(strDir);
}

SearchManager::~SearchManager()
{
}

// 连接Redis
int SearchManager::_initRedisConnect(QString &strHost, int nPort)
{
    m_pRedisContext = redisConnect(strHost.toLocal8Bit().data(), nPort);
    if (NULL == m_pRedisContext || m_pRedisContext->err)
    {
        redisFree(m_pRedisContext);
        m_pRedisContext = NULL;
        return REDIS_ERR;
    }

    return REDIS_OK;
}

// 获取目录下所有文件及文件内单词
bool SearchManager::_tokenize(QString &strDir)
{
    QDir dir(strDir);
    dir.setFilter(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::NoSymLinks);
    dir.setSorting(QDir::Time | QDir::Reversed);

    QStringList listFileName = dir.entryList();
    for (int nIndex = 0; nIndex < listFileName.size(); nIndex++)
    {
        QString strChildPath = QString("%1\\%2").arg(strDir).arg(listFileName.at(nIndex));

        QFileInfo fileInfo(strChildPath);
        if (fileInfo.isDir())
        {   
            // 递归遍历子目录
            _tokenize(strChildPath);
        }
        else
        {
            //遍历文件
            QFile file(strChildPath);
            if (!file.open(QIODevice::ReadOnly))
            {
                return false;
            }

            QString strContent(file.readAll());
            QStringList strListContent = strContent.toLower().split(QRegExp("\\W+"), QString::SkipEmptyParts);
            for (int nIndex = 0; nIndex < strListContent.size(); nIndex++)
            {
                QString strSentence = strListContent.at(nIndex).trimmed();
                for (int nWordIndex = 0; nWordIndex < strSentence.size(); nWordIndex++)
                {
                    QString strWord = strSentence.mid(nWordIndex, 1);
                    if (strWord.isEmpty())
                    {
                        continue;
                    }

                    m_mapFileName2Word[strChildPath].append(strWord);
                }
            }
        }
    }

    return true;
}

// 为目录下所有文件内单词建立反向索引 索引键值形式为 idx:单词
bool SearchManager::_index_document(QString &strDir)
{
    //1、获取目录下所有文件及文件内单词
    _tokenize(strDir);

    //2、为每个单词建立反向索引 记录单词所包括于的文档
    //索引键值形式为 idx:单词
    QMap<QString, QVector<QString>>::Iterator iter = m_mapFileName2Word.begin();
    for (; iter != m_mapFileName2Word.end();iter++)
    {
        QString strFileName = iter.key();
        QVector<QString> vecWord = iter.value();

        for (int nIndex = 0; nIndex < vecWord.size(); nIndex++)
        {
            QString strWord = vecWord.at(nIndex);

            redisReply *pRedisReply = (redisReply *)redisCommand(m_pRedisContext, "SADD idx:%s %s", strWord.toLocal8Bit().data(), strFileName.toLocal8Bit().data());
            if (pRedisReply == NULL)
            {
                return false;
            }

            freeReplyObject(pRedisReply);
        }
    }

    return true;
}

// 通用函数 执行交集/并集/差集运算
bool SearchManager::_set_common(QString &strMethod, QVector<QString> &vecWord, qint64 &nID, int nTTL)
{
    nID = QDateTime::currentDateTime().toMSecsSinceEpoch();

    QString strCommand = QString("%1 idx:%2").arg(strMethod).arg(nID);

    for (int nIndex = 0; nIndex < vecWord.size(); nIndex++)
    {
        QString strWord = vecWord.at(nIndex);

        strCommand = QString("%1 idx:%2").arg(strCommand).arg(strWord);
    }

    redisReply *pRedisReply = (redisReply *)redisCommand(m_pRedisContext, strCommand.toLocal8Bit().data());
    if (pRedisReply == NULL)
    {
        return false;
    }

    pRedisReply = (redisReply *)redisCommand(m_pRedisContext, "EXPIRE idx:%ld %d", nID, nTTL);
    if (pRedisReply == NULL)
    {
        return false;
    }

    return true;
}

// 执行交集运算
bool SearchManager::_intersect(QVector<QString> &vecWord, qint64 &nID, int nTTL)
{
    return _set_common(QString("sinterstore"), vecWord, nID, nTTL);
}

// 执行并集运算
bool SearchManager::_union(QVector<QString> &vecWord, qint64 &nID, int nTTL)
{
    return _set_common(QString("sunionstore"), vecWord, nID, nTTL);
}

// 执行差集运算
bool SearchManager::_difference(QVector<QString> &vecWord, qint64 &nID, int nTTL)
{
    return _set_common(QString("sdiffstore"), vecWord, nID, nTTL);
}

// 对检索条件进行分析 获取需要进行交集/并集/差集运算的单词
bool SearchManager::_parse(QString &strQuery, QVector<QVector<QString>> &vecAll, QVector<QString> &vecUnWanted)
{
    strQuery = strQuery.replace(" ", "");

    QStringList listWord;
    int pos = 0;
    QRegExp rx("[\\+\\-\\s]{1}[^\\+\\-\\s]{1}|[^\\+\\-\\s]{1}");

    while ((pos = rx.indexIn(strQuery, pos)) != -1) 
    {
        listWord << rx.capturedTexts();
        pos += rx.matchedLength();
    }

    // 你+您-可-以搜索;
    QVector<QString> vecSynonym;
    for (int nIndex = 0; nIndex < listWord.size(); nIndex++)
    {
        QString strWord = listWord.at(nIndex);
        QString strPrefix = strWord.left(1);
        if (strPrefix == "+" || strPrefix == "-")
        {
            strWord = strWord.right(strWord.length() - 1);
        }
        else
        {
            strPrefix = "";
        }

        if (strPrefix == "-")
        {
            vecUnWanted.append(strWord);
            continue;
        }
        else if (strPrefix != "+" && vecSynonym.size() > 0)
        {
            vecAll.append(vecSynonym);
            vecSynonym.clear();
        }

        vecSynonym.append(strWord); 
    }

    if (vecSynonym.size() > 0)
    {
        vecAll.append(vecSynonym);
    }

    return true;
}

bool SearchManager::parse_and_search(QString &strQuery, QVariant &varPKValue, int nTTL)
{
    QVector<QVector<QString>> vecAll;
    QVector<QString> vecUnWanted;

    // 对检索条件进行分析 获取需要进行交集/并集/差集运算的单词
    _parse(strQuery, vecAll, vecUnWanted);

    QVector<QString> vecIntersect;
    // 遍历同义词
    for (int nSynonymIndex = 0; nSynonymIndex < vecAll.size(); nSynonymIndex++)
    {
        QVector<QString> vecSynonym = vecAll.at(nSynonymIndex);

        if (vecSynonym.size() > 1)
        {
            qint64 nID;
            _union(vecSynonym, nID, nTTL);
            vecIntersect.append(QString("%1").arg(nID));
        }
        else
        {
            vecIntersect.append(vecSynonym.at(0));
        }
    }

    // 交集
    if (vecIntersect.size() > 1)
    {
        qint64 nID;
        _intersect(vecIntersect, nID, nTTL);

        varPKValue = nID;
    }
    else
    {
        varPKValue = vecIntersect.at(0);
    }

    // 差集
    if (vecUnWanted.size() > 0)
    {
        qint64 nID;
        vecUnWanted.push_front(varPKValue.toString());
        _difference(vecUnWanted, nID, nTTL);

        varPKValue = nID;
    }

    return true;
}
傲然君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisSearch：一个基于Redis的搜索引擎模块
汽车软件开发
04-19 1832
RedisSearch是一个基于Redis的搜索引擎模块，它能够为Redis中的数据创建索引，执行复杂的搜索查询，并实现高级功能，如自动完成、分面搜索和排序。RedisSearch是用C语言编写的，与其他开源搜索引擎相比速度极快。它支持多种数据类型和命令，这些特性从根本上改变了使用Redis的可能性3。此外，RedisSearch还提供了全文搜索、索引和聚合功能2。RedisSearch的安装过程包括下载源码并进行配置89。
深入解析RedisSearch：全文搜索的新维度
最新发布
码到三十五
05-11 2万+
RedisSearch 是 Redis 的一个模块，它提供了全文搜索的功能，允许开发者在 Redis 数据库中执行复杂的搜索查询。RedisSearch 不仅支持简单的文本搜索，还提供了多种查询方式，如模糊查询、范围查询和聚合操作等。RedisSearch 为 Redis 带来了强大的全文搜索功能，使得开发者能够轻松地在 Redis 数据库中执行复杂的搜索查询。通过合理利用 RedisSearch 的特性和优化策略，你可以为你的应用提供高效、准确的搜索体验。
使用Redis进行搜索
weixin_44196785的博客
10-20 2941
搜索引擎以及各种网站中的搜索功能已经是人们从海量信息中快速获取特定信息的常用方式。使用 Redis 可以搭建高性能、多特性的搜索引擎，也特别适合解决基于搜索的问题。 本实训项目从构建反向索引，基本搜索操作，实现搜索三个方面介绍如何使用 Redis 解决基于搜索的问题。 第1关：构建反向索引 #!/usr/bin/env python #-*- coding:utf-8 -*- import re import redis conn = redis.Redis() # 文本序列化 def tokeniz
Redis实现高性能的全文搜索引擎---RediSearch
u010797364的博客
07-01 1731
轻量级搜索引擎-RediSearch。
人工智能项目资料-基于Flask+Yolov5+Redis的深度学习在线监测网站.zip
02-05
我们深入探讨了深度学习的基本原理、神经网络的应用、自然语言处理、语言模型、文本分类、信息检索等领域。更有深度学习、机器学习、自然语言处理和计算机视觉的实战项目源码，助您从理论走向实践，如果您已有一定...
【尚硅谷】徐靖博 最新电商项目实战（完结）
12-03
r1 b# x1 k3 e 137.01 交叉检索redis 138.02 交叉检索redis* Y7 `1 z9 P" D% J+ E 139.03 判断交叉检索的key 140.04 redis的使用总结: C& g/ P ^; B. n8 Y6 d1 C# ^9 l 141.05 一些小问题. @( |. p' J! V5 s; Z+ E ...
springboot万花筒系统的设计与实现（源码+数据库）345600
10-17
《SpringBoot万花筒系统设计与实现：深度解析与实战指南》 在现代Web开发领域，SpringBoot以其轻量级、高效能以及便捷的特性，成为企业级应用开发的首选框架。结合Vue.js前端框架、IDEA开发工具、Redis缓存技术和...
一键搜索-根据关键字批量查找文本
06-05
针对多种格式的根据关键字批量查找文本,jar格式的，附源码！ (注：新的版本发布了,加了一些新功能!http://download.csdn.net/source/2914935)
牛逼啊！使用 Redis 实现一个轻量级的搜索引擎
m0_71777195的博客
06-23 2749
大家如果是做后端开发的，想必都实现过列表查询的接口，当然有的查询条件很简单，一条 SQL 就搞定了，但有的查询条件极其复杂，再加上库表中设计的各种不合理，导致查询接口特别难写，然后加班什么的就不用说了（不知各位有没有这种感受呢~）。下面以一个例子开始，这是某购物网站的搜索条件，如果让你实现这样的一个搜索接口，你会如何实现？（当然你说借助搜索引擎，像 Elasticsearch 之类的，你完全可以实现。但我这里想说的是，如果要你自己实现呢？）必备技能！聊聊二维码扫码登录的原理从上图中可以看出，搜索 总共分为6
使用redis实现搜索引擎
Technology exist forever
03-21 1万+
场景大家如果是做后端开发的，想必都实现过列表查询的接口，当然有的查询条件很简单，一条 SQL 就搞定了，但有的查询条件极其复杂，再加上库表中设计的各种不合理，导致查询接口特别难写，然后加班什么的就不用说了（不知各位有没有这种感受呢~）。下面以一个例子开始，这是某购物网站的搜索条件，如果让你实现这样的一个搜索接口，你会如何实现？（当然你说借助搜索引擎，像 Elasticsearch 之类的，你完全可...
Redis集成搜索功能(简单例子)
weixin_45969142的博客
02-22 668
Redis集成搜索功能 前言 有时候想着，你要是查询一些固定的数据，是不是能从数据库里面查询一次后，就直接可以从redis里面拿啊？下面就是例子的实现 1.添加依赖 <!-- Spring data redis 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spr
利用 Redis 构建全文索引组件
weixin_45648892的博客
03-14 730
文章目录前言一、反向索引二、实现代码 前言 数据库文章全文搜索中我们很少使用 like 查询，因为假设使用包含查询，我们需要对每个检索词每一篇文章的每个单词进行遍历，检索的时间复杂度则会达到 o(n三次方)。通常，我们会直接使用 elasticsearch 组件来实现全文检索，但我们很少了解全文检索的原理，今天我们尝试使用 redis 来构建一个具有基本检索功能的全文索引组件，将时间复杂度降低到 o(n * log2n)。 一、反向索引 在实现这个全文索引组件前，我们需要了解反向索引的数据结构，因为接下
redis scan一点原理
weixin_39312465的博客
04-08 1610
转载:https://www.jb51.net/article/148698.htm
推荐系统全栈：倒排/向量召回+DeepFM排序+推理引擎+后端服务，基于PyTorch + Redis + Elasticsearch + Feast + Triton + Flask（附代码）
DeAlVe的博客
08-29 708
介绍推荐系统从离线到在线的全流程，所有操作都可以在一台笔记本上完成，所有东西都被封在了Conda和Docker里，不会对本地环境有任何伤害。 安装pandas和PyTorch进行离线模型训练。 安装Flask作为推荐后端。 Docker环境安装Redis + Elasticsearch + Feast Feature Store + Triton Inference Server四个组件，用本机localhost调用Docker来模拟工业界的推荐后端RPC调用各个组件。
「从零入门推荐系统」07：召回算法之规则策略方法
大数据与人工智能
12-17 809
作者|gongyouliu编辑 |gongyouliu我们在上一篇文章中对推荐系统中的召回算法进行了简单梳理。从本章开始，我们会花3章的篇幅来详细介绍推荐系统召回算法的具体思路和实现细节。上一章中我们提到了可以按照算法复杂度将召回算法分为3类，接下来的3章我们按照这个分类来介绍召回算法，我们会分别讲解规则策略召回算法、基础召回算法、高阶召回算法。本章我们介绍规则策略召回算法。下面我们分5小结...
Redis实战精要：红丸出品
"Redis实战《红丸出品》" 在Redis实战《红丸出品》中，作者深入浅出地介绍了Redis这一高效、流行的键值存储系统。Redis作为一个内存数据结构存储系统，广泛应用于缓存、消息队列、计数器等多种场景。本资料详细讲解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值