【 OpenGauss源码学习 —— 列存储（CStore）（二）】

已于 2024-03-01 11:00:38 修改
阅读量335 收藏
点赞数 1
分类专栏： OpenGauss 文章标签： gaussdb 数据库
于 2023-11-02 10:59:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43899283/article/details/134166411
版权

列存储（CStore）（二）

声明：本文的部分内容参考了他人的文章。在编写过程中，我们尊重他人的知识产权和学术成果，力求遵循合理使用原则，并在适用的情况下注明引用来源。
本文主要参考了 OpenGauss1.1.0 的开源代码和《OpenGauss数据库源码解析》一书以及OpenGauss社区学习文档和一些学习资料

概述

  在【 OpenGauss源码学习 —— 列存储（CStore）（一）】中我们介绍了部分 CStore 类中的静态成员函数。本节我们将介绍 CStore 类中的部分公有成员函数。
   CStore 类中的公有成员提供了一系列用于处理列存储表的扫描、数据获取、元组处理和性能优化等操作的函数，为数据管理和查询提供了必要的功能支持。
  以下是其主要功能和作用的总结：（详细函数功能描述可以查看【 OpenGauss源码学习 —— 列存储（CStore）（一）】中的函数功能说明表）

  1. 初始化扫描相关函数：InitScan, InitReScan, InitPartReScan, IsEndScan, SetTiming 等函数用于初始化扫描状态，管理扫描进度和时间性能。
  2. 扫描函数：ScanByTids, CStoreScanWithCU 等函数用于执行列存储表的扫描操作，获取数据并返回结果。
  3. CUDesc 相关函数：LoadCUDesc, GetCUDesc, GetCUDeleteMaskIfNeed, GetCURowCount 等函数用于加载和获取列的压缩单元描述信息，以及获取行数和元组删除信息。
  4. 数据获取函数：GetCUData, GetUnCompressCUData 等函数用于获取列存储中的压缩单元数据。
  5. 填充 Vector 函数：FillVecBatch, FillVector, FillVectorByTids, FillVectorLateRead, FillVectorByIndex, FillSysColVector, FillSysVecByTid, FillTidForLateRead, FillScanBatchLateIfNeed 等函数用于填充向量数据结构，用于结果集的构建和处理。
  6. 扫描范围设置函数：SetScanRange 用于在重分发操作中设置扫描的 CU 范围。
  7. 元组生死判断函数：IsDeadRow 用于判断指定的行是否为死亡行。
  8. 预取函数：CUListPrefetch, CUPrefetch 用于执行预取操作，提高数据读取性能。
  9. 扫描执行函数：RunScan 用于执行列存储表的扫描操作，返回结果。
  10. 辅助函数：GetLateReadCtid, IncLoadCuDescCursor 用于辅助扫描操作和数据加载。

CStore::InitScan 函数

  CStore::InitScan 函数主要用于初始化列存储扫描的上下文、内存管理和其他必要的状态信息，以便后续执行列存储扫描操作。该函数的作用是初始化用于扫描列存储表的数据结构和环境。首先，它创建了用于扫描的内存上下文和每个扫描的内存上下文，以便有效地管理内存分配。然后，它设置了实际扫描操作的函数指针，并根据表的属性信息初始化压缩单元（CU）数据存储结构。接下来，它初始化用于跟踪已加载 CU 描述的数组和其他扫描相关的参数。最后，它设置了范围扫描标志，初始化扫描范围，并记录当前计划节点的 ID。函数源码如下所示：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

void CStore::InitScan(CStoreScanState* state, Snapshot snapshot)
{
    // 断言确保传递的扫描状态 `state` 和投影信息不为空
    Assert(state && state->ps.ps_ProjInfo);

    // 创建用于扫描的内存上下文（memory context）
    m_scanMemContext = AllocSetContextCreate(CurrentMemoryContext,
                                             "cstore scan memory context",
                                             ALLOCSET_DEFAULT_MINSIZE,
                                             ALLOCSET_DEFAULT_INITSIZE,
                                             ALLOCSET_DEFAULT_MAXSIZE);
    
    // 创建每个扫描的内存上下文，这些内存上下文将用于分配和管理扫描期间的内存
    m_perScanMemCnxt = AllocSetContextCreate(CurrentMemoryContext,
                                             "cstore scan per scan memory context",
                                             ALLOCSET_DEFAULT_MINSIZE,
                                             ALLOCSET_DEFAULT_INITSIZE,
                                             ALLOCSET_DEFAULT_MAXSIZE);

    // 设置扫描函数指针为 &CStore::CStoreScan，用于执行列存储的实际扫描操作
    m_scanFunc = &CStore::CStoreScan;

    // 初始化用于存储压缩单元（CU）数据的数据结构
    // 根据表的属性信息，分配和初始化 CU 存储结构
    m_relation = state->ss_currentRelation;
    int attNo = m_relation->rd_att->natts;
    m_cuStorage = (CUStorage**)palloc(sizeof(CUStorage*) * attNo);

    for (int i = 0; i < attNo; ++i) {
        if (m_relation->rd_att->attrs[i]->attisdropped) {
            m_cuStorage[i] = NULL;
            continue;
        }
        m_firstColIdx = i;
        CFileNode cFileNode(m_relation->rd_node, m_relation->rd_att->attrs[i]->attnum, MAIN_FORKNUM);
        m_cuStorage[i] = New(CurrentMemoryContext) CUStorage(cFileNode);
    }

    // 分配并初始化用于跟踪已加载 CU 描述的数组
    m_CUDescIdx = (int*)palloc(sizeof(int) * u_sess->attr.attr_storage.max_loaded_cudesc);
    errno_t rc = memset_s((char*)m_CUDescIdx,
                          sizeof(int) * u_sess->attr.attr_storage.max_loaded_cudesc,
                          0xFF,
                          sizeof(int) * u_sess->attr.attr_storage.max_loaded_cudesc);
    securec_check(rc, "\0", "\0");

    // 初始化一些其他参数，如 m_cursor、m_colNum、m_NumCUDescIdx、m_rowCursorInCU、m_prefetch_quantity 等
    m_cursor = 0;
    m_colNum = 0;
    m_NumCUDescIdx = 0;
    m_rowCursorInCU = 0;
    
    // 初始化用于预取操作的参数 m_prefetch_quantity 和 m_prefetch_threshold
    m_prefetch_quantity = 0;
    m_prefetch_threshold = Min(CUCache->m_cstoreMaxSize / 4, u_sess->attr.attr_storage.cstore_prefetch_quantity * 1024LL);

    // 保存传递的快照信息
    m_snapshot = snapshot;

    // 设置范围扫描标志 m_rangeScanInRedis
    m_rangeScanInRedis = state->rangeScanInRedis;

    // 调用 SetScanRange 初始化扫描范围
    SetScanRange();

    // 调用初始化函数 InitFillVecEnv 和 InitRoughCheckEnv 初始化环境
    InitFillVecEnv(state);
    InitRoughCheckEnv(state);

    // 记录当前计划节点的 ID
    m_plan_node_id = state->ps.plan->plan_node_id;
}

