列存储（analyze）

AcquireSampleCStoreRows 函数
- es_get_attnums_to_analyze 函数
- CStoreRelGetCUNumByNow 函数
- CStore::GetLivedRowNumbers 函数
- InitGetValFunc 函数
- CStoreGetfstColIdx 函数
- CStore::GetCUDesc 函数
- CStore::IsTheWholeCuDeleted 函数
- CStore::IsTheWholeCuDeleted 函数
- CStore::CudescTupGetMinMaxDatum 函数

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

AcquireSampleCStoreRows 函数

在前一章中（列存储（analyze）(三)），我们对函数 acquire_sample_rows 进行了学习，其中acquire_sample_rows 函数的作用是在 PostgreSQL 数据库中执行抽样操作，用于获取数据表的随机样本行。这个函数的主要目的是估计数据表的统计信息和数据分布，以帮助查询优化器生成更有效的执行计划。
本章，我们紧接着来看另一种数据库抽样操作 AcquireSampleCStoreRows ，该函数也是我们所需关注的重点，是本【OpenGauss源码学习 —— 列存储（analyze）】系列的重点和最终学习目标。AcquireSampleCStoreRows 是用于列式存储引擎（如列存储数据库表）的函数。它是为了从列存储表中获取样本数据而设计的，通常用于分析和统计查询中，以获取表的随机样本，以便估计表的统计信息和数据分布。
其中，函数 AcquireSampleCStoreRows 的调用关系与 acquire_sample_rows 相同，如下所示：do_analyze_rel -> get_target_rows -> AcquireSampleCStoreRows。

函数的入参含义如下：

Relation onerel: 被分析的关系（表）的 Relation 结构，表示要进行样本抽样的目标表。调试信息如下：

int elevel: 日志消息的错误级别。用于确定错误消息的日志级别。
HeapTuple* rows: 一个用于存储样本数据的数组。函数将抽样的行数据存储在这个数组中。
int64 targrows: 目标抽样行数，即希望从表中抽取的行数。
double* totalrows: 用于存储表的估计总行数的指针。函数将估计的总行数存储在这个指针指向的变量中。
double* totaldeadrows: 用于存储表的估计死行数的指针。函数将估计的死行数存储在这个指针指向的变量中。
VacAttrStats** vacattrstats: 一个 VacAttrStats 结构的数组，表示用于分析的每个属性的统计信息。这些统计信息包括样本数据的属性分布等。

int analyzeAttrNum: 要分析的属性的数量。表示要分析的属性数量。

AcquireSampleCStoreRows 函数的作用和目的是执行列存储表格的抽样操作，以获取列存储表格的随机样本行。AcquireSampleCStoreRows 函数源码如下：（路径：src/gausskernel/optimizer/commands/analyze.cpp）

*
 * AcquireSampleCStoreRows -- acquire a random sample of rows from the table
 *
 * Selected rows are returned in the caller-allocated array rows[], which
 * must have at least targrows entries.
 * The actual number of rows selected is returned as the function result.
 * We also estimate the total number of live and dead rows in the table,
 * and return them into *totalrows and *totaldeadrows, respectively.
 *
 * To improve the analyze efficiency in the condition of severl attrs are selected,
 * we add two parameters which record the information of seleced attrs.The perform
 * can only used for column storage table.
 *
 * The returned list of tuples is in order by physical position in the table.
 * (We will rely on this later to derive correlation estimates.)
 */
