## （三）儲存引擎

openGauss儲存引擎是可插拔、自組裝的，支援多個儲存引擎來滿足不同場景的業務訴求，目前支援行儲存引擎、列儲存引擎和記憶體引擎。

早期計算機程式透過檔案系統管理資料，到了20世紀60年代這種方式就開始不能滿足資料管理要求了，使用者逐漸對資料併發寫入的完整性、高效檢索提出更高的要求。由於機械磁碟的隨機讀寫效能問題，從20世紀80年代開始，大多數資料庫一直在圍繞著減少隨機讀寫磁碟進行設計。主要思路是把對資料頁面的隨機寫盤轉化為對WAL（Write Ahead Log，預寫式日誌）日誌的順序寫盤，WAL日誌持久化完成，事務就算提交成功，資料頁面非同步刷盤。但是隨著記憶體容量變大、保電記憶體、非易失性記憶體的發展，以及SSD技術逐漸的成熟，IO效能極大提高，經歷了幾十年發展的儲存引擎需要調整架構來發揮SSD的效能和充分利用大記憶體計算的優勢。隨著網際網路、移動網際網路的發展，資料量劇增，業務場景多樣化，一套固定不變的儲存引擎不可能滿足所有應用場景的訴求。因此現在的DBMS需要設計支援多種儲存引擎，根據業務場景來選擇合適的儲存模型。

### 1. 資料庫儲存引擎要解決的問題

- 儲存的資料必須要保證ACID：原子性、一致性、隔離性、永續性。
 - 高併發讀寫，高效能。
 - 資料高效儲存和檢索能力。

### 2. openGauss儲存引擎概述

openGauss整個系統設計支援多個儲存引擎來滿足不同場景的業務訴求。當前openGauss儲存引擎有以下3種：

- 行儲存引擎。主要面向OLTP（Online Transaction Processing，線上交易處理）場景設計，例如訂貨發貨，銀行交易系統。
 - 列儲存引擎。主要面向OLAP（Online Analytical Processing，聯機分析處理）場景設計，例如資料統計報表分析。
 - 記憶體引擎。主要面向極致效能場景設計，例如銀行風控場景。

建立表的時候可以指定行儲存引擎、列存引擎的表、記憶體引擎的表，支援一個事務裡包含對3種引擎表的DML（Data Manipulation Language，資料操作語言）操作，可以保證事務ACID性質。

#### 1） storage原始碼組織

storage原始碼目錄為：/src/gausskernel/storage。storage原始碼檔案如表1所示。

####  2） storage主流程

storage主流程程式碼如下。

```python
/* smgr/smgr.cpp, 儲存管理 */
...
/* 檔案管理函式列表，包含磁碟初始化、開關、同步等操作函式 */
static const f_smgr g_smgrsw[] = {   
 /* 磁碟*/    
 {mdinit, 
        NULL, 
       mdclose, 
       mdcreate, 
       mdexists, 
       mdunlink, 
       mdextend, 
       mdprefetch, 
       mdread, 
       mdwrite, 
       mdwriteback, 
       mdnblocks, 
       mdtruncate,  
       mdimmedsync, 
       mdpreckpt,  
       mdsync, 
       mdpostckpt,
       mdasyncread, 
       mdasyncwrite}};
 /* 
 *  儲存管理初始化 * 
 * 當伺服器後端啟動時呼叫 */
 * void smgrinit(void)
 * {    int i;
 * /* 初始化所有儲存相關管理器 */    
 * for (i = 0; i < SMGRSW_LENGTH; i++) {
 if (g_smgrsw[i].smgr_init) {            (*(g_smgrsw[i].smgr_init))();        }    }    
  /* 登記儲存管理終止程式 */  
    if (!IS_THREAD_POOL_SESSION) {        
    on_proc_exit(smgrshutdown, 0);   
     }}/* 
     * 當後端服務關閉時，執行儲存管理關閉程式碼 */
     * static void smgrshutdown(int code, Datum arg){    int i;
     * /* 關閉所有儲存關聯服務 */
     *     for (i = 0; i < SMGRSW_LENGTH; i++) { 
      if (g_smgrsw[i].smgr_shutdown) {  
     (*(g_smgrsw[i].smgr_shutdown))(); 
     } 
      }
      }
```