函数的执行过程包括以下步骤：

  1. 检查传递的扫描状态和投影信息是否非空。
  2. 创建用于扫描的内存上下文和每个扫描的内存上下文。
  3. 设置扫描函数的指针为实际的列存储扫描函数。
  4. 根据表的属性信息初始化 CU 数据存储结构。
  5. 分配和初始化用于跟踪已加载 CU 描述的数组。
  6. 初始化其他扫描相关的参数。
  7. 设置范围扫描标志。
  8. 初始化扫描范围。
  9. 初始化环境并记录计划节点的 ID。

CStore::ScanByTids 函数

  该函数用于执行按行扫描列存储表的操作，根据传入的TID（元组标识符）信息，填充输出的列存储数据。函数的执行过程如下：

  1. 首先，进行断言检查，确保传递的扫描状态 state、输入向量 idxOut 和输出向量 vbout 不为空，并确保输入向量 idxOut 中至少包含一个列。
  2. 在开始实际扫描操作之前，根据传入的 TID 信息，设置输出行数 vbout->m_rows 为输入向量 idxOut 中的行数。
  3. 遍历要扫描的所有列，分别进行以下操作：
  • 对于索引表中的列，将索引表的扫描结果复制到输出向量 vbout 中。
  • 对于非索引列，调用相应的填充函数进行数据填充，并更新输出向量 vbout 的行数。
  1. 如果需要填充系统列，分别填充以下系统列信息：
  • SelfItemPointerAttributeNumber：元组自身的 TID。
  • TableOidAttributeNumber：表的 OID。
  • XC_NodeIdAttributeNumber：节点 ID。
  • MinTransactionIdAttributeNumber：最小事务 ID。
  1. 如果只需要填充常量列，根据 TID 信息计算出存活行数，并设置输出向量 vbout 的行数。

  总之，该函数的主要功能是根据传入的 TID 信息，填充列存储表的数据，并将结果存储在输出向量 vbout 中。函数源码如下所示：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

void CStore::ScanByTids(_in_ CStoreIndexScanState* state, _in_ VectorBatch* idxOut, _out_ VectorBatch* vbout)
{
    // 断言确保传递的扫描状态 `state`、输入向量 `idxOut` 和输出向量 `vbout` 不为空
    Assert(state && idxOut && vbout);
    // 断言确保输入向量 `idxOut` 中至少包含一个列
    Assert(idxOut->m_cols >= 1);

    // 开始记录扫描操作的性能跟踪信息
    CSTORESCAN_TRACE_START(SCAN_BY_TID);

    // 获取索引输出向量的基表属性列信息和属性列数量
    int* indexOutBaseTabAttr = state->m_indexOutBaseTabAttr;
    int indexOutAttrNo = state->m_indexOutAttrNo;

    // 根据是否存在索引表判断是否使用B树索引
    m_useBtreeIndex = (state->m_indexScan == NULL) ? true : false;

    /*
     * Pre-Step: 对于常量目标列表，设置输出行数。
     */
    vbout->m_rows = idxOut->m_rows;

    // 获取TID列的向量
    ScalarVector* tids = idxOut->m_arr + idxOut->m_cols - 1;

    // Step 1: 根据TID填充普通列向量
    CSTORESCAN_TRACE_START(FILL_VECTOR_BATCH_BY_TID);
    for (int i = 0; i < m_colNum; i++) {
        int idx = m_colId[i];

        // 判断该列是否已在索引表扫描中处理
        bool isInIndexOut = false;
        for (int j = 0; j < indexOutAttrNo; j++) {
            if (idx == indexOutBaseTabAttr[j] - 1) {
                // 将索引表的扫描结果复制到输出向量 `vbout` 中
                // 注意：这是浅拷贝操作
                FillVectorByIndex(idx, tids, idxOut->m_arr + j, vbout->m_arr + idx);
                vbout->m_rows = (vbout->m_arr + idx)->m_rows;
                isInIndexOut = true;
                break;
            }
        }

        if (isInIndexOut)
            continue;

        // 断言确保 `m_fillVectorByTids` 不为空
        Assert(m_fillVectorByTids[i]);
        // 根据TID填充列向量
        (this->*m_fillVectorByTids[i])(idx, tids, &vbout->m_arr[idx]);
        vbout->m_rows = vbout->m_arr[idx].m_rows;
    }
    CSTORESCAN_TRACE_END(FILL_VECTOR_BATCH_BY_TID);

    // Step 2: 填充系统列（如TID、表OID、节点ID、最小事务ID等）
    for (int i = 0; i < m_sysColNum; i++) {
        int sysColIdx = m_sysColId[i];
        ScalarVector* sysVec = vbout->GetSysVector(sysColIdx);

        switch (sysColIdx) {
            case SelfItemPointerAttributeNumber: {
                FillSysVecByTid<SelfItemPointerAttributeNumber>(tids, sysVec);
                break;
            }
            case TableOidAttributeNumber: {
                FillSysVecByTid<TableOidAttributeNumber>(tids, sysVec);
                break;
            }
            case XC_NodeIdAttributeNumber: {
                FillSysVecByTid<XC_NodeIdAttributeNumber>(tids, sysVec);
                break;
            }
            case MinTransactionIdAttributeNumber: {
                FillSysVecByTid<MinTransactionIdAttributeNumber>(tids, sysVec);
                break;
            }
            default: {
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         (errmsg("无法填充不支持的系统列 %d 到列存储表", sysColIdx))));
                break;
            }
        }

        vbout->m_rows = sysVec->m_rows;
    }

    // Step 3: 如果只需要填充常量列
    if (unlikely(m_onlyConstCol)) {
        // 仅设置行数，不进行具体数据填充
        int liveRows = 0;
        ScalarVector* vec = vbout->m_arr;
        ScalarValue* tidValue = tids->m_vals;
        uint32 curCUId = InValidCUID;
        uint32 thisCUId = InValidCUID;
        uint32 rowOffset = 0;

        for (int i = 0; i < tids->m_rows; i++) {
            ItemPointer tidPtr = (ItemPointer)&tidValue[i];
            thisCUId = ItemPointerGetBlockNumber(tidPtr);

            // 注意：TID的rowOffset从1开始
            rowOffset = ItemPointerGetOffsetNumber(tidPtr) - 1;

            // 获取CU描述信息和删除掩码（如果需要）
            if (curCUId != thisCUId) {
                curCUId = thisCUId;
                GetCUDeleteMaskIfNeed(curCUId, m_snapshot);
            }
            // 如果是存活行而不是已删除行，增加存活行数
            if (m_delMaskCUId != InValidCUID && !IsDeadRow(curCUId, rowOffset))
                ++liveRows;
        }

        // 设置输出向量 `vec` 的行数
        vec->m_rows = liveRows;
        vbout->m_rows = vec->m_rows;
    }

    // 结束性能跟踪
    CSTORESCAN_TRACE_END(SCAN_BY_TID);
}

