实现一个数据库（9）索引与Runtime

最新推荐文章于 2024-07-28 17:22:54 发布
原创 最新推荐文章于 2024-07-28 17:22:54 发布 · 276 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文档详细介绍了数据库中索引的搭建，包括B树和散列桶索引的结构与实现。B树是一种适合磁盘存储的多叉树，通过增删过程展示了其工作原理。散列桶索引利用散列函数进行快速查找，通过散列桶管理器和散列桶的定义及函数来实现。此外，还讨论了Runtime层在数据库系统中的作用，它是连接文件系统和索引系统的桥梁，提供了插入、查找和删除等接口。最后，概述了单机数据库的启动流程和测试步骤。

github链接(更新中)

https://github.com/pourtheworld/mydb

大纲（更新中）
（0）mydb的架构设想

本期任务

索引的搭建

索引的存在使得我们可以快速定位目标，消耗最少资源跳过不需要目标。
常用的有B树索引、bitmap位图索引、散列索引、地理索引。

B树和散列桶索引

B树

结构：

  1. 适合于磁盘的多叉树结构。
  2. 每个数据页作为一个节点。
  3. 每个节点有不定数量的元素。
  4. 每个元素包含左指针、数据键、与数据记录ID。
  5. 每个节点有一个右指针。

规则：

  1. 元素左指针指向的所有节点的数据键必须小于元素，并且大于等于前一个元素的数据键。
  2. 节点右指针指向的节点的所有元素的数据键必须大于该节点的最大元素。
  3. 节点中考前元素的数据键要小于等于靠后的。

我们通过一个增删的过程来简单描述一下B树结构：

（a） 以一个空节点开始，我们试图插入数据键为5的元素。
在这里插入图片描述
（b）成功插入后，试图插入13。
在这里插入图片描述
（c）由于13>5，直接插在5。
后面成功插入后，试图插入27。
在这里插入图片描述
（d）同理成功插入27后，试图插入9。
在这里插入图片描述
（e）我们规定一个节点最多有3个元素，当第4个元素试图插入时，重点的元素会被分裂到上一层；
可以看到13被分裂出来，我们继续试图插入9。
在这里插入图片描述
（f）此时9会优先插入到子节点中，然后试图插入7。
在这里插入图片描述
（g）成功插入7后，试图插入3。
在这里插入图片描述
（h）老问题，节点个数来到4个，我们将中间的7分裂出来给到13的节点。继续试图插入3。
在这里插入图片描述
（i）成功插入3后，我们试图将9删去。
在这里插入图片描述
（j）由于9删除后，中间的节点为空，因此我们先将父节点的7移到9的左边，并将子节点的5置到父节点。再次试图删去9。
在这里插入图片描述
（k）成功删去9后，我们试图删去7。
在这里插入图片描述
（l）发现删去7中间节点为空，我们试图将5移下将3置上，但发现这样3所在节点会为空。因此我们将3、5、7置为一个子节点中。再试图删去7。
在这里插入图片描述
（m）成功删去7，我们试图删去5。
在这里插入图片描述
（n）成功删去5，试图删去3，发现3节点为空，因此将3、13、27置为一个子节点。再次尝试删去3。
在这里插入图片描述
（o）继续尝试删除3，至此结束。
在这里插入图片描述

本数据库的散列桶索引

散列方式：
散列函数 f（数据记录的_id）=散列值。
散列值%散列桶个数=当前记录的散列桶编号 。
散列桶保存一个map<散列值，数据记录的RID>。
（注意_id与RID的区别，前者用于散列，后者用于文件定位。）

用户查找一个记录的流程：

  1. 输入query {_id:1}。
  2. agentEDU提取出BSONObj交给runtime的find接口。
  3. runtime交给索引manager的处理函数，通过_id经过散列函数得到散列值；
    散列值%散列桶个数得到散列桶号，进入该桶。
  4. 在该桶的map中寻找到散列值对应的RID。
  5. 回到find接口，runtime再交给文件manager的查找函数，通过RID找到对应页的对应记录返回。

索引实现

我们定义ixmBucketManager类作为散列桶的管理器，保存了vector<ixmBucket*>。
以及ixmBucket类作为散列桶，每个散列桶保存了map<散列值，散列元素>。
我们定义一个结构体ixmEleHash作为散列元素，散列元素包含了数据记录以及记录ID。