template <bool estimate_table_rownum>
static int64 AcquireSampleCStoreRows(Relation onerel, int elevel, HeapTuple* rows, int64 targrows, double* totalrows,
    double* totaldeadrows, VacAttrStats** vacattrstats, int analyzeAttrNum)
{
    int64 numrows = 0;             /* 当前在样本中的行数 */
    int64 delta_numrows = 0;       /* 当前在样本中的差异表行数 */
    int32 samplerows = 0;          /* 收集的总行数 */
    int64 liverows = 0;            /* 观察到的存活行数 */
    int64 deadrows = 0;            /* 观察到的已删除行数 */
    BlockNumber totalblocks = 0;   /* 总块数 */
    BlockNumber estBlkNum = 0;     /* 估算的块数 */
    BlockSamplerData bs;           /* 块采样数据结构 */
    double rstate;                 /* 随机状态 */
    AnlPrefetch anlprefetch;       /* 预取设置 */
    int cusize_threshold = maxAnalyzeUseCstoreBufferSize; /* CU大小阈值 */
    anlprefetch.blocklist = NULL;  /* 预取块列表初始化为空 */

    AssertEreport(targrows > 0, MOD_OPT, "采样时目标行数必须大于0");
    
    /*
     * 所有系统表都是行存储表，列存储表必须是用户定义的表，
     * 因此我们只返回而不采样。
     */
    if (IS_PGXC_COORDINATOR) {
        *totalrows = 0;
        *totaldeadrows = 0;
        return 0;
    }
    
    /* 为扩展的统计信息准备 */
    Bitmapset* bms_attnums = es_get_attnums_to_analyze(vacattrstats, analyzeAttrNum);
    int num_attnums = bms_num_members(bms_attnums);   /* 统计属性的数量 */
    int colTotalNum = onerel->rd_att->natts;          /* 表中总的列数 */
    int32* attrSeq = NULL;                           /* 属性顺序 */
    int16* colIdx = (int16*)palloc0(sizeof(int16) * num_attnums); /* 列索引数组 */
    int* slotIdList = NULL;                          /* CU槽位索引数组 */
    CStoreScanDesc cstoreScanDesc = NULL;            /* 列存储扫描描述符 */
    CU** cuPtr = NULL;                               /* CU指针数组 */
    Relation deltarel = NULL;                        /* 差异表 */
    double totalRowCnts = 0;                         /* 总行数 */
    double deltarows = 0;                            /* 差异表的行数 */
    double curows = 0;                               /* CU中的行数 */
    double cudeadrows = 0;                           /* CU中的已删除行数 */

    /* 首先考虑差异关系（delta relation） */
    Assert(OidIsValid(onerel->rd_rel->reldeltarelid));
    
    /* 打开差异表。我们只需要对其进行 AccessShareLock。 */
    deltarel = relation_open((onerel->rd_rel->reldeltarelid), AccessShareLock);
    
    /* 从差异关系中仅获取总行数的估计 */
    delta_numrows = acquire_sample_rows<true>(deltarel, elevel, rows, targrows, &deltarows, totaldeadrows);

    /* 在这里将 nulls 设置为 true，并且那些不需要分析的属性将始终为 null */
    for (int i = 0; i < num_attnums; ++i) {
        colIdx[i] = bms_first_member(bms_attnums);
    }

    /* 为当前分析初始化本地快照（local snapshot）。 */
    Snapshot tmpSnapshot = GetActiveSnapshot();
    Assert(tmpSnapshot != NULL);

    cstoreScanDesc = CStoreBeginScan(onerel, num_attnums, colIdx, tmpSnapshot, false);
    // 开始对列存储表进行扫描，准备抽样
    // onerel: 当前关系
    // num_attnums: 要分析的属性数量
    // colIdx: 要分析的属性列的索引
    // tmpSnapshot: 当前快照
    // false: 是否是 Delta 表的扫描

    totalblocks = CStoreRelGetCUNumByNow(cstoreScanDesc);
    // 获取当前 CU 的数量，用于统计

    curows = (double)cstoreScanDesc->m_CStore->GetLivedRowNumbers(&deadrows);
    // 从 CU 中获取存活行数，并更新 deadrows
    // curows: CU 中存活的行数
    // deadrows: 已删除的行数

    if (curows <= 0.0) {
        // 如果存活行数小于等于0，则没有需要分析的数据
        relation_close(deltarel, AccessShareLock); // 关闭 Delta 表
        CStoreEndScan(cstoreScanDesc); // 结束对列存储表的扫描
        pfree_ext(colIdx); // 释放 colIdx 的内存
        pfree_ext(bms_attnums); // 释放 bms_attnums 的内存
        return 0; // 返回0，表示没有进行抽样
    }

    *totalrows = totalRowCnts = curows + deltarows;
    // 设置总行数为存活行数加上 Delta 表的行数
    // totalrows: 总行数
    // totalRowCnts: 存活行数加上 Delta 表的行数

    cudeadrows = (double)deadrows;
    *totaldeadrows += cudeadrows;
    // 更新总的已删除行数
    deadrows = 0; // 在非 pretty 模式下重用 deadrows 来存储已删除元组的数量

    /* for pretty mode we just return actual lived rows */
    if (estimate_table_rownum && SUPPORT_PRETTY_ANALYZE) {
        // 如果是 "pretty" 模式并且需要估算表的行数
        // "pretty" 模式通常用于漂亮的输出，返回实际存活的行数，而不进行估算

        /* only get estimate rows, free delta rows and close relation */
        // 只获取估算的行数，释放 Delta 表的行并关闭关系
        for (int i = 0; i < delta_numrows; i++) {
            if (rows[i]) {
                pfree_ext(rows[i]); // 释放行的内存
                rows[i] = NULL;
            }
        }
        relation_close(deltarel, AccessShareLock); // 关闭 Delta 表
        CStoreEndScan(cstoreScanDesc); // 结束对列存储表的扫描
        pfree_ext(colIdx); // 释放 colIdx 的内存
        pfree_ext(bms_attnums); // 释放 bms_attnums 的内存
        return 0; // 返回0，表示没有进行抽样
    }

    attrSeq = (int*)palloc0(sizeof(int32) * num_attnums);
    // 分配内存以存储属性的顺序
    slotIdList = (int*)palloc0(sizeof(int) * num_attnums);
    // 分配内存以存储槽位的列表
    cuPtr = (CU**)palloc0(sizeof(CU*) * colTotalNum);
    // 分配内存以存储 CU 指针的数组

    if (!estimate_table_rownum) {
        // 如果不需要估算表的行数（非 pretty 模式）

        /* free rows */
        // 释放之前分配的行内存
        for (int i = 0; i < delta_numrows; i++) {
            if (rows[i]) {
                pfree_ext(rows[i]);
                rows[i] = NULL;
            }
        }
        int64 deltatargrows = 0;
        // 初始化 Delta 表的目标行数为0

        /* recalculate target num */
        // 重新计算目标行数，以根据 Delta 表的情况进行调整
        if (deltarows > 0) {
            // 如果 Delta 表中有存活的行

            deltatargrows = (int)rint(targrows * deltarows / totalRowCnts);
            // 根据存活行数比例重新计算目标行数
            /* Make sure we don't overrun due to roundoff error */
            // 确保不因四舍五入误差而超出目标行数
            deltatargrows = Min(deltatargrows, targrows);
            // 限制目标行数不超过原始目标行数
            if (deltatargrows > 0) {
                double trows = 0;
                double tdrows = 0;
                /* Fetch a random sample of the delta table's rows */
                // 从 Delta 表中获取随机样本行
                delta_numrows = acquire_sample_rows<false>(deltarel, elevel, rows, deltatargrows, &trows, &tdrows);
                // 重新抽样 Delta 表
                /* fix total rows */
                // 更新总行数和已删除行数
                *totalrows = trows + curows;
                *totaldeadrows = tdrows + cudeadrows;
            }
        }

        /* change cstore target num */
        // 调整列存储表的目标行数
        int64 temp_target = (int)rint(targrows * curows / totalRowCnts);
        /* Make sure we don't overrun due to roundoff error */
        // 确保不因四舍五入误差而超出目标行数
        temp_target = Min(temp_target, targrows - deltatargrows);
        targrows = temp_target;

        /*
         * calculate cu number by following formula
         * 1. get lived row number
         * 2. estimate row size by suppose the width of each column is 4
         * 3. estimate how many pages needed if it's row-stored
         * 4. evaluate how many CUs needed to sample
         */
        // 通过以下公式计算 CU 数：
        // 1. 获取存活行数
        // 2. 假定每列的宽度为4，估算行大小
        // 3. 估算如果是按行存储需要多少页
        // 4. 评估需要采样的 CU 数
        int totalwidth = 0;
        int relpages = 0;
        BlockNumber sampleCUs = 0;

        totalwidth = 4 * onerel->rd_att->natts;
        relpages = ceil(*totalrows * totalwidth / BLCKSZ);
        if (relpages == 0) {
            relpages = 1;
        }
        sampleCUs = ceil((double)targrows / relpages * totalblocks);
        sampleCUs = (sampleCUs > totalblocks) ? totalblocks : sampleCUs;

        elog(DEBUG2, "ANALYZE INFO : sample %u cu from totoal %u cu", sampleCUs, totalblocks);
        // 输出采样的 CU 数和总 CU 数
        BlockSampler_Init(&bs, totalblocks, sampleCUs);
    } else {
        AssertEreport(!SUPPORT_PRETTY_ANALYZE, MOD_OPT, "");
        // 如果需要估算表的行数，并且不支持 "pretty" 模式分析，则直接采样指定数量的行
        BlockSampler_Init(&bs, totalblocks, targrows);
        elog(DEBUG2, "ANALYZE INFO : sample %ld rows from totoal %u cu", targrows, totalblocks);
    }

    rstate = anl_init_selection_state(targrows);
    // 初始化行采样状态

    /* Prepare for sampling rows */
    // 为行采样做准备
    CStore* cstore = cstoreScanDesc->m_CStore;
    Form_pg_attribute* attrs = cstore->m_relation->rd_att->attrs;
    GetValFunc* getValFuncPtr = (GetValFunc*)palloc(sizeof(GetValFunc) * colTotalNum);

    /* change sample rows pointer */
    // 移动指针以指向下一个要采样的行
    rows += delta_numrows;

    for (int col = 0; col < num_attnums; ++col) {
        int colSeq = attrSeq[col] = colIdx[col] - 1;
        // 获取列的顺序，并将其保存在 attrSeq 数组中
        InitGetValFunc(attrs[colSeq]->attlen, getValFuncPtr, colSeq);
        // 初始化获取列值的函数指针
    }

    ADIO_RUN()
    {
        uint32 quantity = (uint32)CSTORE_ANALYZE_PREFETCH_QUANTITY;
        // 获取预取数量

        anlprefetch.fetchlist1.size = (uint32)((quantity > (totalblocks / 2 + 1)) ? (totalblocks / 2 + 1) : quantity);
        // 设置第一个预取列表的大小，限制在总块数的一半加一以内
        anlprefetch.fetchlist1.blocklist = (BlockNumber*)palloc(sizeof(BlockNumber) * anlprefetch.fetchlist1.size);
        // 为第一个预取列表分配内存
        anlprefetch.fetchlist1.anl_idx = 0;
        anlprefetch.fetchlist1.load_count = 0;

        anlprefetch.fetchlist2.size = anlprefetch.fetchlist1.size;
        // 第二个预取列表与第一个相同大小
        anlprefetch.fetchlist2.blocklist = (BlockNumber*)palloc(sizeof(BlockNumber) * anlprefetch.fetchlist2.size);
        // 为第二个预取列表分配内存
        anlprefetch.fetchlist2.anl_idx = 0;
        anlprefetch.fetchlist2.load_count = 0;
        anlprefetch.init = false;
        // 初始化预取状态为未完成

        ereport(DEBUG1,
            (errmodule(MOD_ADIO),
                errmsg("analyze prefetch for %s prefetch quantity(%u)",
                    RelationGetRelationName(onerel),
                    anlprefetch.fetchlist1.size)));
        // 发送调试信息，表示进行分析预取，显示表名和预取数量
    }
    ADIO_END();

    MemoryContext sample_context; // 用于存储抽样数据的内存上下文
    MemoryContext old_context;    // 保存当前内存上下文，以便稍后恢复
    BlockNumber targblock;        // 目标块号
    int fstColIdx = CStoreGetfstColIdx(onerel); // 获取列存储表的第一列索引
    Datum* constValues = (Datum*)palloc(sizeof(Datum) * colTotalNum); // 存储常量值的数组
    bool* nullValues = (bool*)palloc(sizeof(bool) * colTotalNum);    // 存储空值信息的数组
    Datum* values = (Datum*)palloc0(sizeof(Datum) * colTotalNum);    // 存储数据值的数组，初始化为零
    bool* nulls = (bool*)palloc0(sizeof(bool) * colTotalNum);        // 存储是否为 null 值的数组，初始化为 false
    int* funcIdx = (int*)palloc0(sizeof(int) * colTotalNum);         // 存储函数索引的数组，初始化为零
    List* sampleTupleInfo = NIL;    // 存储抽样元组信息的列表
    sample_tuple_cell* st_cell = NULL; // 抽样元组单元格
    ListCell* cell1 = NULL;       // 用于遍历列表的 ListCell 指针
    ListCell* cell2 = NULL;       // 用于遍历列表的 ListCell 指针
    ListCell* cell3 = NULL;       // 用于遍历列表的 ListCell 指针

    // 创建一个新的内存上下文，用于存储抽样数据，设置上下文名称和大小参数
    sample_context = AllocSetContextCreate(CurrentMemoryContext,
        "sample cstore rows for analyze",
        ALLOCSET_DEFAULT_MINSIZE,
        ALLOCSET_DEFAULT_INITSIZE,
        ALLOCSET_DEFAULT_MAXSIZE);

    while (
        InvalidBlockNumber != (targblock = BlockSampler_GetBlock<true>(
                                   cstoreScanDesc, &bs, &anlprefetch, num_attnums, attrSeq, estimate_table_rownum))) {
        List* valueLocation = NIL;     // 存储值的位置信息的列表
        List* targoffsetList = NIL;    // 存储目标偏移量的列表
        int location = 0;             // 当前位置
        CUDesc cuDesc;                // 列存储单元描述
        uint16 targoffset = 0;        // 目标偏移量
        uint16 maxoffset;             // 最大偏移量
        int64 total_cusize = 0;       // 总共的列存储单元大小
        int start_col = -1;           // 起始列索引
        int end_col = -1;             // 结束列索引
        bool first_batch = true;      // 是否是第一批次
        bool all_in_buffer = true;    // 是否所有数据都在缓冲区内

        targblock = targblock + FirstCUID + 1; // 计算目标块号

        // 如果获取列存储单元描述失败，则继续下一次循环
        if (cstoreScanDesc->m_CStore->GetCUDesc(fstColIdx, targblock, &cuDesc, tmpSnapshot) != true)
            continue;

        // 如果启用工作负载控制，进行 IO 调度和更新
        if (ENABLE_WORKLOAD_CONTROL)
            IOSchedulerAndUpdate(IO_TYPE_READ, 1, IO_TYPE_COLUMN);

        cstore->GetCUDeleteMaskIfNeed(targblock, tmpSnapshot); // 获取列存储单元删除掩码

        // 如果该列存储单元内的所有元组都已删除，则继续下一次循环
        if (cstore->IsTheWholeCuDeleted(cuDesc.row_count))
            continue;

        maxoffset = cuDesc.row_count;

        if (estimate_table_rownum) {
            liverows = maxoffset;
            estBlkNum++;

            if (liverows > 0)
                break;

            ereport(DEBUG1,
                (errmsg("ANALYZE INFO : estimate total rows of \"%s\" - no lived rows in cuid: %u",
                    RelationGetRelationName(onerel),
                    targblock)));

            totalblocks--;
            continue;
        }

        /* 重置 null 标志和常量值标志以供下一个块使用 */
        errno_t rc;

        // 将 nulls 数组的所有元素设置为 true
        rc = memset_s(nulls, sizeof(bool) * colTotalNum, true, sizeof(bool) * colTotalNum);
        securec_check(rc, "\0", "\0");

        // 将 nullValues 数组的所有元素设置为 false
        rc = memset_s(nullValues, sizeof(bool) * colTotalNum, false, sizeof(bool) * colTotalNum);
        securec_check(rc, "\0", "\0");

        // 将 constValues 数组的所有元素设置为 0
        rc = memset_s(constValues, sizeof(Datum) * colTotalNum, 0, sizeof(Datum) * colTotalNum);
        securec_check(rc, "\0", "\0");

/* copy data from cu buffer */
#define copy_sample_dataum(dest, col_num, offset)                                   \
    do {                                                                            \
        old_context = MemoryContextSwitchTo(sample_context);                        \
        Datum dm = getValFuncPtr[colNum][funcIdx[colNum]](cuPtr[colNum], (offset)); \
        int16 valueTyplen = attrs[(col_num)]->attlen;                               \
        bool valueTypbyval = attrs[(col_num)]->attlen == 0 ? false : true;          \
        if (valueTyplen < 0)                                                        \
            (dest) = PointerGetDatum(PG_DETOAST_DATUM_COPY(dm));                    \
        else                                                                        \
            (dest) = datumCopy(dm, valueTypbyval, valueTyplen);                     \
        (void)MemoryContextSwitchTo(old_context);                                   \
    } while (0)

/*
 * 检查是否选择了特定的行进行分析
 * 1. 跳过已删除的行（死行）
 * 2. 如果已获取的行数 < 目标行数，则获取所有行
 * 3. 随机选择一个位置替换一个元组
 */
#define check_match_tuple(copyTuple)                                              \
    do {                                                                          \
        (copyTuple) = false;                                                      \
        if (cstore->IsDeadRow((uint32)targblock, (uint32)targoffset)) {           \
            deadrows++;                                                           \
        } else if (numrows < targrows) {                                          \
            (copyTuple) = true;                                                   \
            location = numrows;                                                   \
            numrows++;                                                            \
            samplerows++;                                                         \
        } else {                                                                  \
            if (0 >= anl_get_next_S(samplerows, targrows, &rstate)) {             \
                location = (int64)(targrows * anl_random_fract());                \
                (copyTuple) = true;                                               \
                AssertEreport(location >= 0 && location < targrows, MOD_OPT, ""); \
            }                                                                     \
            samplerows++;                                                         \
        }                                                                         \
    } while (0)

#define load_cu_data(s_col, e_col, values, nulls, copy)                                                       \
    do {                                                                                                      \
        for (int col1 = (s_col); col1 <= (e_col); ++col1) {                                                   \
            int colNum = attrSeq[col1];                                                                       \
            if (cuPtr[colNum]) {                                                                              \
                if (cuPtr[colNum]->IsNull(targoffset)) {                                                      \
                    (nulls)[colNum] = true;                                                                   \
                    (values)[colNum] = 0;                                                                     \
                } else {                                                                                      \
                    (nulls)[colNum] = false;                                                                  \
                    if (copy)                                                                                 \
                        copy_sample_dataum((values)[colNum], colNum, targoffset);                             \
                    else                                                                                      \
                        (values)[colNum] = getValFuncPtr[colNum][funcIdx[colNum]](cuPtr[colNum], targoffset); \
                }                                                                                             \
            } else {                                                                                          \
                (nulls)[colNum] = nullValues[colNum];                                                         \
                (values)[colNum] = constValues[colNum];                                                       \
            }                                                                                                 \
        }                                                                                                     \
    } while (0)

		/*
		 * 试图加载所有的CU数据到cstore_buffers中：
		 * 1. 如果总CU大小小于cstore_buffers的1/8，将所有CU加载到CU缓冲区。
		 * 2. 如果总CU大小大于或等于cstore_buffers的1/8，将样本数据复制到临时内存以避免固定太多的CU。
		 */
		for (int col = 0; col < num_attnums; ++col) {
		    int colNum = attrSeq[col];
		
		    cuPtr[colNum] = NULL;
		    slotIdList[col] = CACHE_BLOCK_INVALID_IDX;
		
		    // 如果是当前处理的第一个列
		    if (-1 == start_col)
		        start_col = col;
		    end_col = col;
		
		    // 获取CU描述符
		    (void)cstore->GetCUDesc(colNum, targblock, &cuDesc, tmpSnapshot);
		
		    if (cuDesc.IsNullCU()) {
		        nullValues[colNum] = true;
		        constValues[colNum] = 0;
		        elog(DEBUG2,
		            "ANALYZE INFO - 表 \"%s\"：attnum(%d)，cuid(%u) 为空",
		            RelationGetRelationName(onerel),
		            colNum,
		            targblock);
		        continue;
		    } else if (cuDesc.IsSameValCU()) {
		        bool shoulFree = false;
		
		        nullValues[colNum] = false;
		        // 从CU描述符中获取常量值
		        old_context = MemoryContextSwitchTo(sample_context);
		        constValues[colNum] = CStore::CudescTupGetMinMaxDatum(&cuDesc, attrs[colNum], true, &shoulFree);
		        (void)MemoryContextSwitchTo(old_context);
		        elog(DEBUG2,
		            "ANALYZE INFO - 表 \"%s\"：attnum(%d)，cuid(%u) 包含常量值",
		            RelationGetRelationName(onerel),
		            colNum,
		            targblock);
		        continue;
		    } else {
		        nullValues[colNum] = false;
		        constValues[colNum] = 0;
		        // 获取CU数据并缓存
		        cuPtr[colNum] = cstore->GetCUData(&cuDesc, colNum, attrs[colNum]->attlen, slotIdList[col]);
		        funcIdx[colNum] = cuPtr[colNum]->HasNullValue() ? 1 : 0;
		        // 在每个CU的IO操作之前检查是否开启了Vacuum延迟。如果可以从CU缓存中获取CU数据，我们应该减少AMAP的调用次数。
		        vacuum_delay_point();
		
		        // 断言CU数据不是压缩的
		        AssertEreport(!cuPtr[colNum]->m_cache_compressed, MOD_OPT, "");
		        total_cusize += cuPtr[colNum]->GetUncompressBufSize();
		
		        /*
		         * 如果总CU大小小于cusize_threshold并且（或者是最后一列，以确保所有样本CU数据都已加载到临时内存中），
		         * 则继续下一列的处理。
		         */
		        if (total_cusize < cusize_threshold && (first_batch || (num_attnums - 1) != col))
		            continue;
		
		        if (NIL == sampleTupleInfo) {
		            ereport(LOG,
		                (errmsg(
		                     "ANALYZE INFO - 表 \"%s\"：从CU缓冲区复制数据", RelationGetRelationName(onerel)),
		                    errdetail("增加cstore_buffers的大小以避免复制数据")));
		        }
		        elog(DEBUG2,
		            "ANALYZE INFO - 表 \"%s\"：复制列数据 [%d, %d] 从CU缓冲区",
		            RelationGetRelationName(onerel),
		            start_col,
		            end_col);
		    }
		
		    all_in_buffer = false;
		    if (first_batch) {
		        /* 处理第一个批次的CU数据，我们应该首先初始化sample_tuple_cell */
		        bool copyTuple = false;
		        cell1 = list_head(sampleTupleInfo) ? list_head(sampleTupleInfo) : NULL;
		        for (targoffset = FirstOffsetNumber - 1; targoffset < maxoffset; targoffset++) {
		            check_match_tuple(copyTuple);
		            if (!copyTuple)
		                continue;
		
		            if (cell1 != NULL) {
		                errno_t rc;
		
		                st_cell = (sample_tuple_cell*)lfirst(cell1);
		                rc = memset_s(st_cell->nulls, sizeof(bool) * colTotalNum, true, sizeof(bool) * colTotalNum);
		                securec_check(rc, "\0", "\0");
		                rc = memset_s(st_cell->values, sizeof(Datum) * colTotalNum, 0, sizeof(Datum) * colTotalNum);
		                securec_check(rc, "\0", "\0");
		            } else {
		                errno_t rc;
		
		                st_cell = (sample_tuple_cell*)palloc0(sizeof(sample_tuple_cell));
		                sampleTupleInfo = lappend(sampleTupleInfo, st_cell);
		
		                st_cell->nulls = (bool*)palloc(sizeof(bool) * colTotalNum);
		                rc = memset_s(st_cell->nulls, sizeof(bool) * colTotalNum, true, sizeof(bool) * colTotalNum);
		                securec_check(rc, "\0", "\0");
		                st_cell->values = (Datum*)palloc0(sizeof(Datum) * colTotalNum);
		            }
		
		            valueLocation = lappend_int(valueLocation, location);
		            targoffsetList = lappend_int(targoffsetList, targoffset);
		            // 加载CU数据
		            load_cu_data(start_col, end_col, st_cell->values, st_cell->nulls, true);
		            cell1 = (cell1 && lnext(cell1)) ? lnext(cell1) : NULL;
		        }
		
		        for (int col1 = start_col; col1 <= end_col; ++col1) {
		            if (IsValidCacheSlotID(slotIdList[col1]))
		                CUCache->UnPinDataBlock(slotIdList[col1]);
		        }
		
		        first_batch = false;
		        AssertEreport(sampleTupleInfo, MOD_OPT, "");
		    } else {
		        /* 已经建立了sample_tuple_cell，只需将数据从缓冲区复制到临时内存中 */
		        AssertEreport(sampleTupleInfo, MOD_OPT, "");
		        forboth(cell1, sampleTupleInfo, cell3, targoffsetList)
		        {
		            st_cell = (sample_tuple_cell*)lfirst(cell1);
		            targoffset = lfirst_int(cell3);
		            // 加载CU数据
		            load_cu_data(start_col, end_col, st_cell->values, st_cell->nulls, true);
		        }
		
		        for (int col1 = start_col; col1 <= end_col; ++col1) {
		            if (IsValidCacheSlotID(slotIdList[col1]))
		                CUCache->UnPinDataBlock(slotIdList[col1]);
		        }
		    }
		
		    start_col = -1;
		}

	if (all_in_buffer) {
	    /* 已经将所有的CU加载到CU缓冲区，直接使用CU缓冲区数据构建元组 */
	    bool copyTuple = false;
	
	    // 断言已处理的列范围正确
	    AssertEreport(0 == start_col && end_col == num_attnums - 1, MOD_OPT, "");
	
	    for (targoffset = FirstOffsetNumber - 1; targoffset < maxoffset; targoffset++) {
	        check_match_tuple(copyTuple);
	        if (!copyTuple)
	            continue;
	
	        // 加载CU数据到元组
	        load_cu_data(0, num_attnums - 1, values, nulls, false);
	        tableam_tops_free_tuple(rows[location]);
	        // 使用CU数据构建HeapTuple
	        rows[location] = (HeapTuple)tableam_tops_form_tuple(onerel->rd_att, values, nulls, HEAP_TUPLE);
	        ItemPointerSet(&(rows[location])->t_self, targblock, targoffset + 1);
	    }
	
	    for (int col1 = 0; col1 < num_attnums; ++col1) {
	        if (IsValidCacheSlotID(slotIdList[col1]))
	            CUCache->UnPinDataBlock(slotIdList[col1]);
	    }
	} else {
	    /* 使用临时内存中的数据构建元组 */
	    AssertEreport(end_col == num_attnums - 1, MOD_OPT, "");
	    forthree(cell1, sampleTupleInfo, cell2, valueLocation, cell3, targoffsetList)
	    {
	        st_cell = (sample_tuple_cell*)lfirst(cell1);
	        location = lfirst_int(cell2);
	        targoffset = lfirst_int(cell3);
	        tableam_tops_free_tuple(rows[location]);
	        // 使用临时内存中的数据构建HeapTuple
	        rows[location] = (HeapTuple)tableam_tops_form_tuple(onerel->rd_att, st_cell->values, st_cell->nulls, HEAP_TUPLE);
	        ItemPointerSet(&(rows[location])->t_self, targblock, targoffset + 1);
	    }
	
	    // 释放临时列表
	    list_free_ext(valueLocation);
	    list_free_ext(targoffsetList);
	}
	
	// 重置内存上下文
	MemoryContextReset(sample_context);

	/* 步骤 4：释放内存 */
	pfree_ext(nullValues);
	pfree_ext(constValues);
	pfree_ext(nulls);
	pfree_ext(values);
	pfree_ext(attrSeq);
	pfree_ext(colIdx);
	pfree_ext(funcIdx);
	pfree_ext(cuPtr);
	pfree_ext(slotIdList);
	pfree_ext(getValFuncPtr);
	list_free_ext(sampleTupleInfo);
	pfree_ext(bms_attnums);
	
	/* 删除内存上下文 */
	MemoryContextDelete(sample_context);
	
	ADIO_RUN()
	{
	    pfree_ext(anlprefetch.fetchlist1.blocklist);
	    pfree_ext(anlprefetch.fetchlist2.blocklist);
	}
	ADIO_END();
	
	/* 步骤 5：关闭 delta 表并结束 cstore 扫描 */
	relation_close(deltarel, AccessShareLock);
	CStoreEndScan(cstoreScanDesc);
	
	if (estimate_table_rownum) {
	    /* 在非 pretty 模式下估算总行数 */
	    AssertEreport(!SUPPORT_PRETTY_ANALYZE, MOD_OPT, "");
	
	    if (totalblocks == 0 || (totalblocks > 0 && liverows > 0)) {
	        *totalrows = liverows * totalblocks + deltarows;
	    } else {
	        /* 目标 300 行的所有块都是死行。 */
	        *totalrows = INVALID_ESTTOTALROWS + targrows;
	    }
	
	    ereport(elevel,
	        (errmsg("ANALYZE INFO : \"%s\"：扫描了 %u 个 CU，目标 cuid：%u，"
	                "包含 %ld 个活动行， %ld 个死亡行，估计总行数 %.0f",
	            RelationGetRelationName(onerel),
	            estBlkNum,
	            totalblocks,
	            targblock,
	            liverows,
	            deadrows,
	            *totalrows)));
	
	    return numrows + delta_numrows;
	}
	
	/*
	 * 步骤 6：对行进行排序并估算 reltuples
	 *
	 * 如果我们没有找到所需数量的元组，则无需排序，因为它们已经有序。
	 *
	 * 否则，我们需要根据位置（itempointer）对收集的元组进行排序。
	 * 不值得担心已经有序的边界情况。
	 */
	if (numrows == targrows)
	    qsort((void*)rows, numrows, sizeof(HeapTuple), compare_rows);
	
	/* 在数据节点中，输出一些有趣的关系信息 */
	if (IS_PGXC_DATANODE) {
	    ereport(elevel,
	        (errmsg("ANALYZE INFO : \"%s\"：扫描了 %d 个 CU，样本 %ld 行，估算总 %.0f 行",
	            RelationGetRelationName(onerel),
	            bs.m,
	            totalblocks,
	            numrows,
	            *totalrows)));
	}
	
	return numrows + delta_numrows;

该函数的关键部分和作用如下：

获取样本数据：函数通过对表格的列存储块进行抽样，获取一定数量的行数据，这些行数据将用于后续的分析和统计。
估算总行数和死行数：函数会估算列存储表格的总行数和死行数。总行数是表格中的所有行数，而死行数是已标记为删除的行数。
处理 delta 表：如果表格具有 delta 表（差异表），函数会首先尝试从 delta 表中获取样本数据，以提高估算的准确性。
数据处理：函数根据样本数据中的 null 值、常量值等信息进行数据处理，包括处理列的数据类型和 null 值。
样本数据排序：如果成功获取了样本数据，并且样本数据数量达到了目标数量，函数会对样本数据进行排序，以确保它们按照物理位置在表格中的顺序排列。
输出结果：函数会返回实际获取的样本数据行数，以及估算的总行数和死行数。这些信息将用于查询优化和统计信息收集。
其他功能：函数还包括一些额外的功能，例如处理样本数据的方式（复制到临时内存或直接在 CU 缓冲区中操作）、IO 调度（根据优化器的要求进行数据加载）等。

es_get_attnums_to_analyze 函数

es_get_attnums_to_analyze 函数用于获取需要进行分析的所有列的 attnum（属性号），包括单列统计和多列统计。

参数：

vacattrstats：VacAttrStats 数组，包含要分析的列的统计信息。
vacattrstats_size：VacAttrStats 数组的大小。

返回值：

Bitmapset*：一个位图集合，包含所有需要分析的列的 attnum。调试信息如下：

函数逻辑：

创建一个名为 bms_attnum 的位图集合，用于存储需要分析的列的 attnum。
使用两个嵌套的循环遍历 vacattrstats 数组和其中的每个 VacAttrStats 元素。
（1）外循环遍历 vacattrstats 数组。
（2）内循环遍历每个 VacAttrStats 元素的属性列表，属性列表存储在 attrs 成员中。
在内循环中，获取每个属性的 attnum（属性号）并将其添加到 bms_attnum 中，使用 bms_add_member 函数。
最终，函数返回一个位图集合 bms_attnum，其中包含了需要进行分析的所有列的 attnum。

函数源码如下：（路径：src/common/backend/utils/adt/extended_statistics.cpp）

/*
 * es_get_attnums_to_analyze
 *     get all attnums to be analyzed, including single column stats and multi-column stats
 *
 * @param (in) vacattrstats:
 *     the VacAttrStats array
 * @param (in) vacattrstats_size:
 *     the size of the VacAttrStats array
 *
 * @return:
 *     a Bitmapset including all columns' attnum
 */
Bitmapset* es_get_attnums_to_analyze(VacAttrStats** vacattrstats, int vacattrstats_size)
{
    Bitmapset* bms_attnum = NULL;
    for (int i = 0; i < vacattrstats_size; ++i) {
        for (unsigned int j = 0; j < vacattrstats[i]->num_attrs; ++j) {
            int2 attnum = vacattrstats[i]->attrs[j]->attnum;
            bms_attnum = bms_add_member(bms_attnum, attnum);
        }
    }
    return bms_attnum;
}

CStoreRelGetCUNumByNow 函数

CStoreRelGetCUNumByNow 函数用于获取一个列存储（Column Store）表在当前时刻的压缩单元（CU）数量。

参数：

cstoreScanState：列存储扫描描述符，包含了对列存储表的扫描状态信息。

返回值：

uint32：表示当前时刻列存储表的压缩单元数量。

函数逻辑：

获取与列存储表关联的元组描述符（TupleDesc）和关联（Relation）。
打开与列存储表关联的 CUDesc（压缩单元描述）关系和其索引。
（1）cudesc_rel：CUDesc 表的关系。
（2）cudesc_tupdesc：CUDesc 表的元组描述符。
（3）idx_rel：CUDesc 表的索引关系。
获取列存储表的第一个属性的属性号 attid。
（1）如果第一个属性已经被删除（attisdropped 为真），则获取列存储表中第一个未被删除属性的属性号（fstColIdx 指示第一个未被删除属性的索引）。
初始化用于检索 CUDesc 表的索引扫描键（ScanKey），以便按照属性号（col_id）查找对应的压缩单元描述。
开始有序系统表扫描（SysScanDesc），以获取与指定属性号匹配的压缩单元描述。
初始化一个变量 max_cuid，用于存储找到的最大压缩单元编号。将其初始化为 FirstCUID 的值。
通过反向扫描（BackwardScanDirection）系统表，查找匹配的压缩单元描述。如果找到匹配的描述，则将其压缩单元编号存储在 max_cuid 中。
结束有序系统表扫描。
关闭 CUDesc 表的索引和关系。
返回压缩单元数量，计算方式为 max_cuid - FirstCUID，即找到的最大压缩单元编号减去起始压缩单元编号 FirstCUID。

函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

// CStoreRelGetCUNumByNow
// 获取当前时刻关系的CU（压缩单元）数量

uint32 CStoreRelGetCUNumByNow(CStoreScanDesc cstoreScanState)
{
    ScanKeyData key;
    HeapTuple tup;
    bool isnull = false;
    Relation relation = cstoreScanState->m_CStore->m_relation;

    /*
     * 打开CUDesc关系和其索引。
     * CUDesc关系存储了列存储关系中每个列的CU（压缩单元）的描述信息，
     * 索引用于快速检索特定列的CU信息。
     */
    Relation cudesc_rel = heap_open(relation->rd_rel->relcudescrelid, AccessShareLock);
    TupleDesc cudesc_tupdesc = cudesc_rel->rd_att;
    Relation idx_rel = index_open(cudesc_rel->rd_rel->relcudescidx, AccessShareLock);

    int attid = relation->rd_att->attrs[0]->attnum;

    // 如果列已删除（attisdropped），则选择关系的第一个非删除列。
    if (relation->rd_att->attrs[0]->attisdropped) {
        int fstColIdx = CStoreGetfstColIdx(relation);
        attid = relation->rd_att->attrs[fstColIdx]->attnum;
    }

    /* 设置扫描键以通过列ID从索引中获取数据。 */
    ScanKeyInit(&key, (AttrNumber)CUDescColIDAttr, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(attid));

    // 开始有序扫描CUDesc关系以获取与列相关的最后一个CU描述。
    SysScanDesc cudesc_scan = systable_beginscan_ordered(cudesc_rel, idx_rel, SnapshotNow, 1, &key);

    uint32 max_cuid = FirstCUID;

    /*
     * 优化以获取列的最后一个CU（压缩单元）描述。
     * 使用BackwardScanDirection扫描以获取最新的CU描述信息。
     */
    if ((tup = systable_getnext_ordered(cudesc_scan, BackwardScanDirection)) != NULL) {
        max_cuid = DatumGetUInt32(fastgetattr(tup, CUDescCUIDAttr, cudesc_tupdesc, &isnull));
    }
    systable_endscan_ordered(cudesc_scan);
    index_close(idx_rel, AccessShareLock);
    heap_close(cudesc_rel, AccessShareLock);

    // 返回最后一个CU的ID，并将其与FirstCUID相减以获得CU的数量。
    return (max_cuid - FirstCUID);
}

该函数通常在列存储数据库的查询优化和统计信息收集过程中使用，以了解关系中当前 CU 的数量。

CStore::GetLivedRowNumbers 函数

CStore::GetLivedRowNumbers 函数的作用是计算 CStore 存储引擎中指定关系的存活（未删除）行数，并提供了总删除行数。这个函数通过遍历列存储单元（CU）的描述信息来实现这一目标。

代码的主要步骤如下：

初始化变量 rowNumbers 为0，该变量用于存储存活行数。
初始化变量 * totaldeadrows 为0，该变量用于存储已删除行数。
使用 LoadCUDescCtl 对象 loadInfo 初始化，该对象用于加载CU（压缩单元）的描述信息。
进入循环，通过 GetCURowCount 函数获取CU的行数信息，并存储在 loadInfo 中。
遍历每个CU的描述信息，获取其行数以及检查是否存在已删除的行。
如果存在已删除的行，通过计算位掩码中设置的位数来更新存活行数和已删除行数。
继续加载下一个CU的描述信息，直到所有CU都被处理。
销毁 loadInfo 对象，释放相关资源。
返回存活行数。

其函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/*
 * 获取CStore关系的存活行数。
 * 该函数计算CStore关系中存活（未删除）行的数量，
 * 并提供总删除行数。
 *
 * @param (out) totaldeadrows:
 *     指向存储总删除行数的变量的指针。
 *
 * @return:
 *     CStore关系中存活（未删除）行的数量。
 */
int64 CStore::GetLivedRowNumbers(int64* totaldeadrows)
{
    int64 rowNumbers = 0;  // 初始化变量以存储存活行数。
    LoadCUDescCtl loadInfo(m_startCUID);  // 创建用于加载CU描述符的控制对象。

    *totaldeadrows = 0;  // 将总删除行数初始化为零。

    // 遍历CU描述符。
    while (GetCURowCount(m_firstColIdx, &loadInfo, m_snapshot)) {
        CUDesc* cuDescArray = loadInfo.cuDescArray;

        // 遍历当前加载的CU描述符数组。
        for (uint32 i = 0; i < loadInfo.curLoadNum; ++i) {
            GetCUDeleteMaskIfNeed(cuDescArray[i].cu_id, m_snapshot);

            // 增加存活行数。
            rowNumbers += cuDescArray[i].row_count;

            if (m_hasDeadRow) {
                int nBytes = (cuDescArray[i].row_count + 7) / 8;

                // 遍历位图字节，计算总删除行数。
                for (int j = 0; j < nBytes; ++j) {
                    *totaldeadrows += NumberOfBit1Set[m_cuDelMask[j]];
                    rowNumbers -= NumberOfBit1Set[m_cuDelMask[j]];
                }
            }
        }
    }
    loadInfo.Destroy();

InitGetValFunc 函数

InitGetValFunc 函数的主要作用是根据数据类型的字节长度 attlen 初始化一个函数指针数组 getValFuncPtr，用于获取不同数据类型的值。这个函数在分析过程中非常有用，因为它允许针对不同的数据类型选择正确的函数来获取列数据，以确保数据的正确性和高效性。

具体来说，这个函数的作用如下：

根据传入的 attlen 参数，确定数据类型的字节长度，以便后续选择合适的函数来处理数据。
根据数据类型的字节长度，为该列初始化两个函数指针，一个用于处理带符号的数据，另一个用于处理无符号的数据。这些函数指针会存储在 getValFuncPtr 数组中的特定列中。
这些函数指针在分析期间用于获取列数据。根据列的数据类型和是否带符号，选择适当的函数指针，以确保正确地获取数据值。
如果传入的 attlen 值不匹配任何已知的数据类型，函数会引发错误，报告不支持的数据类型。
总结：InitGetValFunc 函数为分析过程提供了必要的工具，以根据不同的数据类型获取正确的列数据，确保了数据分析的准确性和效率。

其函数源码如下：（路径：src/gausskernel/optimizer/commands/analyze.cpp）

void InitGetValFunc(int attlen, GetValFunc* getValFuncPtr, int col)
{
    switch (attlen) {
        case sizeof(uint8): {
            getValFuncPtr[col][0] = &GetValue<1, false>;
            getValFuncPtr[col][1] = &GetValue<1, true>;
            break;
        }
        case sizeof(uint16): {
            getValFuncPtr[col][0] = &GetValue<2, false>;
            getValFuncPtr[col][1] = &GetValue<2, true>;
            break;
        }
        case sizeof(uint32): {
            getValFuncPtr[col][0] = &GetValue<4, false>;
            getValFuncPtr[col][1] = &GetValue<4, true>;
            break;
        }
        case sizeof(uint64): {
            getValFuncPtr[col][0] = &GetValue<8, false>;
            getValFuncPtr[col][1] = &GetValue<8, true>;
            break;
        }
        case 12: {
            getValFuncPtr[col][0] = &GetValue<12, false>;
            getValFuncPtr[col][1] = &GetValue<12, true>;
            break;
        }
        case 16: {
            getValFuncPtr[col][0] = &GetValue<16, false>;
            getValFuncPtr[col][1] = &GetValue<16, true>;
            break;
        }
        case -1: {
            getValFuncPtr[col][0] = &GetValue<-1, false>;
            getValFuncPtr[col][1] = &GetValue<-1, true>;
            break;
        }
        case -2: {
            getValFuncPtr[col][0] = &GetValue<-2, false>;
            getValFuncPtr[col][1] = &GetValue<-2, true>;
            break;
        }
        default:
            ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("unsupported datatype")));
    }
}

CStoreGetfstColIdx 函数

CStoreGetfstColIdx 函数的主要功能是遍历给定关系 rel 的所有列，并找到第一个未被删除（未被标记为 dropped）的列，然后返回该列的索引（列号）。这个函数通常用于在处理表或关系的列时，需要忽略已删除的列，从而准确地获取第一个有效的列。如果没有未被删除的列，它将返回 0，表示第一列未被删除。其函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/*
 * @Description: get the first colum index that is not dropped
 * @Param[IN] rel: the target relation
 * @Return: the first column index that is not dropped
 * @See also:
 */
int CStoreGetfstColIdx(Relation rel)
{
    for (int i = 0; i < rel->rd_att->natts; i++) {
        if (!rel->rd_att->attrs[i]->attisdropped)
            return i;
    }
    return 0;
}

CStore::GetCUDesc 函数

CStore::GetCUDesc 函数的作用是根据给定的列号（col）和 CU ID（cuid）获取列的 CUDesc（列存储单元描述）。它主要完成以下任务：

初始化相关变量和上下文。
打开 CUDesc 表和其索引。
设置用于索引扫描的扫描键。
执行索引扫描，找到匹配的 CUDesc 记录。
解析 CUDesc 记录，提取其中的信息并存储到 cuDescPtr 结构中。
关闭相关的数据库对象，释放资源。
返回是否找到匹配的 CUDesc 记录。如果找到，返回 true；否则，返回 false。

其函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/*
 * Get CUDesc of column according to cuid.
 * 根据 cuid 获取列的 CUDesc（列存储单元描述）。
 */
bool CStore::GetCUDesc(_in_ int col, _in_ uint32 cuid, _out_ CUDesc* cuDescPtr, _in_ Snapshot snapShot)
{
    ScanKeyData key[2];
    HeapTuple tup;
    bool found = false;
    errno_t rc = EOK;
    Assert(col >= 0);

    // 当切换到下一批 cudesc 数据时，我们将重置 m_perScanMemCnxt。
    // 因此，仅在此批次中使用的空间应由 m_perScanMemCnxt 管理。
    AutoContextSwitch newMemCnxt(m_perScanMemCnxt);

    /*
     * 打开 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 isFixedLen = m_relation->rd_att->attrs[col]->attlen > 0 ? true : false;
    // 转换逻辑 ID 为属性的物理 ID
    int attid = m_relation->rd_att->attrs[col]->attnum;

    /*
     * 设置扫描键以通过 attid 从索引中获取。
     */
    ScanKeyInit(&key[0], (AttrNumber)CUDescColIDAttr, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(attid));

    ScanKeyInit(&key[1], (AttrNumber)CUDescCUIDAttr, BTEqualStrategyNumber, F_OIDEQ, UInt32GetDatum(cuid));

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

    SysScanDesc cudesc_scan = systable_beginscan_ordered(cudesc_rel, idx_rel, snapShot, 2, key);
    // 仅循环一次
    while ((tup = systable_getnext_ordered(cudesc_scan, ForwardScanDirection)) != NULL) {
        Datum values[CUDescCUExtraAttr] = {0};
        bool isnull[CUDescCUExtraAttr] = {0};
        char* valPtr = NULL;

        heap_deform_tuple(tup, cudesc_tupdesc, values, isnull);

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

        cuDescPtr->xmin = HeapTupleGetRawXmin(tup);

        cuDescPtr->cu_id = cu_id;

        // 将最小值放入 cudesc->cu_min
        if (!isnull[CUDescMinAttr - 1]) {
            char* minPtr = cuDescPtr->cu_min;
            char len_1 = MIN_MAX_LEN;
            valPtr = DatumGetPointer(values[CUDescMinAttr - 1]);
            if (!isFixedLen) {
                *minPtr = (char)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, "", "");
        }
        // 将最大值放入 cudesc->cu_max
        if (!isnull[CUDescMaxAttr - 1]) {
            char* maxPtr = cuDescPtr->cu_max;
            char len_2 = MIN_MAX_LEN;
            valPtr = DatumGetPointer(values[CUDescMaxAttr - 1]);
            if (!isFixedLen) {
                *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, "", "");
        }

        cuDescPtr->row_count = DatumGetInt32(values[CUDescRowCountAttr - 1]);
        Assert(!isnull[CUDescRowCountAttr - 1]);

        // 将 CUMode 放入 cudesc->cumode
        cuDescPtr->cu_mode = DatumGetInt32(values[CUDescCUModeAttr - 1]);
        Assert(!isnull[CUDescCUModeAttr - 1]);

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

        // 将 CUPointer 放入 cudesc->cuPointer
        char* cu_ptr = DatumGetPointer(values[CUDescCUPointerAttr - 1]);
        Assert(!isnull[CUDescCUPointerAttr - 1] && cu_ptr);
        rc = memcpy_s(&cuDescPtr->cu_pointer, sizeof(CUPointer), VARDATA_ANY(cu_ptr), sizeof(CUPointer));
        securec_check(rc, "", "");
        Assert(VARSIZE_ANY_EXHDR(cu_ptr) == sizeof(CUPointer));

        cuDescPtr->magic = DatumGetUInt32(values[CUDescCUMagicAttr - 1]);
        Assert(!isnull[CUDescCUMagicAttr - 1]);
        found = true;
    }
    systable_endscan_ordered(cudesc_scan);
    index_close(idx_rel, AccessShareLock);
    heap_close(cudesc_rel, AccessShareLock);

    return found;
}

CStore::IsTheWholeCuDeleted 函数

CStore::IsTheWholeCuDeleted 函数的作用是根据给定的 cuid（列存储单元 ID）加载相应的删除掩码，以标识是否存在已删除的行。它完成以下任务：

初始化相关变量。
如果已加载相同的删除掩码，直接返回，无需再次加载。
在进行扫描之前，切换到新的内存上下文以管理分配的内存。
打开 CUDesc 关系和其索引，以准备执行索引扫描。
设置用于索引扫描的扫描键。
如果未提供快照，则使用当前活动快照。
开始按顺序扫描 CUDesc 关系，查找匹配的记录。
如果找到匹配的记录，则提取 CUPointer（列存储单元指针）并相应地处理删除掩码。
结束索引扫描并关闭相关的数据库对象。
处理异常情况

函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

ull = false;
errno_t rc = EOK;
bool found = false;

// 如果删除掩码已加载，无需再次加载，直接返回
if (m_delMaskCUId == cuid)
    return;

// 当切换到下一批 cudesc 数据时，我们将重置 m_perScanMemCnxt。
// 因此，仅在此批次中使用的空间应由 m_perScanMemCnxt 管理。
AutoContextSwitch newMemCnxt(m_perScanMemCnxt);

// 打开 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);

// 设置扫描键以通过 attid 从索引中获取。
ScanKeyInit(&key[0], (AttrNumber)CUDescColIDAttr, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(VitrualDelColID));

ScanKeyInit(&key[1], (AttrNumber)CUDescCUIDAttr, BTEqualStrategyNumber, F_OIDEQ, UInt32GetDatum(cuid));

// 如果未提供快照，则使用当前活动快照
snapShot = (snapShot == NULL) ? GetActiveSnapshot() : snapShot;
Assert(snapShot != NULL);

// 开始按顺序扫描 cudesc 关系
SysScanDesc cudesc_scan = systable_beginscan_ordered(cudesc_rel, idx_rel, snapShot, 2, key);

if ((tup = systable_getnext_ordered(cudesc_scan, ForwardScanDirection)) != NULL) {
    // 将 CUPointer 放入 cudesc->cuPointer
    Datum v = fastgetattr(tup, CUDescCUPointerAttr, cudesc_tupdesc, &isnull);
    if (isnull)
        m_hasDeadRow = false;
    else {
        m_hasDeadRow = true;
        int8* bitmap = (int8*)PG_DETOAST_DATUM(DatumGetPointer(v));
        rc = memcpy_s(m_cuDelMask, MaxDelBitmapSize, VARDATA_ANY(bitmap), VARSIZE_ANY_EXHDR(bitmap));
        securec_check(rc, "", "");

        // 因为可能创建了新的内存，所以我们必须检查并及时释放。
        if ((Pointer)bitmap != DatumGetPointer(v)) {
            pfree_ext(bitmap);
        }
    }

    found = true;
}

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

// 如果未找到对应的删除掩码，则处理异常情况
if (!found) {
    TransactionId currGlobalXmin = pg_atomic_read_u64(&t_thrd.xact_cxt.ShmemVariableCache->recentGlobalXmin);
    Assert(snapShot->xmin > 0);
    if (TransactionIdPrecedes(snapShot->xmin, currGlobalXmin))
        ereport(ERROR,
                (errcode(ERRCODE_SNAPSHOT_INVALID),
                 (errmsg("Snapshot too old."),
                  errdetail("Could not get the old version of CUDeleteBitmap, RecentGlobalXmin: %lu, "
                            "snapShot->xmin: %lu, snapShot->xmax: %lu",
                            currGlobalXmin,
                            snapShot->xmin,
                            snapShot->xmax),
                  errhint("This is a safe error report, will not impact data consistency, retry your query if "
                          "needed."))));
    else {
        if (m_useBtreeIndex)
            m_delMaskCUId = InValidCUID;
        else {
            // 处理异常情况：CU 删除位图丢失
            ereport(PANIC,
                    (errmsg("CU Delete bitmap is missing."),
                     errdetail("There might be some issue about cu %u delete bitmap, Please contact HW engineers "
                               "for support.",
                               cuid)));
        }
    }
} else {
    // 记录已加载的删除掩码的 cuid
    m_delMaskCUId = cuid;
}

return;
}