CStore::CStoreScanWithCU 函数

  CStore::CStoreScanWithCU 函数的主要作用是扫描列存储表中的数据，但是与通常的 CStoreScan 不同，它将整个"行"（具有相同的 CUID）的 CU 以及相应的 CUDesc 和位图一次性加载和处理，通常用于 CStore 分区合并，支持 ADIO 操作，通过加载和处理 CU 和 CUDesc 来实现列存储表的查询和操作，同时支持 CU 的验证。函数源码如下所示：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/*
 * @Description: 类似于CStoreScan，但是移动整个CU的"行"（相同的CUID），以及相应的CUDesc和位图。
 *			   到目前为止，主要用于CStore分区合并。
 *			   支持ADIO。
 *			   注意：通过使用CUStorage->LoadCU，我们使用CStoreMemAlloc::Palloc来分配分配给BatchCUData->CUptrData的CU_ptr(s)。
 *			   因此，它们在完成后必须在CStoreMemAlloc::Pfree中释放。
 * @See also: ATExecCStoreMergePartition
 */
void CStore::CStoreScanWithCU(_in_ CStoreScanState* state, __inout BatchCUData* batchCUData, _in_ bool isVerify)
{
    // 步骤1: 保持的CUDesc的数量是max_loaded_cudesc
    // 如果我们一次加载所有CUDesc，内存不够。
    // 因此，我们一次加载max_loaded_cudesc的CUDesc
    LoadCUDescIfNeed();

    // 步骤2: 如果需要，进行粗略检查
    // 通过CU的最小/最大值消除CU。
    // 对ADIO非常重要。
    RoughCheckIfNeed(state);

    /*
     * 步骤3: 是否有CU命中
     * 我们将不填充向量，因为没有CU命中
     */
    ADIO_RUN()
    {
        if (unlikely(m_cursor == m_NumCUDescIdx)) {
            return;
        }
    }
    ADIO_ELSE()
    {
        if (unlikely(m_NumLoadCUDesc == 0)) {
            return;
        }
    }
    ADIO_END();

    /*
     * 步骤4:
     * 加载当前正在处理的行的CUDescs和CUs
     *
     *   1. 带有CUDescs的已处理行的数量
     *   2. 已死行的数量。因为我们不处理复制CU中的死行
     */
    int cuDescIdx = m_CUDescIdx[m_cursor];
    Form_pg_attribute* attrs = m_relation->rd_att->attrs;
    for (int i = 0; i < m_colNum; ++i) {
        /* colIdx是物理列ID */
        int colIdx = m_colId[i];
        if (attrs[colIdx]->attisdropped) {
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OPERATION),
                     (errmsg("不能加载表 \"%s\" 的已删除列 \"%s\" 的CUDesc和CU",
                             RelationGetRelationName(m_relation),
                             NameStr(attrs[colIdx]->attname))));
        }

        CUDesc* cuDescPtr = &(m_CUDescInfo[i]->cuDescArray[cuDescIdx]);
        CU* cuDataPtr =
            New(CurrentMemoryContext) CU(attrs[colIdx]->attlen, attrs[colIdx]->atttypmod, attrs[colIdx]->atttypid);

        /* 在LoadCU中使用CStoreMemAlloc::Palloc，需要在完成后调用CStoreMemAlloc::Pfree */
        if (cuDescPtr->cu_size > 0) {
            m_cuStorage[colIdx]->LoadCU(cuDataPtr,
                                        cuDescPtr->cu_pointer,
                                        cuDescPtr->cu_size,
                                        g_instance.attr.attr_storage.enable_adio_function,
                                        false);

            if (cuDataPtr->IsVerified(cuDescPtr->magic) == false) {
                addBadBlockStat(
                    &m_cuStorage[colIdx]->m_cnode.m_rnode, ColumnId2ColForkNum(m_cuStorage[colIdx]->m_cnode.m_attid));

                if (RelationNeedsWAL(m_relation) && CanRemoteRead()) {
                    ereport(WARNING,
                            (errcode(ERRCODE_DATA_CORRUPTED),
                             (errmsg("表 \"%s\" 的CU文件 %s 偏移 %lu 中的CU %u 无效，尝试进行远程读取",
                                     RelationGetRelationName(m_relation),
                                     relcolpath(m_cuStorage[colIdx]),
                                     cuDescPtr->cu_pointer,
                                     cuDescPtr->cu_id)),
                             handle_in_client(true)));

                    m_cuStorage[colIdx]->RemoteLoadCU(cuDataPtr,
                                                      cuDescPtr->cu_pointer,
                                                      cuDescPtr->cu_size,
                                                      g_instance.attr.attr_storage.enable_adio_function,
                                                      false);

                    if (cuDataPtr->IsVerified(cuDescPtr->magic)) {
                        m_cuStorage[colIdx]->OverwriteCU(
                            cuDataPtr->m_compressedBuf, cuDescPtr->cu_pointer, cuDescPtr->cu_size, false);
                    } else {
                        ereport(ERROR,
                                (errcode(ERRCODE_DATA_CORRUPTED),
                                 (errmsg("远程读取CU失败，网络数据损坏")));
                    }
                } else {
                    int elevel = ERROR;
                    if (isVerify) {
                        elevel = WARNING;
                    }
                    ereport(elevel,
                            (errcode(ERRCODE_DATA_CORRUPTED),
                             (errmsg("CU验证失败。节点是 %s，表 %s 中CU %u 的CU文件 %s 偏移 %lu 无效",
                                     g_instance.attr.attr_common.PGXCNodeName,
                                     RelationGetRelationName(m_relation),
                                     cuDescPtr->cu_id,
                                     relcolpath(m_cuStorage[colIdx]),
                                     cuDescPtr->cu_pointer)),
                             handle_in_client(true)));
                }
            }
        }

        *batchCUData->CUDescData[colIdx] = *cuDescPtr;
        batchCUData->CUptrData[colIdx] = cuDataPtr;
        GetCUDeleteMaskIfNeed(cuDescPtr->cu_id, m_snapshot);
    }

    batchCUData->hasValue = true;

    batchCUData->CopyDelMask(m_hasDeadRow ? m_cuDelMask : NULL);

    // 步骤5: 刷新游标
    // 由于我们整体移动CU，因此只需要移动游标
    IncLoadCuDescIdx(m_cursor);

    // 在此函数中，我们不应该进入CU中的行
    Assert(m_rowCursorInCU == 0);

    // 步骤6: 如果需要，进行预取
    ADIO_RUN()
    {
        CUListPrefetch();
    }
    ADIO_END();
}