散列桶管理器以及散列桶定义

#define IXM_KEY_FIELDNAME    "_id"
#define IXM_HASH_MAP_SIZE   1000

//索引元素 包含记录数据+记录id
struct ixmEleHash
{
    const char *data;
    dmsRecordID recordID;
};


//首先有一个桶管理器，保存了1000个桶
//每个桶包含一个map。可以通过map的first 索引值，得到map的second 索引记录。
//索引值通过记录数据+记录长度通过索引函数得到。

class ixmBucketManager
{
private:
    class ixmBucket
    {
    private:
        std::multimap<unsigned int,ixmEleHash> _bucketMap;
        ossSLatch _mutex;
    public:
        //给定索引值，寻找当前桶map中对应的索引记录。与给定索引记录比较是否存在。
        int isIDExist(unsigned int hashNum,ixmEleHash &eleHash);
        int createIndex ( unsigned int hashNum, ixmEleHash &eleHash ) ;
        int findIndex ( unsigned int hashNum, ixmEleHash &eleHash ) ;
        int removeIndex ( unsigned int hashNum, ixmEleHash &eleHash ) ;
    };
    //通过给定的record得到索引值。通过索引值%桶数得到对应桶。在对应桶的map中建立索引。
        int _processData(BSONObj &record,dmsRecordID &recordID,
        unsigned int &hashNum,ixmEleHash &eleHash,unsigned int &random);
private:
    std::vector<ixmBucket*> _bucket;
public:
    ixmBucketManager ()
   {
   }
   ~ixmBucketManager ()
   {
      ixmBucket *pIxmBucket = NULL ;
      for ( int i = 0; i < IXM_HASH_MAP_SIZE; ++i )
      {
         pIxmBucket = _bucket[i] ;
         if ( pIxmBucket )
            delete pIxmBucket ;
      }
   }
   int initialize () ;
   int isIDExist ( BSONObj &record ) ;
   int createIndex ( BSONObj &record, dmsRecordID &recordID ) ;
   int findIndex ( BSONObj &record, dmsRecordID &recordID ) ;
   int removeIndex ( BSONObj &record, dmsRecordID &recordID ) ;
};

散列函数

#undef get16bits
#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
#define get16bits(d) (*((const unsigned short *) (d)))
#endif

#if !defined (get16bits)
#define get16bits(d) ((((unsigned int)(((const unsigned char *)(d))[1])) << 8)\
                       +(unsigned int)(((const unsigned char *)(d))[0]) )
#endif
unsigned int ossHash ( const char *data, int len )
{
   unsigned int hash = len, tmp ;
   int rem ;
   if ( len <= 0 || data == NULL ) return 0 ;
   rem = len&3 ;
   len >>= 2 ;
   for (; len > 0 ; --len )
   {
      hash += get16bits (data) ;
      tmp   = (get16bits (data+2) << 11) ^ hash;
      hash  = (hash<<16)^tmp ;
      data += 2*sizeof(unsigned short) ;
      hash += hash>>11 ;
   }
   switch ( rem )
   {
   case 3:
      hash += get16bits (data) ;
      hash ^= hash<<16 ;
      hash ^= ((char)data[sizeof (unsigned short)])<<18 ;
      hash += hash>>11 ;
      break ;
   case 2:
      hash += get16bits(data) ;
      hash ^= hash <<11 ;
      hash += hash >>17 ;
      break ;
   case 1:
      hash += (char)*data ;
      hash ^= hash<<10 ;
      hash += hash>>1 ;
   }
   hash ^= hash<<3 ;
   hash += hash>>5 ;
   hash ^= hash<<4 ;
   hash += hash>>17 ;
   hash ^= hash<<25 ;
   hash += hash>>6 ;
   return hash ;
}
#undef get16bits

散列桶函数

首先散列桶的函数都需要通过散列桶Manager经过数据处理函数后再调用。
散列桶函数包括了ID是否存在、插入、查找、删去等函数。

散列桶管理器的数据记录处理函数：通过record，得到散列值、对应桶、散列元素。

//处理数据记录函数
//先检验记录是否有_id字段打头
//根据散列值获得桶号random
//把散列元素的data和id附上值