CStore::IsTheWholeCuDeleted 函数

CStore::IsTheWholeCuDeleted 函数的作用是判断指定的列存储单元（CU）是否已经完全删除。函数接受一个参数 rowsInCu，表示列存储单元中的行数。

函数内部的逻辑如下：

首先，它检查成员变量 m_hasDeadRow 是否为 true，这个变量表示当前列存储中是否包含已删除的行。如果没有已删除的行，那么整个列存储单元就不可能被删除。
如果 m_hasDeadRow 为 true，则调用 IsTheWholeCuDeleted 函数来进一步检查列存储单元的删除状态。它将 m_cuDelMask（删除掩码）和 rowsInCu 作为参数传递给 IsTheWholeCuDeleted 函数，以确定列存储单元是否已完全删除。

其中，函数 IsTheWholeCuDeleted 被定义为两个版本，一个版本接受 int 类型的参数，另一个版本接受 char* 类型的参数。目的是优化性能，当没有已删除的行时，不需要执行更复杂的检查，直接返回结果。只有在存在已删除的行时，才需要进一步检查删除状态。
函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

bool CStore::IsTheWholeCuDeleted(int rowsInCu)
{
    return m_hasDeadRow && IsTheWholeCuDeleted((char*)m_cuDelMask, rowsInCu);
}