CStore::LoadCUDescIfNeed 函数

  这段代码是 CStore 数据库存储引擎的一个函数，主要用于在扫描过程中加载CUDesc（列存储的控制信息）信息。该函数的具体功能包括：

  1. 首先，检查是否需要加载 CUDesc。加载 CUDesc 信息时，会根据列数来决定一次性加载还是分批加载，以免内存不足。
  2. 如果需要加载 CUDesc，会先重置内存上下文，以便分批加载。
  3. 接着，循环加载 CUDesc 信息，每次加载一个CUDesc，并将其记录在内存中。
  4. 如果 ADIO（Asynchronous Direct I/O）功能启用，会检查是否需要预取更多的 CUDesc 信息，并根据需求进行加载。
  5. 最后，根据加载的 CUDesc 信息，决定是否需要进行粗略检查（Rough Check）。

  需要注意的是，CUDesc 信息用于控制列存储中的列数据的读取，因此加载 CUDesc 信息是扫描过程中的一个重要步骤，有助于提高列存储扫描的效率和性能。
  此外，代码中包括了一些条件编译的宏（ADIO_RUN、ADIO_ELSE、ADIO_END、BFIO_RUN、BFIO_END），这些宏用于根据不同的编译选项来控制ADIO 和 BFIO（Buffered I/O）功能的相关逻辑，以优化 I/O 操作。
  函数源码如下所示：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