int ixmBucketManager::_processData ( BSONObj &record,
                                     dmsRecordID &recordID,
                                     unsigned int &hashNum,
                                     ixmEleHash &eleHash,
                                     unsigned int &random )
{
   int rc               = EDB_OK ;
   //得到字段为i_id的BSON元素部分
   BSONElement element  = record.getField ( IXM_KEY_FIELDNAME ) ;
   //如果没有_id字段，或者_id的类型不是int或者string 则出错
   if ( element.eoo() ||
        ( element.type() != NumberInt && element.type() != String ) )
   {
      rc = EDB_INVALIDARG ;
      PD_LOG ( PDERROR, "record must be with _id" ) ;
      goto error ;
   }

   // 根据_id的值和长度，经过散列函数获得散列值
   hashNum = ossHash ( element.value(), element.valuesize() ) ;
   // 根据散列值通过取模得到桶号
   random = hashNum % IXM_HASH_MAP_SIZE ;

   //将散列元素赋值
   eleHash.data = element.rawdata () ;
   eleHash.recordID = recordID ;
done :
   return rc ;
error :
   goto done ;
}

散列桶的判断ID是否存在函数： 通过哈希值去对应桶里查找有无相同的散列元素。

//具体的记录检查函数：
//首先已经经过Manager的记录处理函数，得到了对应的散列值和散列元素
//去对应的桶里寻找相同散列值的迭代器范围
//在这个范围内判断是否与散列元素相同：先判断数据类型->数据长度->数据本身
//我们对该桶使用共享锁

int ixmBucketManager::ixmBucket::isIDExist ( unsigned int hashNum,
                                             ixmEleHash &eleHash )
{
   int rc = EDB_OK ;
   BSONElement destEle ;
   BSONElement sourEle ;
   ixmEleHash existEle ;
   std::pair<std::multimap<unsigned int, ixmEleHash>::iterator,
             std::multimap<unsigned int, ixmEleHash>::iterator> ret ;
   _mutex.get_shared () ;
   ret = _bucketMap.equal_range ( hashNum ) ;   //相同散列值的迭代器范围
   sourEle = BSONElement ( eleHash.data ) ;
   for ( std::multimap<unsigned int, ixmEleHash>::iterator it = ret.first ;
         it != ret.second; ++it )
   {
      existEle = it->second ;
      destEle = BSONElement ( existEle.data ) ;
      if ( sourEle.type() == destEle.type() )   //先判断值的类型是否相同
      {
         if ( sourEle.valuesize() == destEle.valuesize() )  //再判断长度
         {
            if ( !memcmp ( sourEle.value(), destEle.value(),    //最后判断内容
                           destEle.valuesize() ) )
            {
               rc = EDB_IXM_ID_EXIST ;
               PD_LOG ( PDERROR, "record _id does exist" ) ;
               goto error ;
            }
         }
      }
   }
done :
   _mutex.release_shared () ;
   return rc ;
error :
   goto done ;
}

插入、删除、查找的逻辑与上一个函数类似，不再赘述。

Runtime

在这里插入图片描述

Runtime层的作用

之前我们已经实现了由DMS数据管理系统（文件）、索引管理系统组成的存储层部分；
也实现了传输层的Messenger（消息模型）和线程池的EDU（事件调度单元）。

我们在这个数据库系统中将事件调度单元分为listener以及agent，它们都有对应的处理函数，其中agentEDU负责与客户端进行通信。那么agentEDU的处理函数中需要对消息进行处理，我们可以引进runtime来调用文件系统和索引系统。

Runtime层的接口

可以看到runtime类的本身包含了文件和索引，作为上层调用底层的一个过渡。

class rtn
{
private:
    dmsFile *_dmsFile;
    ixmBucketManager *_ixmBucketMgr; 
public:
    rtn();
    ~rtn();
    int rtnInitialize();
    int rtnInsert(bson::BSONObj &record);
    int rtnFind(bson::BSONObj &inRecord,bson::BSONObj &outRecord);
    int rtnRemove(bson::BSONObj &record);
};

以rtnInsert为例看一下调用方法： 先查看索引中有无这个记录，没有再插入到文件中。