/**
 * @Description: 检查该CU内的所有元组是否已删除。
 *               如果是，则返回true；否则返回false。
 * @param rowsInCu: CU内包含的元组数量
 * @param delBitmapPtr: 删除位图
 * @return: 如果该位图内的所有元组都已删除，则返回true。
 *          如果有任何一个元组是活跃的，则返回false。
 * @See also:
 */
bool CStore::IsTheWholeCuDeleted(char* delBitmapPtr, int rowsInCu)
{
    // 预先计算用于快速比较的映射数组
    static const uint8 map[] = {0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
    unsigned int numUint64 = 0;
    unsigned int numUint8 = 0;
    unsigned int mapIdx = 0;

    /*
     * numUint64 表示当值的数量为 rowsInCu 时，使用多少个 Uint64 数据；
     * 这等于 (rowsInCu/64)，因为 Uint64 可以保存 64 位。
     * numUint8 表示使用多少个 Uint8 数据，不包括 (numUint64 * 64) 个值；
     * 这等于 ((rowsInCu - numUint64 * 64) / 8)。同时我们排除了最后半字节。
     */
    compute_factors_of_n((unsigned int)rowsInCu, numUint64, numUint8, mapIdx);

    /* 通过将 *delBitmapPtr* 视为 uint64 数组来进行快速比较。*/
    uint64* uint64Item = (uint64*)delBitmapPtr;
    for (unsigned int i = 0; i < numUint64; ++i) {
        if (*uint64Item != 0xFFFFFFFFFFFFFFFF) {
            return false;
        }
        ++uint64Item;
    }

    /* 将剩余部分视为 char 数组来进行比较。*/
    uint8* uint8Item = (uint8*)uint64Item;
    for (unsigned int i = 0; i < numUint8; ++i) {
        if (*uint8Item != 0xFF) {
            return false;
        }
        ++uint8Item;
    }

    /*
     * 如果 (rowsInCu != 8*N)，则必须特殊处理最后一个字节。
     * 我们将使用 *map[]* 直接进行快速比较。
     */
    if (mapIdx != 0) {
        return (*uint8Item == map[mapIdx]);
    }

    /* 没问题，整个 CU 已被删除。 */
    return true;
}

CStore::CudescTupGetMinMaxDatum 函数

CStore::CudescTupGetMinMaxDatum 函数的作用是从 CUDesc 结构中提取并返回最小或最大值的 Datum 表示。该函数针对不同的列属性信息（pColAttr）以及最小或最大值标志（min），处理不同数据类型和大小的数据，并返回一个 Datum 表示。函数还通过 shouldFree 参数返回一个布尔值，指示是否应该释放提取的数据。函数源码如下：（路径：src/gausskernel/storage/cstore/cstore_am.cpp）

/**
 * @Description: 从CUDesc结构中提取并返回最小或最大值的Datum表示。
 *               该函数根据提供的列属性信息，处理不同的数据类型和大小。
 * @param pCudesc: CUDesc结构指针，包含了最小和最大值
 * @param pColAttr: 列属性的指针，描述了列的数据类型和大小
 * @param min: 为true表示提取最小值，为false表示提取最大值
 * @param shouldFree: 返回一个布尔值，指示是否应该释放提取的数据
 * @return: 表示最小或最大值的Datum
 * @See also:
 */
Datum CStore::CudescTupGetMinMaxDatum(
    _in_ CUDesc* pCudesc, _in_ Form_pg_attribute pColAttr, _in_ bool min, _out_ bool* shouldFree)
{
    // 确保CUDesc结构表示了相同的值（即min和max相同）
    Assert(pCudesc->IsSameValCU());
    *shouldFree = false; // 默认情况下不需要释放数据

    char* value = NULL;
    char* dataPtr = min ? pCudesc->cu_min : pCudesc->cu_max; // 根据需要选择最小或最大值的指针
    errno_t rc = EOK;

    if (pColAttr->attbyval) {
        // 情况1：attlen > 0 && attlen <= sizeof(Datum)
        // 数据可以直接按值传递
        return (*(Datum*)dataPtr);
    }

    *shouldFree = true; // 数据需要释放

    if (pColAttr->attlen > (int)sizeof(Datum)) {
        // 情况2：attlen > sizeof(Datum) && attlen <= MIN_MAX_LEN
        Assert(pColAttr->attlen <= MIN_MAX_LEN);
        value = (char*)palloc(pColAttr->attlen); // 为数据分配内存
        rc = memcpy_s(value, pColAttr->attlen, dataPtr, pColAttr->attlen); // 复制数据
        securec_check(rc, "", "");
    } else if (pColAttr->attlen == -1) {
        // 情况3：attlen == -1，包括空字符串（非空字符串）
        Assert((int)dataPtr[0] >= 0 && (int)dataPtr[0] < MIN_MAX_LEN);
        value = (char*)palloc(dataPtr[0] + VARHDRSZ_SHORT); // 为字符串数据分配内存
        SET_VARSIZE_SHORT(value, dataPtr[0] + VARHDRSZ_SHORT); // 设置字符串头部大小
        if (dataPtr[0] > 0) {
            rc = memcpy_s(value + VARHDRSZ_SHORT, dataPtr[0], dataPtr + 1, dataPtr[0]); // 复制字符串数据
            securec_check(rc, "", "");
        }
    } else {
        // 情况4：attlen == -2，包括非空字符串
        Assert((int)dataPtr[0] > 0 && (int)dataPtr[0] < MIN_MAX_LEN);
        Assert(dataPtr[(int)dataPtr[0]] == '\0');
        value = (char*)palloc(dataPtr[0]); // 为字符串数据分配内存
        rc = memcpy_s(value, dataPtr[0], dataPtr + 1, dataPtr[0]); // 复制字符串数据
        securec_check(rc, "", "");
    }

    return PointerGetDatum(value); // 返回表示最小或最大值的Datum
}