// The number of holding CUDesc is max_loaded_cudesc
// if we load all CUDesc once, the memory will not enough.
// So we load CUdesc once for max_loaded_cudesc
void CStore::LoadCUDescIfNeed()
{
    uint32 last_load_num = 0; // 上一次加载的CUDesc数量
    int32 cudesc_idx = 0;  // cudesc_idx在缓冲IO时设置为0，在ADIO时设置为m_NumCUDescIdx

    if (!NeedLoadCUDesc(cudesc_idx)) { // 如果不需要加载CUDesc信息，直接返回
        return;
    }

    m_NumLoadCUDesc = 0; // 已加载的CUDesc数量，初始化为0

    Assert(m_perScanMemCnxt); // 断言确保内存上下文m_perScanMemCnxt存在
    // 当一批CU已经扫描和处理完时，重置内存上下文
    MemoryContextReset(m_perScanMemCnxt);
#ifdef MEMORY_CONTEXT_CHECKING
    MemoryContextCheck(m_perScanMemCnxt->parent, m_perScanCnxt->parent->session_id > 0);
#endif

    // 加载CUDesc信息到m_cuDescInfo中，用于所有访问的列
    if (m_colNum > 0) {
        last_load_num = m_CUDescInfo[0]->curLoadNum; // 记录第一列的已加载CUDesc数量
    }

    do {
        bool found = false; // 标志是否找到CUDesc
        for (int i = 0; i < m_colNum; ++i) { // 遍历所有访问的列
            Assert(m_colId[i] >= 0); // 断言确保列ID大于等于0
            // 如果启用ADIO，加载一个CU用于计算预取数量
            found = LoadCUDesc(m_colId[i], m_CUDescInfo[i], g_instance.attr.attr_storage.enable_adio_function, m_snapshot);
        }

        if (likely(m_colNum > 1 && m_CUDescInfo[0]->curLoadNum > 0)) {
            CheckConsistenceOfCUDescCtl(); // 检查CUDescCtl的一致性
            /* 检查所有列的第一个CUDesc */
            CheckConsistenceOfCUDesc(0);
            /* 检查所有列的最后一个CUDesc */
            if (m_CUDescInfo[0]->curLoadNum > 1) {
                CheckConsistenceOfCUDesc(m_CUDescInfo[0]->curLoadNum - 1);
            }
        }

        if (m_colNum > 0) {
            for (int j = (int)m_CUDescInfo[0]->lastLoadNum; j != (int)m_CUDescInfo[0]->curLoadNum;
                 IncLoadCuDescIdx(j)) {
                m_CUDescIdx[cudesc_idx] = j; // 记录已加载CUDesc的索引
                IncLoadCuDescIdx(cudesc_idx);
            }
            m_NumLoadCUDesc += LoadCudescMinus(m_CUDescInfo[0]->lastLoadNum, m_CUDescInfo[0]->curLoadNum);
        }

        ADIO_RUN()
        {
            // 如果找到CUDesc，需要检查预取数量并决定是否需要加载更多CUDesc
            if (found && m_prefetch_quantity < m_prefetch_threshold &&
                HasEnoughCuDescSlot(last_load_num, m_CUDescInfo[0]->curLoadNum)) {
                continue;
            }
            // 加载完成，设置lastLoadNum为备份值
            for (int i = 0; i < m_colNum; ++i) {
                m_CUDescInfo[i]->lastLoadNum = last_load_num;
            }
            if (m_colNum > 0) {
                // 这里设置一个最小的预取计数，因为我们需要预取窗口来控制是否需要预取
                t_thrd.cstore_cxt.cstore_prefetch_count = Max(m_NumLoadCUDesc, CSTORE_MIN_PREFETCH_COUNT);
                ereport(DEBUG1,
                        (errmodule(MOD_ADIO),
                         errmsg("LoadCUDesc: columns(%d), count(%d), quantity(%d)",
                                m_colNum,
                                m_NumLoadCUDesc,
                                m_prefetch_quantity)));
            }
            break;
        }
        ADIO_ELSE()
        {
            break;
        }
        ADIO_END();
    } while (1);

    // sys列和const列
    if (m_colNum > 0 && m_sysColNum != 0) {
        // 访问普通列和sys列，使用普通列的CUDesc
        m_virtualCUDescInfo = m_CUDescInfo[0];
    } else if (OnlySysOrConstCol()) {
        // 只有系统列或常数列，使用第一列的CUDesc
        Assert(m_virtualCUDescInfo);
        LoadCUDesc(m_firstColIdx, m_virtualCUDescInfo, false, m_snapshot);

        for (int j = (int)m_virtualCUDescInfo->lastLoadNum; j != (int)m_virtualCUDescInfo->curLoadNum;
             IncLoadCuDescIdx(j)) {
            m_CUDescIdx[cudesc_idx] = j;
            IncLoadCuDescIdx(cudesc_idx);
        }
        m_NumLoadCUDesc = LoadCudescMinus(m_virtualCUDescInfo->lastLoadNum, m_virtualCUDescInfo->curLoadNum);
        // ADIO使用了它，但无需添加ADIO_RUN()，因为对于缓冲IO，它是无用的
        t_thrd.cstore_cxt.cstore_prefetch_count = m_NumLoadCUDesc;
    }

    // 加载新的CU需要进行粗略检查
    m_needRCheck = true;

    // 在进行粗略检查之前，m_NumCUDescIdx表示已加载的CUDesc信息的长度
    BFIO_RUN()
    {
        m_NumCUDescIdx = m_NumLoadCUDesc;
    }
    BFIO_END();
    return;
}

CStore::LoadCUDesc 函数

  CStore::LoadCUDesc 函数用于从 CStore 列存储中加载指定列的 CUDesc（列式数据块描述）信息，根据给定的加载信息控制结构 LoadCUDescCtl 和快照信息。它允许进行精细的 ADIO（自适应数据管理器）操作，以加载适当数量的 CUDesc 并进行预取控制。这个函数会扫描 CUDesc 表，按 CUID（列式数据块 ID）和属性 ID 筛选相关信息，将这些信息加载到内存中的 CUDesc 结构中，以供后续查询和操作。函数源码如下所示：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/*
 * 根据loadInfoPtr加载列的CUDesc信息
 * LoadCUDescCtrl包含此加载的maxCUDescNum，因为如果加载所有信息，将需要大量内存
 * 这个函数专为ADIO设计，第三个参数adio_work用于控制类似enable_adio_function的ADIO操作，
 * 因为GetLivedRowNumbers不应在ADIO模式下工作
 */