### 3. 行儲存引擎

openGauss的行儲存引擎設計上支援MVCC（Multi-Version Concurrency Control，多版本併發控制），採用集中式垃圾版本回收機制，可以提供OLTP業務系統的高併發讀寫要求。支援儲存計算分離架構，儲存層非同步回放日誌。如圖1所示。
![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20210426105153664.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0dhdXNzREI=,size_16,color_FFFFFF,t_70#pic_center)

|圖1 行儲存架構|

行儲存引擎的關鍵技術有：

- 基於CSN（Commit Sequence Number，待提交事務的序列號，它是一個64位遞增無符號數）的MVCC併發控制機制，集中式垃圾資料清理。
 - 並行刷日誌，並行恢復。傳統資料庫一般都採用序列刷日誌的設計，因為日誌有順序依賴關係，例如一個是事務產生的redo/undo log是有前後依賴關係的。openGauss的日誌系統採用多個logwriter執行緒並行寫的機制，充分發揮SSD的多通道IO能力。
 - 基於大記憶體設計的Buffer manager。

行儲存buffer主流程程式碼如下。

```python
/* buffer/bufmgr.cpp, 基礎行儲存管理 */
...
/* 查詢或建立一個緩衝區 */
Buffer ReadBufferExtended(
    Relation reln, ForkNumber fork_num, BlockNumber block_num, ReadBufferMode mode, BufferAccessStrategy strategy)
{
    bool hit = false;
    Buffer buf;

if (block_num == P_NEW) {
        STORAGE_SPACE_OPERATION(reln, BLCKSZ);
    }

/* 以smgr(儲存管理器)級別開啟一個緩衝區 */
    RelationOpenSmgr(reln);

/* 拒絕讀取非區域性臨時關係的請求，因為可能會獲得監控不到的錯誤資料 */
    if (RELATION_IS_OTHER_TEMP(reln) && fork_num <= INIT_FORKNUM)
        ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot access temporary tables of other sessions")));

/* 讀取緩衝區，更新pgstat 數量反饋cache 命中與否情況 */
    pgstat_count_buffer_read(reln);
    pgstatCountBlocksFetched4SessionLevel();
    buf = ReadBuffer_common(reln->rd_smgr, reln->rd_rel->relpersistence, fork_num, block_num, mode, strategy, &hit);
    if (hit) {
        pgstat_count_buffer_hit(reln);
    }
    return buf;
}

/* 釋放一個緩衝區 */
void ReleaseBuffer(Buffer buffer)
{
    BufferDesc* buf_desc = NULL;
    PrivateRefCountEntry* ref = NULL;
    /* 錯誤釋放處理 */
    if (!BufferIsValid(buffer)) {
        ereport(ERROR, (errcode(ERRCODE_INVALID_BUFFER), (errmsg("bad buffer ID: %d", buffer))));
    }

ResourceOwnerForgetBuffer(t_thrd.utils_cxt.CurrentResourceOwner, buffer);

if (BufferIsLocal(buffer)) {
        Assert(u_sess->storage_cxt.LocalRefCount[-buffer - 1] > 0);
        u_sess->storage_cxt.LocalRefCount[-buffer - 1]--;
        return;
    }
    /* 釋放當前緩衝區 */
    buf_desc = GetBufferDescriptor(buffer - 1);

PrivateRefCountEntry *free_entry = NULL;
    ref = GetPrivateRefCountEntryFast(buffer, free_entry);
    if (ref == NULL) {
        ref = GetPrivateRefCountEntrySlow(buffer, false, false, free_entry);}
    Assert(ref != NULL);
    Assert(ref->refcount > 0);

if (ref->refcount > 1) {
        ref->refcount--;
    } else {
        UnpinBuffer(buf_desc, false);
    }
}
/* 標記寫髒緩衝區 */
void MarkBufferDirty(Buffer buffer)
{
    BufferDesc* buf_desc = NULL;
    uint32 buf_state;
    uint32 old_buf_state;

if (!BufferIsValid(buffer)) {
        ereport(ERROR, (errcode(ERRCODE_INVALID_BUFFER), (errmsg("bad buffer ID: %d", buffer))));}

if (BufferIsLocal(buffer)) {
        MarkLocalBufferDirty(buffer);
        return;
    }

buf_desc = GetBufferDescriptor(buffer - 1);

Assert(BufferIsPinned(buffer));
    Assert(LWLockHeldByMe(buf_desc->content_lock));

old_buf_state = LockBufHdr(buf_desc);

buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);

/* 將未入隊的髒頁入隊 */
    if (g_instance.attr.attr_storage.enableIncrementalCheckpoint) {
        for (;;) {
            buf_state = old_buf_state | (BM_DIRTY | BM_JUST_DIRTIED);
            if (!XLogRecPtrIsInvalid(pg_atomic_read_u64(&buf_desc->rec_lsn))) {
                break;
            }

if (!is_dirty_page_queue_full(buf_desc) && push_pending_flush_queue(buffer)) {
                break;
            }

UnlockBufHdr(buf_desc, old_buf_state);
            pg_usleep(TEN_MICROSECOND);
            old_buf_state = LockBufHdr(buf_desc);
        }
    }

UnlockBufHdr(buf_desc, buf_state);

/* 如果緩衝區不是“髒”狀態，則更新相關計數 */
    if (!(old_buf_state & BM_DIRTY)) {
        t_thrd.vacuum_cxt.VacuumPageDirty++;
        u_sess->instr_cxt.pg_buffer_usage->shared_blks_dirtied++;

pgstatCountSharedBlocksDirtied4SessionLevel();

if (t_thrd.vacuum_cxt.VacuumCostActive) {
            t_thrd.vacuum_cxt.VacuumCostBalance += u_sess->attr.attr_storage.VacuumCostPageDirty;
        }
    }
}
```

### 4. 列儲存引擎

傳統行儲存資料壓縮率低，必須按行讀取，即使讀取一列也必須讀取整行。openGauss建立表的時候，可以指定行儲存還是列儲存。列儲存表也支援DML操作，也支援MVCC。列儲存架構如圖2所示。

![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20210426111732734.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0dhdXNzREI=,size_16,color_FFFFFF,t_70#pic_center)

|圖2 列儲存架構|

列儲存引擎有以下優勢：

- 列的資料特徵比較相似，適合壓縮，壓縮比很高。
 - 當表列的個數比較多，但是訪問的列個數比較少時，列存可以按需讀取列資料，大大減少不必要的讀IO，提高查詢效能。
 - 基於列批次資料Vector（向量）的運算，CPU的cache命中率比較高，效能比較好。列儲存引擎更適合OLAP大資料統計分析的場景。

#### 1） 列儲存原始碼組織

列儲存原始碼目錄為：/src/gausskernel/storage/cstore。列儲存原始碼檔案如表2所示。

表2 列儲存原始碼檔案

####  2） 列儲存主要API

列儲存主要API程式碼如下。

```python
/*  cstore_am.cpp */
...
/*  掃描 APIs */
    void InitScan(CStoreScanState *state, Snapshot snapshot = NULL);
    void InitReScan();
    void InitPartReScan(Relation rel);
    bool IsEndScan() const;

/*  延遲讀取APIs */
    bool IsLateRead(int id) const;
    void ResetLateRead();

/*  更新列儲存掃描計時標記*/
    void SetTiming(CStoreScanState *state);

/*  列儲存掃描*/
    void ScanByTids(_in_ CStoreIndexScanState *state, _in_ VectorBatch *idxOut, _out_ VectorBatch *vbout);
    void CStoreScanWithCU(_in_ CStoreScanState *state, BatchCUData *tmpCUData, _in_ bool isVerify = false);

/*  載入資料壓縮單元描述資訊  */
    bool LoadCUDesc(_in_ int col, __inout LoadCUDescCtl *loadInfoPtr, _in_ bool prefetch_control, _in_ Snapshot snapShot = NULL);

/*  從描述表中獲取資料壓縮單元描述*/
    bool GetCUDesc(_in_ int col, _in_ uint32 cuid, _out_ CUDesc *cuDescPtr, _in_ Snapshot snapShot = NULL);

/*  獲取元組刪除資訊*/
    void GetCUDeleteMaskIfNeed(_in_ uint32 cuid, _in_ Snapshot snapShot);

bool GetCURowCount(_in_ int col, __inout LoadCUDescCtl *loadCUDescInfoPtr, _in_ Snapshot snapShot);
    /* 獲取實時行號。 */
    int64 GetLivedRowNumbers(int64 *deadrows);

/*  獲得資料壓縮單元*/
    CU *GetCUData(_in_ CUDesc *cuDescPtr, _in_ int colIdx, _in_ int valSize, _out_ int &slotId);

CU *GetUnCompressCUData(Relation rel, int col, uint32 cuid, _out_ int &slotId, ForkNumber forkNum = MAIN_FORKNUM,
                            bool enterCache = true) const;

/*  緩衝向量填充 APIs */
    int FillVecBatch(_out_ VectorBatch *vecBatchOut);

/*  填充列向量*/
    template <bool hasdeadrow="" int="" attlen="">
    int FillVector(_in_ int colIdx, _in_ CUDesc *cu_desc_ptr, _out_ ScalarVector *vec);

template <int attlen="">
    void FillVectorByTids(_in_ int colIdx, _in_ ScalarVector *tids, _out_ ScalarVector *vec);

template <int attlen="">
    void FillVectorLateRead(_in_ int seq, _in_ ScalarVector *tids, _in_ CUDesc *cuDescPtr, _out_ ScalarVector *vec);

void FillVectorByIndex(_in_ int colIdx, _in_ ScalarVector *tids, _in_ ScalarVector *srcVec, _out_ ScalarVector *destVec);

/*  填充系統列*/
    int FillSysColVector(_in_ int colIdx, _in_ CUDesc *cu_desc_ptr, _out_ ScalarVector *vec);

template <int syscoloid="">
    void FillSysVecByTid(_in_ ScalarVector *tids, _out_ ScalarVector *destVec);

template <bool hasdeadrow="">
    int FillTidForLateRead(_in_ CUDesc *cuDescPtr, _out_ ScalarVector *vec);

void FillScanBatchLateIfNeed(__inout VectorBatch *vecBatch);

/* 設定資料壓縮單元範圍以支援索引掃描 */
    void SetScanRange();

/*  判斷行是否可用*/
    bool IsDeadRow(uint32 cuid, uint32 row) const;

void CUListPrefetch();
    void CUPrefetch(CUDesc *cudesc, int col, AioDispatchCUDesc_t **dList, int &count, File *vfdList);

/* 掃描函式 */
    typedef void (CStore::*ScanFuncPtr)(_in_ CStoreScanState *state, _out_ VectorBatch *vecBatchOut);
    void RunScan(_in_ CStoreScanState *state, _out_ VectorBatch *vecBatchOut);
    int GetLateReadCtid() const;
    void IncLoadCuDescCursor();
```

### 5. 記憶體引擎

openGauss引入了MOT（Memory-Optimized Table，記憶體最佳化表）儲存引擎，它是一種事務性行儲存，針對多核和大記憶體伺服器進行了最佳化。MOT是openGauss資料庫出色的生產級特性（Beta版本），它為事務性工作負載提供更高的效能。MOT完全支援ACID特性，幷包括嚴格的永續性和高可用性支援。企業可以在關鍵任務、效能敏感的線上事務處理（OLTP）中使用MOT，以實現高效能、高吞吐、可預測低延遲以及多核伺服器的高利用率。MOT尤其適合在多路和多核處理器的現代伺服器上執行，例如基於ARM（Advanced RISC Machine，高階精簡指令集計算機器）/鯤鵬處理器的華為TaiShan伺服器，以及基於x86的戴爾或類似伺服器。MOT儲存引擎如圖3所示。

![在這裡插入圖片描述](https://img-blog.csdnimg.cn/20210426112200233.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0dhdXNzREI=,size_16,color_FFFFFF,t_70#pic_center)

|圖3 openGauss記憶體引擎|

MOT與基於磁碟的普通表並排建立。MOT的有效設計實現了幾乎完全的SQL覆蓋，並且支援完整的資料庫功能集，如儲存過程和自定義函式。透過完全儲存在記憶體中的資料和索引、非統一記憶體訪問感知（NUMA-aware）設計、消除鎖和鎖存爭用的演算法以及查詢原生編譯，MOT可提供更快的資料訪問和更高效的事務執行。MOT有效的幾乎無鎖的設計和高度調優的實現，使其在多核伺服器上實現了卓越的近線性吞吐量擴充套件。

MOT的高效能（查詢和事務延遲）、高可擴充套件性（吞吐量和併發量）等特點，在某些情況下低成本（高資源利用率）方面擁有顯著優勢。

- 低延遲（Low Latency）：提供快速的查詢和事務響應時間。
 - 高吞吐量（High Throughput）：支援峰值和持續高使用者併發。
 - 高資源利用率（High Resource Utilization）：充分利用硬體。

MOT的關鍵技術如下：

- 記憶體最佳化資料結構：以實現高併發吞吐量和可預測的低延遲為目標，所有資料和索引都在記憶體中，不使用中間頁緩衝區，並使用持續時間最短的鎖。資料結構和所有演算法都是專門為記憶體設計而最佳化的。
 - 免鎖事務管理：MOT在保證嚴格一致性和資料完整性的前提下，採用樂觀的策略實現高併發和高吞吐。在事務過程中，MOT不會對正在更新的資料行的任何版本加鎖，從而大大降低了一些大記憶體系統中的爭用。
 - 免鎖索引：由於記憶體表的資料和索引完全儲存在記憶體中，因此擁有一個高效的索引資料結構和演算法非常重要。MOT索引機制基於領域前沿的樹結構Masstree，一種用於多核系統的快速和可擴充套件的鍵值（Key Value，KV）儲存索引，以B+樹的Trie實現。透過這種方式，高併發工作負載在多核伺服器上可以獲得卓越的效能。同時MOT應用了各種先進的技術以最佳化效能，如最佳化鎖方法、快取記憶體感知和記憶體預取。
 - NUMA-aware的記憶體管理：MOT記憶體訪問的設計支援非統一記憶體訪問（NUMA，Non-Uniform Memory Access）感知。NUMA-aware演算法增強了記憶體中資料佈局的效能，使執行緒訪問物理上連線到執行緒執行的核心的記憶體。這是由記憶體控制器處理的，不需要透過使用互連（如英特爾QPI（Quick Path Interconnect，快速路徑互連））進行額外的跳轉。MOT的智慧記憶體控制模組，為各種記憶體物件預先分配了記憶體池，提高了效能、減少了鎖、保證了穩定性。
 - 高效永續性：日誌和檢查點是實現磁碟持久化的關鍵能力，也是ACID的關鍵要求之一。目前所有的磁碟（包括SSD和NVMe（Non-Volatile Memory express，非易失性高速傳輸匯流排））都明顯慢於記憶體，因此持久化是基於記憶體資料庫引擎的瓶頸。作為一個基於記憶體的儲存引擎，MOT的持久化設計必須實現各種各樣的演算法最佳化，以確保持久化的同時還能達到設計時的速度和吞吐量目標。
 - 高SQL覆蓋率和功能集：MOT透過擴充套件的openGauss外部資料封裝（Foreign Data Wrapper，FDW）以及索引，幾乎支援完整的SQL範圍，包括儲存過程、使用者定義函式和系統函式呼叫。
 - 使用PREPARE語句的查詢原生編譯：透過使用PREPARE客戶端命令，可以以互動方式執行查詢和事務語句。這些命令已被預編譯成原生執行格式，也稱為Code-Gen或即時（Just-in-Time，JIT）編譯。這樣可以實現平均30%的效能提升。
 - MOT和openGauss資料庫的無縫整合：MOT是一個高效能的面向記憶體最佳化的儲存引擎，已整合在openGauss軟體包中。MOT的主記憶體引擎和基於磁碟的儲存引擎並存，以支援多種應用場景，同時在內部重用資料庫輔助服務，如WAL重做日誌、複製、檢查點和恢復高可用性等。

#### 1） 記憶體引擎原始碼組織

記憶體引擎原始碼目錄為：/src/gausskernel/storage/mot。記憶體引擎原始碼檔案如表3所示。

表3 記憶體引擎原始碼檔案

####  2） 記憶體引擎主流程

記憶體引擎主流程程式碼如下。

```python
/* system/mot_engine.cpp */
...
/* 建立記憶體引擎例項 */
MOTEngine* MOTEngine::CreateInstance(
    const char* configFilePath /* = nullptr */, int argc /* = 0 */, char* argv[] /* = nullptr */)
{
    if (m_engine == nullptr) {
        if (CreateInstanceNoInit(configFilePath, argc, argv) != nullptr) {
            bool result = m_engine->LoadConfig();
            if (!result) {
                MOT_REPORT_ERROR(MOT_ERROR_INTERNAL, "System Startup", "Failed to load Engine configuration");
            } else {
                result = m_engine->Initialize();
                if (!result) {
                    MOT_REPORT_ERROR(MOT_ERROR_INTERNAL, "System Startup", "Engine initialization failed");
                }
            }

if (!result) {
                DestroyInstance();
                MOT_ASSERT(m_engine == nullptr);
            }
        }
    }
    return m_engine;
}
/* 記憶體引擎初始化 */
bool MOTEngine::Initialize()
{
    bool result = false;
/* 初始化應用服務，開始後臺任務 */
    do {  // instead of goto
        m_initStack.push(INIT_CORE_SERVICES_PHASE);
        result = InitializeCoreServices();
        CHECK_INIT_STATUS(result, "Failed to Initialize core services");

m_initStack.push(INIT_APP_SERVICES_PHASE);
        result = InitializeAppServices();
        CHECK_INIT_STATUS(result, "Failed to Initialize applicative services");

m_initStack.push(START_BG_TASKS_PHASE);
        result = StartBackgroundTasks();
        CHECK_INIT_STATUS(result, "Failed to start background tasks");
    } while (0);

if (result) {
        MOT_LOG_INFO("Startup: MOT Engine initialization finished successfully");
        m_initialized = true;
    } else {
        MOT_LOG_PANIC("Startup: MOT Engine initialization failed!");
        /* 呼叫方應在失敗後呼叫DestroyInstance() */
    }

return result;
}
/* 銷燬記憶體引擎例項 */
void MOTEngine::Destroy()
{
    MOT_LOG_INFO("Shutdown: Shutting down MOT Engine");
    while (!m_initStack.empty()) {
        switch (m_initStack.top()) {
            case START_BG_TASKS_PHASE:
                StopBackgroundTasks();
                break;

case INIT_APP_SERVICES_PHASE:
                DestroyAppServices();
                break;

case INIT_CORE_SERVICES_PHASE:
                DestroyCoreServices();
                break;

case LOAD_CFG_PHASE:
                break;

case INIT_CFG_PHASE:
                DestroyConfiguration();
                break;

default:
                break;
        }
        m_initStack.pop();
    }
    ClearErrorStack();
    MOT_LOG_INFO("Shutdown: MOT Engine shutdown finished");
}
```</bool></int></int></int></bool>

openGauss資料庫原始碼解析系列文章——openGauss簡介（二）

相關文章