//实际上就是调用文件的insert
int rtn::rtnInsert(BSONObj &record)
{
    int rc=EDB_OK;
    dmsRecordID recordID;
    BSONObj outRecord;
    
    //检查索引是否已经存在该记录了。
    rc=_ixmBucketMgr->isIDExist(record);
    PD_RC_CHECK ( rc, PDERROR, "Failed to call isIDExist, rc = %d", rc ) ;

    rc=_dmsFile->insert(record,outRecord,recordID);
    if ( rc )
    {
      PD_LOG ( PDERROR, "Failed to call dms insert, rc = %d", rc ) ;
      goto error ;
    }
    //插入完以后更新索引
    rc=_ixmBucketMgr->createIndex(outRecord,recordID);
    PD_RC_CHECK ( rc, PDERROR, "Failed to call ixmCreateIndex, rc = %d", rc ) ;
done :
   return rc ;
error :
   goto done ;
}

查找、删除的接口类似，不再赘述。

AgentEDU对runtime的调用

我们以Agent处理请求函数中的插入请求部分为例：

  1. 首先对应Insert的拆包函数，获得待插入数据记录。
  2. 检查记录第一个字段是否为_id。
  3. 交给rtnInsert进行具体插入。
try
   {  //处理消息
      if(OP_INSERT==opCode)
      {
         int recordNum=0;  //插入记录数量
         PD_LOG(PDDEBUG,"Insert request received");
         //insert消息是由消息头+recordNum+BSONoBJ组成的
         //通过这一步解封我们获得的pInsertorBuffer已经指向了BSONObj的首字母
         rc=msgExtractInsert(pReceiveBuffer,recordNum,&pInsertorBuffer);

         if(rc)
         {
            PD_LOG(PDERROR,"Failed to read insert packet");
            probe=20;
            rc=EDB_INVALIDARG;
            goto error;
         }
         try//先检查对象本身有无错误，再检查第一个字段是不是id，最后交给rtnMgr来插入
         {  //从buffer中读取BSON对象
            BSONObj insertor(pInsertorBuffer);
            PD_LOG ( PDEVENT,
                     "Insert: insertor: %s",
                     insertor.toString().c_str() ) ;
            BSONObjIterator it(insertor); //BSON对象的一个迭代器
            BSONElement ele=*it; //获取BSON对象的第一个元素
            const char *tmp=ele.fieldName(); //获取第一个元素的字段名
            rc=strcmp(tmp,gKeyFieldName); //比较是不是"id"
            if ( rc )
            {
               PD_LOG ( PDERROR,
                        "First element in inserted record is not _id" ) ;
               probe = 25 ;
               rc = EDB_NO_ID ;
               goto error ;
            }

            rc=rtnMgr->rtnInsert(insertor);

         }
         catch(const std::exception& e)
         {
            PD_LOG(PDERROR,"Failed to create insertor for insert: %s",e.what());
            probe=30;
            rc=EDB_INVALIDARG;
            goto error;
         }
      }

单机数据库的测试

启动流程

  1. pmdMain.cpp/main->pmdMain.cpp/pmdMasterThreadMain主线程启动:
    两个主要流程：pmdMasterThreadMain.cpp/pmdResolveArguments（加载配置文件）：

    
	rc=options.init(argc,argv);
	if(rc)
	{
		if(EDB_PMD_HELP_ONLY!=rc)
			PD_LOG(PDERROR,"Failed to init options,rc=%d",rc);
		goto error;
	}
	//将options里的内容传入内核
	rc=pmdGetKRCB()->init(&options);

    过程中会初始化内核，让我们跳转进pmd.cpp/init:

    int EDB_KRCB::init(pmdOptions *options)
{
	setDBStatus(EDB_DB_NORMAL);
	setDataFilePath(options->getDBPath());
	setLogFilePath(options->getLogPath());
	//从配置文件中得到Log文件的地址，并copy给pd的日志文件地址
	strncpy(_pdDiagLogPath,getLogFilePath(),sizeof(_pdDiagLogPath));
	setSvcName(options->getServiceName());
	setMaxPool(options->getMaxPool());
	return _rtnMgr.rtnInitialize();
}

    过程中会将runtime初始化，让我们再跳转进rtn.cpp/rtnInitialize：

    int rtn::rtnInitialize()
{
   int rc=EDB_OK;
    
   _ixmBucketMgr=new(std::nothrow) ixmBucketManager();
   if ( !_ixmBucketMgr )
   {
      rc = EDB_OOM ;
      PD_LOG ( PDERROR, "Failed to new ixm bucketManager" ) ;
      goto error ;
   }

   _dmsFile=new(std::nothrow) dmsFile(_ixmBucketMgr);
    if ( !_dmsFile )
   {
      rc = EDB_OOM ;
      PD_LOG ( PDERROR, "Failed to new dms file" ) ; 
      goto error ;
   }

   rc=_ixmBucketMgr->initialize();
   if ( rc )
   {
      PD_LOG ( PDERROR, "Failed to call bucketMgr initialize, rc = %d", rc ) ;
      goto error ;
   }

   rc=_dmsFile->initialize(pmdGetKRCB()->getDataFilePath());
   if ( rc )
   {
      PD_LOG ( PDERROR, "Failed to call dms initialize, rc = %d", rc ) ;
      goto error ;
   }

done :
   return rc ;
error :
   goto done ; 
}

    在这一步，我们初始化了文件和索引系统，让我们回到最初pmdMasterThreadMain.cpp的另一个流程， pmdMasterThreadMain.cpp/eduMgr->startEDU（TcpListenerEDU）。

  2. pmdEDUMgr.cpp/startEDU监听线程启动。当有客户端连接，由于是数据库刚启动，空闲队列中没有空闲agentEDU，因此我们转入pmdEDUMgr.cpp/_createNewEDU。

    //如果为空，或者该EDU类型不是agent(idle队列里只能是agent)
    if(true==_idleQueue.empty()||!isPoolable(type))
    {
        _mutex.release();
        rc=_createNewEDU(type,arg,eduid);
        if(EDB_OK==rc)  goto done;
        goto error;
 
    }

  3. pmdEDUMgr.cpp/_createNewEDU中，我们创建新的thread传入agent处理函数并且detach它。转入
    pmdEDU.cpp/pmdEDUEntryPoint。

    try
   {//创建thread，将CB和其它参数传进去
       boost::thread agentThread(pmdEDUEntryPoint,type,cb,arg);
       agentThread.detach();
   }

  4. pmdEDU.cpp/pmdEDUEntryPoint中，检查事件类型，如果为恢复，那么根据EDU类型赋予处理函数，转入pmdEDU.cpp/getEntryFuncByType。

    pmdEntryPoint entryFunc=getEntryFuncByType(type);

  5. pmdEDU.cpp/getEntryFuncByType，得到pmdAgentEntryPoint，进入pmdAgent.cpp/ pmdAgentEntryPoint。

    pmdEntryPoint rt=NULL;
	//静态，第一次加载这个函数时生成entry入口函数对应数组
	static const _eduEntryInfo entry[]={
		ON_EDUTYPE_TO_ENTRY1(EDU_TYPE_AGENT,false,pmdAgentEntryPoint,"Agent"),
		ON_EDUTYPE_TO_ENTRY1(EDU_TYPE_TCPLISTENER,true,pmdTcpListenerEntryPoint,"TCPListener"),
		ON_EDUTYPE_TO_ENTRY1(EDU_TYPE_MAXIMUM,false,NULL,"Unknown")
	};

	static const unsigned int number=sizeof(entry)/sizeof(_eduEntryInfo);

	unsigned int index=0;

	for(;index<number;++index)
	{	//entry数组中寻找对应于type的入口函数
		if(entry[index].type==type)
		{	//获取到了该入口
			rt=entry[index].entryFunc;
			goto done;
		}
	}
done:
	return rt;

  6. pmdAgent.cpp/ pmdAgentEntryPoint，等待客户端发来消息，进入pmdAgent.cpp/ pmdProcessAgentRequest进行消息处理。

     //正式对数据包进行处理
      rc = pmdProcessAgentRequest ( pReceiveBuffer,
                                    packetLength,
                                    &pResultBuffer,
                                    &resultBufferSize,
                                    &disconnect,
                                    cb ) ;

  7. pmdAgent.cpp/ pmdProcessAgentRequest，根据消息类型调用对应的runtime底层接口函数。详细请看runtime例子部分。

实际演示

  1. 打开服务器（左），客户端（右），客户端连接。
    在这里插入图片描述
  2. 客户端输入insert {_id:1,hello:“world”}，服务器响应插入成功。
    在这里插入图片描述
  3. 客户端输入insert {_id:2,hello:“c++”}，服务器响应插入成功。
    在这里插入图片描述
  4. 客户端输入query {_id:1}，服务器返回给客户端整个记录信息。
    在这里插入图片描述
  5. 客户端输入delete {_id:1}，服务器响应删除命令。
    在这里插入图片描述
  6. 客户端此时再查找这条记录，会显示不存在。
    在这里插入图片描述
分布式数据库设计——分布式索引
庄小焱
01-22 2375
摘要 索引是数据检错的关键技术，那么在分布式数据库这种体量的数据容量下，如单机数据那样进行数据表全量扫描是非常不现实的，故分布式存储引擎的关键就是要通过索引查找目标数据。通过上一讲的学习，你已经知道存储引擎中包含数据文件和索引文件，同时索引文件中又有索引组织表这种主要的形式。目前世界上主要的分布式数据库的数据存储形式，就是围绕着索引而设计的。 由于分布式数据库的数据被分散在多个节点上，当查询请求到达服务端时，目标数据有极大的概率并不在该节点上，需要进行一次甚至多次远程调用才可查询到数据。由于以上的原因，
【微服务】mysql + elasticsearch数据双写设计与实现
热门推荐
congge
11-04 1万+
mysql + elasticsearch数据双写设计与实现
实现一个数据库（7）消息模型
pourtheworld的博客
06-19 444
github链接(更新中) https://github.com/pourtheworld/mydb 大纲（更新中） （0）mydb的架构设想 本期任务通讯协议的构建架构设计协议格式内存对齐自定义消息格式消息头消息主体消息接受消息回复消息处理服务端Agent消息处理测试gdb调试以及BSON格式完善了Agent的处理后进行测试 通讯协议的构建 协议的构建来源于架构的设计； 协议的格式包括头+主体+附加信息； 我们设计协议某个部分长度时需要考虑到内存对齐。 架构设计 插入 每次插入一条或者多条记录。（我
算法-链表
pourtheworld的博客
04-16 162
算法-链表链表单链表1.2021-4-14 指定区间单链表节点反转2.2021-4-15 K 个一组翻转链表 链表 单链表 1.2021-4-14 指定区间单链表节点反转 题目： 给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。 示例 输入 head = [1,2,3,4,5], left = 2, right = 4 输出 [1,4,3,2,5] 思路： 两个
后台开发核心技术（三）ELF文件
pourtheworld的博客
08-19 323
ELF：用于二进制文件，可执行文件，目标代码，共享库，核心转储的标准文件格式。 目标文件发展历程：UNIX从最早的a.out（难以支撑共享库概念）->COFF（引入了段的概念）->ELF（更具扩展性和灵活性） ELF文件类型： 可重定位的目标文件 即由汇编器汇编生成的.o文件，链接器将其作为目标文件作为输入 ，链接处理后，生成一个可执行的目标文件或者可被共享的对象文件(.so文件)...
后台开发核心技术（一）编译与链接
pourtheworld的博客
08-18 268
编译与链接的整个过程： 预处理Prepressing->编译->Compilation->汇编 Assembly->链接->Linking 以helloworld作为例子展开： 预处理 g++ -E hello.cpp -o hello.i -> hello.i (1) 将#define的内容替换 (2) 处理条件预编译指令，如#if ,#ifdef等 (...
设计一个数据库路由组件实现分库分表
最新发布
wywcool的博客
07-28 1449
通过使用Springboot进行开发，基于aop，Spring动态数据源切换，扰动函数实现分库分表功能，为一个小学习项目
Dify中的高质量索引模式实现过程
NLP工程化
07-15 3744
思考在什么情况下会使用到高质量索引模式呢？第1种情况是在知识库中上传文档，文档被拆分为段落后需要进行编码（增加）；第2种情况是在召回测试的时候，需要对query进行编码（查询）；第3种情况是当文档中的段落增加和更新时需要进行编码（增加和更新）。索引模式是针对知识库设置的，即对该知识库中所有的文档都生效。本文主要解释Dify中的高质量索引模式实现过程。
实现一个数据库（10）快照
pourtheworld的博客
06-25 789
github链接(更新中) https://github.com/pourtheworld/mydb 大纲（更新中） （0）mydb的架构设想 快照机制快照介绍快照级别快照实现快照类定义快照类运用 快照介绍 通过记录实时状态，DBA可以了解当前系统的运行状况，在基于此进行性能监控和调优。 快照级别 一般来说为： 数据库级快照：可能包含连接数量、索引读写次数、索引IO次数、执行事务总数、磁盘空间占用、内存占用、CPU开销等。 会话级快照：可能包含连接开始时间、执行事务总数、索引读写次数、CPU占用、内存
利用FMDB与runtime实现IOS数据存储高效管理
YUDBFramework是一个基于FMDB和runtime特性的iOS数据库操作框架。该框架将FMDB的数据库操作和runtime的动态特性结合起来，为开发者提供了一种更加灵活、强大的数据操作方式。通过YUDBFramework，开发者可以更加直观...
分布式数据库查询优化
12-26
共7页，以前做课程作业时通过搜集资料、自己整理的，先介绍了分布式查询的背景和查询方法，然后引出了查询优化的目标，最后用大部分的篇幅分布式查询优化的各种方法。
分布式搜索引擎的架构原理-Elasticsearch
lh87270202的博客
03-01 668
一、倒排索引 搜索这个技术领域里最入门级别的一个概念——倒排索引。 我们先简单说一下倒排索引是个什么？ 比如我们不用索引，用数据库存放和搜索一些数据，比如说放了一些论坛的帖子数据吧，那么这个数据的格式大致如下： id title content 1 Java好用吗？ Java是非常非常好的一门语言。。。。 2 大家一起来学Java 我这儿有一些很好的Java学习资源，比如说。。...
分布式索引入门
鸭梨的博客
08-05 1360
说到分布式索引时，我们在谈论什么？ 首先，我要说明一下谈到分布式索引，需要了解什么样的内容。你已经知道存储引擎中包含数据文件和索引文件，同时索引文件中又有索引组织表这种主要的形式。 目前世界上主要的分布式数据库的数据存储形式，就是围绕着索引而设计的。 为什么会这样呢？ 由于分布式数据库的数据被分散在多个节点上，当查询请求到达服务端时，目标数据有极大的概率并不在该节点上，需要进行一次甚至多次远程调用才可查询到数据。由于以上的原因，在设计分布式数据库存储引擎时，我们更希望采用含有索引的数据表，从而减少查询的延迟
索引大数据：分布式数据库中的全局索引与本地索引
weixin_34119545的博客
05-20 345
2019独角兽企业重金招聘Python工程师标准>>> ...
TiDB分布式数据库索引
Hanhahahahah的博客
07-17 706
TiDB的索引可以分为和。主键索引就是在主键字段上建立的索引，二级索引是在非主键字段上建立的索引。
分布式数据库NoSQL(五)——MongoDB 之滴滴、摩拜都在用的索引
m0_64139004的博客
10-01 9077
MongoDB 常用于大数据的存储，在庞大的数据中查询出我们所要的信息，如果使用普通查询方法，遍历所有文档查询，花费的时间太久了。 假设现在有个集合 person，查询命令：db.person.find( {age: 18} )， 查询所有年龄 18 岁的人，这时需要遍历所有的文档（全表扫描），根据位置信息读出文档，对比 age 字段是否为 18。当然如果只有 4 条文档，全表扫描的开销并不大，但如果集合文档数量到百万、甚至千万上亿的时候，对集合进行全表扫描开销是非常大的
分布式数据库实战第三节 分布式数据库引擎、索引和事务
fegus的博客
05-17 1258
07 概要：什么是存储引擎，为什么需要了解它？ 经过第一个模块的学习，相信你已经知道了什么是分布式数据库，对分布式数据库的核心知识有了比较全面和深入的了解了。 这一讲是第二模块存储引擎的概要，主要目的是为你解释什么是存储引擎，以及它在分布式数据库中起到什么样的作用。 数据库的一个首要目标是可靠并高效地管理数据，以供人们使用。进而不同的应用可以使用相同的数据库来共享它们的数据。数据库的出现使人们放弃了为每个独立的应用开发数据存储的想法，同时，随着数据库广泛的使用，其处理能力飞速发展，演进出如现代的分布式数据
分库分表索引设计：二级索引、全局索引的最佳设计实践
m0_71777195的博客
06-27 995
对主键来说，要保证在所有分片中都唯一，它本质上就是一个全局唯一的索引。如果用大部分同学喜欢的自增作为主键，就会发现存在很大的问题。因为自增并不能在插入前就获得值，而是要通过填 NULL 值，然后再通过函数 last_insert_id()获得自增的值。所以，如果在每个分片上通过自增去实现主键，可能会出现同样的自增值存在于不同的分片上。比如，对于电商的订单表 orders，其表结构如下（分片键是o_custkey，表的主键是o_orderkey）： 如果把 o_orderkey 设计成上图所示的自增，那么
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值