bool CStore::LoadCUDesc(
    _in_ int col, __inout LoadCUDescCtl* loadCUDescInfoPtr, _in_ bool prefetch_control, _in_ Snapshot snapShot)
{
    ScanKeyData key[3];
    HeapTuple tup;
    errno_t rc = EOK;
    bool found = false;
    int loadNum = 0;

    Assert(col >= 0);
    Assert(loadCUDescInfoPtr);
    if (col >= m_relation->rd_att->natts) {
        ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR),
            errmsg("列索引超过列数，列：%d，列数：%d", col, m_relation->rd_att->natts)));
    }
    /*
     * 切换到下一批cudesc数据时，我们将重置m_perScanMemCnxt。
     * 因此，仅用于此批次的空间应由m_perScanMemCnxt进行管理。
     */
    AutoContextSwitch newMemCnxt(m_perScanMemCnxt);

    ADIO_RUN()
    {
        loadCUDescInfoPtr->lastLoadNum = loadCUDescInfoPtr->curLoadNum;
    }
    ADIO_ELSE()
    {
        loadCUDescInfoPtr->lastLoadNum = 0;
        loadCUDescInfoPtr->curLoadNum = 0;
    }
    ADIO_END();

    CUDesc* cuDescArray = loadCUDescInfoPtr->cuDescArray;
    /*
     * 打开CUDesc关系及其索引
     */
    Relation cudesc_rel = heap_open(m_relation->rd_rel->relcudescrelid, AccessShareLock);
    TupleDesc cudesc_tupdesc = cudesc_rel->rd_att;
    Relation idx_rel = index_open(cudesc_rel->rd_rel->relcudescidx, AccessShareLock);
    bool needLengthInfo = m_relation->rd_att->attrs[col]->attlen < 0;
    /* 转换逻辑ID为属性的物理ID */
    int attid = m_relation->rd_att->attrs[col]->attnum;

    /*
     * 设置扫描键，以通过属性ID和CU ID范围从索引中获取数据。
     */
    ScanKeyInit(&key[0], (AttrNumber)CUDescColIDAttr, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(attid));

    ScanKeyInit(&key[1],
                (AttrNumber)CUDescCUIDAttr,
                BTGreaterEqualStrategyNumber,
                F_OIDGE,
                UInt32GetDatum(loadCUDescInfoPtr->nextCUID));

    ScanKeyInit(&key[2], (AttrNumber)CUDescCUIDAttr, BTLessEqualStrategyNumber, F_OIDLE, UInt32GetDatum(m_endCUID));

    snapShot = (snapShot == NULL) ? GetActiveSnapshot() : snapShot;

    Assert(snapShot != NULL);

    SysScanDesc cudesc_scan = systable_beginscan_ordered(cudesc_rel, idx_rel, snapShot, 3, key);
    /* 按照CUID升序顺序扫描cudesc元组 */
    while ((tup = systable_getnext_ordered(cudesc_scan, ForwardScanDirection)) != NULL) {
        Datum values[CUDescCUExtraAttr] = {0};
        bool isnull[CUDescCUExtraAttr] = {0};
        char* valPtr = NULL;

        /* 在这里使用heap_deform_tuple()，因为cudesc tupe的存储方式不合适。
         * min和max是可变长度的，但存储在元组的中间。如果在这里使用fastgetattr()
         * 可能会导致高额的CPU开销。
         * 顺便说一下，最好的存储方式是以以下形式存储元组：
         *   属性1：固定长度
         *   属性2：固定长度
         *   ......        ：固定长度
         *   属性n：可变长度
         *   属性n+1：可变长度
         *    ......        ：可变长度
         */
        heap_deform_tuple(tup, cudesc_tupdesc, values, isnull);

        uint32 cu_id = DatumGetUInt32(values[CUDescCUIDAttr - 1]);
        Assert(!isnull[CUDescCUIDAttr - 1]);

        if (IsDicVCU(cu_id))
            continue;

        /* 将cusize放入cudesc->cu_size中 */
        int32 cu_size = DatumGetInt32(values[CUDescSizeAttr - 1]);
        Assert(!isnull[CUDescSizeAttr - 1]);

        ADIO_RUN()
        {
            loadNum = (int)loadCUDescInfoPtr->curLoadNum;
            IncLoadCuDescIdx(loadNum);
            /* case1: 检查是否可以加载更多; case 2: m_virtualCUDescInfo在此检查是否数组溢出 */
            if (m_CUDescIdx[m_cursor] == loadNum || !HasEnoughCuDescSlot(loadCUDescInfoPtr->lastLoadNum, loadNum)) {
                break;
            }
            m_prefetch_quantity += cu_size;
        }
        ADIO_ELSE()
        {
            if (!loadCUDescInfoPtr->HasFreeSlot())
                break;
        }
        ADIO_END();

        cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_size = cu_size;
        cuDescArray[loadCUDescInfoPtr->curLoadNum].xmin = HeapTupleGetRawXmin(tup);
        cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_id = cu_id;
        loadCUDescInfoPtr->nextCUID = cu_id;

        /* 并行扫描CU划分。 */
        if (u_sess->stream_cxt.producer_dop > 1 &&
            (cu_id % u_sess->stream_cxt.producer_dop != (uint32)u_sess->stream_cxt.smp_id))
            continue;

        /* 将min值放入cudesc->min中 */
        if (!isnull[CUDescMinAttr - 1]) {
            char* minPtr = cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_min;
            int len_1 = MIN_MAX_LEN;
            valPtr = DatumGetPointer(values[CUDescMinAttr - 1]);
            if (needLengthInfo) {
                *minPtr = VARSIZE_ANY_EXHDR(valPtr);
                minPtr = minPtr + 1;
                len_1 -= 1;
            }
            rc = memcpy_s(minPtr, len_1, VARDATA_ANY(valPtr), VARSIZE_ANY_EXHDR(valPtr));
            securec_check(rc, "", "");
        }
        /* 将max值放入cudesc->max中 */
        if (!isnull[CUDescMaxAttr - 1]) {
            char* maxPtr = cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_max;
            int len_2 = MIN_MAX_LEN;
            valPtr = DatumGetPointer(values[CUDescMaxAttr - 1]);
            if needLengthInfo {
                *maxPtr = VARSIZE_ANY_EXHDR(valPtr);
                maxPtr = maxPtr + 1;
                len_2 -= 1;
            }
            rc = memcpy_s(maxPtr, len_2, VARDATA_ANY(valPtr), VARSIZE_ANY_EXHDR(valPtr));
            securec_check(rc, "", "");
        }

        cuDescArray[loadCUDescInfoPtr->curLoadNum].row_count = DatumGetInt32(values[CUDescRowCountAttr - 1]);
        Assert(!isnull[CUDescRowCountAttr - 1]);

        /* 将CUMode放入cudesc->cumode中 */
        cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_mode = DatumGetInt32(values[CUDescCUModeAttr - 1]);
        Assert(!isnull[CUDescCUModeAttr - 1]);

        /* 将CUPointer放入cudesc->cuPointer中 */
        Assert(col != VitrualDelColID);
        Assert(!isnull[CUDescCUPointerAttr - 1]);
        valPtr = DatumGetPointer(values[CUDescCUPointerAttr - 1]);
        rc = memcpy_s(&cuDescArray[loadCUDescInfoPtr->curLoadNum].cu_pointer,
                      sizeof(CUPointer),
                      VARDATA_ANY(valPtr),
                      sizeof(CUPointer));
        securec_check(rc, "", "");
        Assert(VARSIZE_ANY_EXHDR(valPtr) == sizeof(CUPointer));

        /* 将magic值放入cudesc->magic中 */
        cuDescArray[loadCUDescInfoPtr->curLoadNum].magic = DatumGetUInt32(values[CUDescCUMagicAttr - 1]);
        Assert(!isnull[CUDescCUMagicAttr - 1]);

        found = true;

        IncLoadCuDescIdx(*(int*)&loadCUDescInfoPtr->curLoadNum);
        /* 为ADIO仅加载一个CU，因为我们需要计算预取数量的CU大小 */
        if (prefetch_control) {
            break;
        }
    }

    systable_endscan_ordered(cudesc_scan);
    index_close(idx_rel, AccessShareLock);
    heap_close(cudesc_rel, AccessShareLock);

    ADIO_RUN()
    {
        if (tup == NULL) {
            /* 没有找到tup表示预取已完成 */
            m_load_finish = true;
        }
    }
    ADIO_END();

    if (found) {
        /* nextCUID必须大于已加载的cudesc */
        loadCUDescInfoPtr->nextCUID++;
        return true;
    }
    return false;
}

  以下简述函数 CStore::LoadCUDesc 函数的执行过程：

  1. 首先，函数检查传入的参数，包括列索引（col）和加载 CUDesc 信息的控制结构（LoadCUDescCtl），确保它们有效。
  2. 针对列的逻辑 ID，确定相应的物理 ID，以访问 CUDesc 表中的相关信息。
  3. 设置合适的扫描键（ScanKey），以通过索引访问 CUDesc 表中的行。这些扫描键通常包括列 ID、CUID 范围和其他条件。
  4. 打开 CUDesc 表以及相关的索引，准备进行有序扫描。
  5. 通过扫描 CUDesc 表，按 CUID 范围和列 ID 筛选出相关的 CUDesc 信息。函数将 CUDesc 信息加载到内存中的 CUDesc 结构中，包括 CUID、CUBlock 地址、大小、行数、最小值、最大值和其他属性。
  6. 如果执行了 ADIO 操作（根据参数 prefetch_control），则该函数在加载单个 CUDesc 后就返回，用于计算预取数量。否则，它会继续加载 CUDesc 信息，直到满足预取条件。
  7. 函数会根据加载的 CUDesc 信息，更新相应的控制结构和状态信息，以确保后续的 CStore 扫描操作能够使用这些加载的 CUDesc 信息。
  8. 执行完加载操作后，函数返回布尔值，指示是否成功加载了 CUDesc 信息。
J.Kuchiki
关注
专栏目录
【 OpenGauss源码学习 —— 列存储（CStore）（六）】
qq_43899283的博客
11-13 273
本章我们继续在【 OpenGauss源码学习 —— 列存储（CStore）（五）】的基础上进行进一步学习，本文将主要介绍CStore类中剩余的各别私有成员函数。
【 OpenGauss源码学习 —— 列存储（CStore）（四）】
qq_43899283的博客
11-10 569
本章我们继续在【 OpenGauss源码学习 —— 列存储（CStore）（三）】基础上进行进一步学习，本文将继续介绍CStore类中与填充列存储引擎中的数据结构或有关的部分公有成员函数。本文所讲的这一系列的函数主要用于==填充Columnar存储引擎中的数据结构或。==这些函数涵盖了不同的场景和功能，包括普通列数据的填充系统列数据的填充延迟读取列的填充等。用于填充一个，主要用于查询扫描时读取多列数据。用于填充，主要用于普通列的数据填充，支持不同数据类型和压缩方式。根据提供的TID列信息填充。
安全函数解读及使用注意事项
2401_83143557的博客
03-21 835
危险函数信赖于程序员对参数进行检查、或保证空间能足够容纳所产生的结果，函数本身不对这些情况进行判断，即使有问题也不会给出错误的指示。相比危险函数，安全函数进行了相应的安全增强，会对入参以及不同的错误情况进行判断，降低操作不当所引入的安全风险。强化边界检查：在接口参数中增加一个 buffer 长度的参数，在长度参数正确情况下不会出现溢出保证结果字符串以’\0’结尾，避免访问 buffer 边界之外的信息发现缓冲区溢出发生，将目的缓冲区的首字节置零增加错误返回值，便于程序员快速进行错误定位。
SSH服务详解
惨绿少年 | 欢迎访问CLSN博客站点 http://clsn.io
10-22 1436
&#13; 第1章 SSH服务&#13; 1.1 SSH服务协议说明&#13; SSH 是 Secure Shell Protocol 的简写，由 IETF 网络工作小组（Network Working Group )制定；在进行数据传输之前，SSH先对联机数据包通过加密技术进行加密处理，加密后在进行数据传输。确保了传递的数据安全。&#13; SSH是专为远程登录会话和其他网...
openGauss数据库源码解析系列文章——存储引擎源码解析（一）_opengauss存储引擎源码分析
2401_84185471的博客
05-06 312
【代码】openGauss数据库源码解析系列文章——存储引擎源码解析（一）_opengauss存储引擎源码分析。
openGauss数据库源码解析系列文章——存储引擎源码解析（一）_opengauss存储引擎源码分析(1)
2401_84182758的博客
04-30 788
另一方面，在openGauss行存储格式中，对同一行数据的写-写查询冲突通过两阶段锁协议来实现并发控制（参见第5章中关于行级锁的介绍），对同一行数据的读-写查询冲突通过行级多版本技术来实现互不阻塞的、高效的并发控制。磁盘引擎是数据库系统中最常用的存储引擎，openGauss提供不同存储格式的磁盘引擎来支持大容量（数据量大于内存空间）场景下的OLTP、OLAP和HTAP（hybrid transactions and analytics processing，混合交易和分析处理）业务。
openGauss数据库源码解析系列文章—— 执行器解析（二）_param_extern param_exec param_sublink
2401_84264244的博客
04-28 566
（2） 计算表达式结果。（3） 判断结果中itemIsDone[resind]参数并生成最后的元组。ExecTargetList函数的执行流程如图7-19所示。图7-19 ExecTargetList函数执行流程ExecProject函数的作用是进行投影操作，投影操作是一种属性过滤过程，该操作将对元组的属性进行精简，把在上层计划节点中不需要用的属性从元组中去掉，从而构造一个精简版的元组。投影操作中被保留下来的那些属性被称为投影属性。ExecProject函数的主要执行流程如下。
openGauss数据库源码解析系列文章——执行器解析（二）
2301_76434200的博客
03-30 43
表达式计算表达式计算对应的代码源文件是“execQual.cpp”，openGauss处理SQL语句中的函数调用、计算式和条件表达式时需要用到表达式计算。表达式的表示方式和查询计划树的计划节点类似，通过生成表达式计划来对每个表达式节点进行计算。表达式继承层次中的公共根类为Expr节点，其他表达式节点都继承Expr节点。表达式状态的公共根类为ExprState，记录了表达式的类型以及实现该表达式节点...
【云原生进阶之数据库技术】第四章-GaussDB-关键技术-2.4.2.1-openGauss存储引擎层关键技术方案
junbaozi的专栏
10-30 22
从整个数据库服务的组成构架来看，存储引擎向上对接SQL引擎，为SQL引擎提供或接收标准化的数据格式（元组或向量数组）；向下对接存储介质，按照特定的数据组织方式，以页面、列存储单元（CU，compression unit）或其他形式为单位，通过存储介质提供的特定接口，对存储介质中的数据完成读、写操作。在此基础之上，存储引擎通过日志系统提供数据的持久化和可靠性能力；通过并发控制（事务）系统保证同时执行的、多个读写操作之间的原子性、一致性和隔离性；通过索引系统提供对特定数据的加速寻址和查询能力；
【云原生进阶之数据库技术】第四章-GaussDB-关键技术-2.4.1-GaussDB存储引擎层关键技术方案
junbaozi的专栏
10-30 31
GaussDB整个系统设计是可插拔、自组装的，支持多个存储引擎以满足不同场景的业务诉求。当前Gauss存储行存储列存储内存引擎，主要面向极致性能场景设计，例如银行风控场景。创建表的时候可以指定为行存储引擎表、列存储引擎表、内存引擎表，支持一个事务中包含对三种引擎表的 DML操作，可以保证事务的 ACID性质。从整个数据库服务的组成构架来看，存储引擎向上对接SQL引擎，为SQL引擎提供或接收标准化的数据格式（元组或向量数组）；
【云原生进阶之数据库技术】第四章-GaussDB-关键技术-2.4.2.5-Ustore最佳实践方案
junbaozi的专栏
11-04 154
存储引擎会对数据库整体效率和性能具有巨大影响，请根据实际需求选择适当的存储引擎。用户可使用WITH ( [ORIENTATION | STORAGE_TYPE] [= value] [, ... ] )为表或索引指定一个可选的存储参数。
Docker安装部署单机版高斯数据库gaussdb
最新发布
宋发元
11-07 157
如果出现镜像无法拉取的情况，请先在本地，开启VPN访问外网，拉取镜像，再离线拷贝到目标服务器上。进入opengauss容器中配置opengauss。2：修改postgresql.conf配置信息。1：修改pg_hba.conf配置信息。4：重新启动opengauss。5：navicat连接成功。3：重新加载配置信息。
GaussDB的向量化处理技术
Gauss松鼠会
11-04 666
作为GaussDB最新版本的一部分，使用SIMD向量化的优化被添加到过滤器 (filter) 和表达式 (expression) 计算中。相比之前的实现显示出良好的性能提升。下面是与基线版本的性能对比，测试使用TPC-H SF=100数据库进行，下图显示Q1、Q6、Q9和Q15有显著改进；最高达到3倍的提升。
GaussDB Ustore存储引擎解读
hai40587的博客
11-03 901
GaussDB Ustore存储引擎是华为云推出的一款高性能数据库存储引擎，旨在解决传统行存储引擎在特定场景下的性能瓶颈。通过原地更新策略、UNDO子系统设计、多版本索引技术等特性，Ustore存储引擎为需要频繁更新和随机访问的场景提供了高效、稳定、可靠的数据库服务。未来，随着技术的不断发展，GaussDB将继续结合AI自治技术等先进技术，对Ustore存储引擎进行更智能、更安全、更高效的技术优化。同时，GaussDB也将不断推出新的特性和功能，以满足不同应用场景的需求，为企业数字化转型注入新的动力。
go 集成go-redis 缓存操作
hlsd的博客
11-07 823
go redis 学习。
Redis实战-利用Lua解决批量插入防重方案
葵续浅笑的博客
11-01 1318
本文介绍了以Lua脚本为基础设计的防重和幂等方案。
windows11安装redis
qq_42985657的博客
11-06 296
下载免安装版本，鼠标点击一下自动下载。解压。
情怀系列国际版棋牌完整源码具备强大的多语言扩展功能，涵盖了900多款子游戏，专为全球市场的游戏开发和运营设计。
z926098的博客
11-05 347
客户端使用Cocos Creator进行跨平台开发，可以发布为App、H5网页和PC网页。这种跨平台的能力使运营商只需维护一套代码，就能同时管理多个终端。除此之外，系统还支持产品的热更新功能，大幅提升运营效率并降低成本，实现了产品层面的“降维打击”。情怀棋牌源代码的服务器端使用JAVA和Node.js开发，采用RocketMQ作为消息队列中间件，有效防止服务器堵塞、消峰。该源码包涵盖了完整的服务器端代码、服务端900款子游戏源码、客户端代码、客户端700款子游戏、管理后台代码、数据库以及热更新生成脚本等。
【达梦数据库】Oracle数据库通过DTS工具迁移数据到达梦数据库--索引数量存在出入
weixin_47686079的博客
11-06 47
【代码】【达梦数据库】Oracle数据库通过DTS迁移到达梦数据库索引数量不一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值