执行算子（ColumnTableSample）
- 概述
- [ColumnTableSample 类](#ColumnTableSample 类)
-
- [ColumnTableSample::ColumnTableSample 构造函数](#ColumnTableSample::ColumnTableSample 构造函数)
- [ColumnTableSample::~ColumnTableSample 析构函数](#ColumnTableSample::~ColumnTableSample 析构函数)
- [ExecCStoreScan 函数](#ExecCStoreScan 函数)
- [ColumnTableSample::scanVecSample 函数](#ColumnTableSample::scanVecSample 函数)
- [ColumnTableSample::getMaxOffset 函数](#ColumnTableSample::getMaxOffset 函数)
- [ColumnTableSample::scanBatch 函数](#ColumnTableSample::scanBatch 函数)
- [ColumnTableSample::getBatchBySamples 函数](#ColumnTableSample::getBatchBySamples 函数)
- [ColumnTableSample::resetVecSampleScan 函数](#ColumnTableSample::resetVecSampleScan 函数)
- [BaseTableSample::system_nextsampletuple 函数](#BaseTableSample::system_nextsampletuple 函数)
- 案例
声明 ：本文的部分内容参考了他人的文章。在编写过程中，我们尊重他人的知识产权和学术成果，力求遵循合理使用原则，并在适用的情况下注明引用来源。
本文主要参考了 OpenGauss1.1.0 的开源代码和《OpenGauss数据库源码解析》一书以及相关学习资料。
概述
在先前的学习中，我们在【 OpenGauss源码学习 ------ 列存储（CopyTo）】一文中也学习过 CStore::CStoreScan 成员函数，该函数实现了列式存储表的扫描过程，通过加载压缩单元描述符（CUDesc） 、进行粗略检查 （RoughCheck ）、填充数据批量 （FillVecBatch ）等步骤完成扫描操作。那么 CStore::CStoreScan 和 ExecCStoreScan 函数之间有什么联系吗？
CStore::CStoreScan 和 ExecCStoreScan 函数的区别 主要在于它们所属的上下文和调用方式。这两个函数都用于执行列式存储表的扫描 ，但可能在不同的软件层次上。CStore::CStoreScan ：属于 CStore 类，表明它可能是类的成员函数；而 ExecCStoreScan 函数属于执行器 （Executor ）或执行计划节点 ，表明它可能在查询执行计划的上下文中调用。总的来说，CStore::CStoreScan 可能更关联于存储引擎的具体实现 ，而 ExecCStoreScan 则更可能属于查询执行计划的执行器的一部分。
ColumnTableSample 类
ColumnTableSample 类是用于在列式存储表 中执行采样扫描的实现。其功能包括维护偏移标识 、当前列存储单元标识 以及元组标识向量 等状态信息，提供方法用于重置采样扫描状态 、获取采样数据的批量行数 ，执行批量和向量化的采样扫描操作 ，并获取采样中的最大偏移值 。该类的设计旨在有效地支持列式存储表的采样查询和分析需求。函数源码如下所示：（路径：src/include/executor/nodeSamplescan.h）
cpp
/* ColumnTableSample 类是 BaseTableSample 的子类，用于进行列存储表的抽样扫描。*/
class ColumnTableSample : public BaseTableSample {
private:
uint16* offsetIds; // 存储列的偏移标识数组
uint32 currentCuId; // 当前的列单元（CU）标识
int batchRowCount; // 批次中的行数
VectorBatch* tids; // 存储样本行的标识符
public:
ColumnTableSample(CStoreScanState* scanstate); // 构造函数，接受 CStoreScanState 参数进行初始化
virtual ~ColumnTableSample(); // 虚析构函数，用于释放资源
void resetVecSampleScan(); // 重置抽样扫描的矢量
void getBatchBySamples(VectorBatch* vbout); // 根据样本获取批次数据
ScanValid scanBatch(VectorBatch* batch); // 扫描并填充批次数据
void scanVecSample(VectorBatch* batch); // 扫描抽样矢量数据
void getMaxOffset(); // 获取最大的偏移值
};ColumnTableSample::ColumnTableSample 构造函数
ColumnTableSample::ColumnTableSample 函数是 ColumnTableSample 类的构造函数 ，用于初始化样本扫描参数。在函数中进行了以下操作：
- 为 offsetIds 分配了内存，并将其初始化为 0。
- 创建了一个新的 VectorBatch 对象，用于构造 tids 以获取样本的 VectorBatch。
函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* 描述: 初始化 CStoreScanState 的样本扫描参数。
*
* 参数:
* @in scanstate: CStoreScanState 信息
*
* 返回: void
*/
ColumnTableSample::ColumnTableSample(CStoreScanState* scanstate)
: BaseTableSample(scanstate), currentCuId(0), batchRowCount(0)
{
// 为 offsetIds 分配内存，并初始化为0
offsetIds = (uint16*)palloc0(sizeof(uint16) * BatchMaxSize);
errno_t rc = memset_s(offsetIds, sizeof(uint16) * BatchMaxSize, 0, sizeof(uint16) * BatchMaxSize);
securec_check(rc, "", "");
/* 创建新的 VectorBatch 以构造 tids 以获取样本 VectorBatch。*/
TupleDesc tupdesc = CreateTemplateTupleDesc(1, false);
TupleDescInitEntry(tupdesc, (AttrNumber)1, "tids", INT8OID, -1, 0);
tids = New(CurrentMemoryContext) VectorBatch(CurrentMemoryContext, tupdesc);
}ColumnTableSample::~ColumnTableSample 析构函数
ColumnTableSample::~ColumnTableSample 是 ColumnTableSample 类的析构函数 ，用于释放在构造函数中分配的资源。在函数中进行了以下操作：
- 释放 offsetIds 分配的内存。
- 删除 tids 对象，释放相关资源。
函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
ColumnTableSample::~ColumnTableSample()
{
// 释放 offsetIds 分配的内存
if (offsetIds) {
pfree_ext(offsetIds);
offsetIds = NULL;
}
// 释放 tids 对象
if (tids) {
delete tids;
tids = NULL;
}
}下面，我将按照函数的调用关系来依次介绍 ColumnTableSample 类相关成员函数，函数调用关系如下图所示：
ExecCStoreScan 函数
ExecCStoreScan 函数用于执行列存储表的扫描操作，返回下一个符合条件的向量批次。函数包括了设置运行时键 、处理函数返回集合 、运行列存储扫描 或样本扫描 、检查扫描是否结束 等关键步骤。函数的目的是执行列存储表的顺序扫描 ，返回下一个符合条件的向量批次 。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 执行列存储表的扫描操作，返回下一个符合条件的向量批次。
*
* Parameters:
* @in node: CStoreScanState 信息
*
* Returns: VectorBatch 包含下一个符合条件的元组。
*/
VectorBatch* ExecCStoreScan(CStoreScanState* node)
{
VectorBatch* p_out_batch = NULL; // 输出向量批次
VectorBatch* p_scan_batch = NULL; // 扫描到的向量批次
// 如果有运行时键且尚未设置，进行设置
if (node->m_ScanRunTimeKeysNum && !node->m_ScanRunTimeKeysReady) {
ExecCStoreScanEvalRuntimeKeys(node->ps.ps_ExprContext, node->m_pScanRunTimeKeys, node->m_ScanRunTimeKeysNum);
node->m_ScanRunTimeKeysReady = true;
}
p_out_batch = node->m_pCurrentBatch;
p_scan_batch = node->m_pScanBatch;
// 更新列存储扫描计时标志
node->m_CStore->SetTiming(node);
ExprDoneCond done = ExprSingleResult;
// 处理函数返回集合的情况
if (node->ps.ps_TupFromTlist) {
Assert(node->ps.ps_ProjInfo);
p_out_batch = ExecVecProject(node->ps.ps_ProjInfo, true, &done);
if (p_out_batch->m_rows > 0) {
return p_out_batch;
}
node->ps.ps_TupFromTlist = false;
}
restart:
// 重置向量批次和表达式上下文
p_scan_batch->Reset(true);
p_out_batch->Reset(true);
node->ps.ps_ProjInfo->pi_exprContext->current_row = 0;
// 运行列存储扫描或样本扫描
if (!node->isSampleScan) {
node->m_CStore->RunScan(node, p_scan_batch);
} else {
((ColumnTableSample*)node->sampleScanInfo.tsm_state)->scanVecSample(p_scan_batch);
}
// 检查扫描是否结束且批次为空
if (node->m_CStore->IsEndScan() && p_scan_batch->m_rows == 0) {
// 如果有数据，扫描增量存储表
ScanDeltaStore(node, p_scan_batch, NULL);
if (p_scan_batch->m_rows == 0)
return p_out_batch;
}
// 修复扫描到的向量批次的行数
p_scan_batch->FixRowCount();
// 应用条件和投影操作
p_out_batch = ApplyProjectionAndFilter(node, p_scan_batch, &done);
if (done != ExprEndResult) {
// 如果表达式计算结果不是结束状态
node->ps.ps_TupFromTlist = (done == ExprMultipleResult);
}
// 处理停止查询标志
if (unlikely(executorEarlyStop()))
return NULL;
// 如果输出批次为空，重新开始扫描
if (BatchIsNull(p_out_batch)) {
CHECK_FOR_INTERRUPTS();
goto restart;
}
return p_out_batch;
}其中，可以看到，在代码 ExecCStoreScan 中调用了 CStore::RunScan 函数：
cpp
// 运行列存储扫描或样本扫描
if (!node->isSampleScan) {
node->m_CStore->RunScan(node, p_scan_batch);
} else {
((ColumnTableSample*)node->sampleScanInfo.tsm_state)->scanVecSample(p_scan_batch);
}ColumnTableSample::scanVecSample 函数
ColumnTableSample::scanVecSample 函数是一个用于获取列存储表样本的函数。函数通过状态机 的方式，依次执行获取最大块数（GETMAXBLOCK） 、获取块号（GETBLOCKNO） 、获取最大偏移量（GETMAXOFFSET） 、获取偏移量（GETOFFSET） 、获取数据（GETDATA）的操作。在每个阶段，根据不同的条件 和状态执行 相应的操作，最终将样本数据存储在输出的 VectorBatch 中。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
c
/*
* Description: 获取列存储表的样本 VectoBatch。
*
* Parameters:
* @in pOutBatch: 返回 VectorBatch 的数值
*
* Returns: void
*/
void ColumnTableSample::scanVecSample(VectorBatch* pOutBatch)
{
/* 如果扫描已完成或者百分比值为0，则返回NULL。*/
if ((finished == true) || (vecsampleScanState->sampleScanInfo.sampleType == BERNOULLI_SAMPLE && percent[0] == 0) ||
(vecsampleScanState->sampleScanInfo.sampleType == SYSTEM_SAMPLE && percent[0] == 0) ||
(vecsampleScanState->sampleScanInfo.sampleType == HYBRID_SAMPLE && percent[BERNOULLI_SAMPLE] == 0 &&
percent[SYSTEM_SAMPLE] == 0)) {
return;
}
for (;;) {
CHECK_FOR_INTERRUPTS();
switch (runState) {
case GETMAXBLOCK: {
/* 获取最大CU数目。 */
totalBlockNum = CStoreRelGetCUNumByNow((CStoreScanDesc)vecsampleScanState);
runState = GETBLOCKNO;
elog(DEBUG2,
"获取关系：%s 在 %s 上的 %u 个CUs。",
NameStr(vecsampleScanState->ss_currentRelation->rd_rel->relname),
g_instance.attr.attr_common.PGXCNodeName,
totalBlockNum);
break;
}
case GETBLOCKNO: {
/* 获取随机或序列化的CUId作为当前块。 */
(this->*nextSampleBlock_function)();
if (!BlockNumberIsValid(currentBlock)) {
/* 所有块已经扫描完成。 */
finished = true;
return;
}
currentCuId = currentBlock + FirstCUID + 1;
runState = GETMAXOFFSET;
break;
}
case GETMAXOFFSET: {
getMaxOffset();
if (InvalidOffsetNumber == curBlockMaxoffset) {
runState = GETBLOCKNO;
} else {
runState = GETOFFSET;
}
elog(DEBUG2,
"获取关系：%s 在 %s 上的 CUNo: %u 中的 %d 个元组。",
NameStr(vecsampleScanState->ss_currentRelation->rd_rel->relname),
g_instance.attr.attr_common.PGXCNodeName,
currentBlock,
curBlockMaxoffset);
break;
}
case GETOFFSET: {
(this->*nextSampleTuple_function)();
runState = GETDATA;
break;
}
case GETDATA: {
// 调用 scanBatch 函数获取有效的批次
ScanValid scanState = scanBatch(pOutBatch);
switch (scanState) {
// 如果存在有效数据，继续获取下一行数据
case VALIDDATA: {
runState = GETOFFSET;
return;
}
// 如果没有更多数据，转到获取下一个块的状态
case NEXTDATA: {
runState = GETOFFSET;
break;
}
// 如果块中的数据已经全部扫描完毕，需要获取下一个块
case INVALIDOFFSET: {
runState = GETBLOCKNO;
// 如果上一个批次已经填满，返回上一个批次并获取新的块和批次
if (batchRowCount > 0) {
batchRowCount = 0;
return;
}
break;
}
// 处理其他情况
default: {
break;
}
}
break;
}
default: {
break;
}
}
}
}ColumnTableSample::getMaxOffset 函数
ColumnTableSample::getMaxOffset 函数是用于获取当前块的最大偏移量的函数。在列存储数据库系统中，数据通常以列为单位进行组织，一个列可以被分成多个块 ，每个块包含一定数量的行 。偏移量是指在一个块中某一行的相对位置。函数首先根据当前块号 和列标识符 获取列存储描述符 CUDesc 。然后，通过检查快照规则 和元组状态 ，确定当前块的最大偏移量 。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 获取当前块的最大偏移量。
*
* Parameters: 无
*
* Returns: void
*/
void ColumnTableSample::getMaxOffset()
{
CUDesc cu_desc;
int fstColIdx = 0;
Assert(BlockNumberIsValid(currentBlock));
curBlockMaxoffset = InvalidOffsetNumber;
/* 如果第一列已经被删除，我们应该更改第一列的索引。 */
if (vecsampleScanState->ss_currentRelation->rd_att->attrs[0]->attisdropped) {
fstColIdx = CStoreGetfstColIdx(vecsampleScanState->ss_currentRelation);
}
/*
* 根据 currentCuId 获取列的 CUDesc。
*/
if (vecsampleScanState->m_CStore->GetCUDesc(fstColIdx, currentCuId, &cu_desc, GetActiveSnapshot()) != true) {
return;
}
/*
* 我们尽力保持对行关系获取元组的规则：
* 1). 忽略已死亡的元组
* 2). 忽略最近死亡的元组
* 3). 忽略其他事务中正在插入中的元组
* 4). 忽略我们事务中正在删除中的元组
* 5). 忽略其他事务中正在删除中的元组
* SnapshotNow 可以满足规则 1) 2) 3) 4)，因此在这里使用它。
*/
vecsampleScanState->m_CStore->GetCUDeleteMaskIfNeed(currentCuId, GetActiveSnapshot());
/* 如果在此 CU 单元中所有元组都已删除，则快速退出此循环。 */
if (vecsampleScanState->m_CStore->IsTheWholeCuDeleted(cu_desc.row_count)) {
return;
}
curBlockMaxoffset = cu_desc.row_count;
}ColumnTableSample::scanBatch 函数
ColumnTableSample::scanBatch 函数是用于通过元组 ID 扫描每个偏移量 ，获取样本的 VectorBatch 的函数。函数会检查当前块的偏移量是否为无效值 ，如果是 ，则判断是否有剩余的批次需要处理 ，如果有 ，则调用 getBatchBySamples 处理批次。接着，函数检查当前偏移量对应的行是否为无效行 ，如果不是，则将其添加到当前批次的 offsetIds 数组中。当批次的元组数量达到 BatchMaxSize 时，调用 getBatchBySamples 处理批次，然后清空 offsetIds 数组 。最后，函数根据处理的结果返回相应的标志 。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 扫描每个偏移量，并通过元组ID获取样本的 VectorBatch。
*
* Parameters:
* @in pOutBatch: 返回 VectorBatch 的数值
*
* Returns: ScanValid（用于标识元组是否有效的标志）
*/
ScanValid ColumnTableSample::scanBatch(VectorBatch* pOutBatch)
{
Assert(BlockNumberIsValid(currentBlock));
/* 当前块已经被读取。*/
if (currentOffset == InvalidOffsetNumber) {
if (batchRowCount > 0) {
/*
* 如果到达这里，意味着我们已经用尽了这个 CU 上的元组，
* 现在是时候移到下一个 CU。
*/
getBatchBySamples(pOutBatch);
errno_t rc = memset_s(offsetIds, sizeof(uint16) * BatchMaxSize, 0, sizeof(uint16) * BatchMaxSize);
securec_check(rc, "", "");
}
return INVALIDOFFSET;
}
if (!vecsampleScanState->m_CStore->IsDeadRow(currentCuId, (uint32)currentOffset)) {
elog(DEBUG2,
"获取一个元组 [currentCuId: %u, currentOffset: %u] for 关系: %s 在 %s 上.",
currentCuId,
currentOffset,
NameStr(vecsampleScanState->ss_currentRelation->rd_rel->relname),
g_instance.attr.attr_common.PGXCNodeName);
/* 从 CU 中获取当前行，并填充到向量中，直到完成一个批次。 */
offsetIds[batchRowCount++] = currentOffset;
if (batchRowCount >= BatchMaxSize) {
getBatchBySamples(pOutBatch);
batchRowCount = 0;
errno_t rc = memset_s(offsetIds, sizeof(uint16) * BatchMaxSize, 0, sizeof(uint16) * BatchMaxSize);
securec_check(rc, "", "");
return VALIDDATA;
}
}
return NEXTDATA;
}ColumnTableSample::getBatchBySamples 函数
ColumnTableSample::getBatchBySamples 函数是根据 tids （CuId+offsetId ）获取样本的 VectorBatch 的函数。函数首先重置了 tids 的状 态，然后通过当前 CU 的 CuId 和 offsetIds 构建了 tids 的 VectorBatch 。接着，函数通过 tids 扫描了 VectorBatch ，并将结果存储在输出参数 vbout 中。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 根据 tids（CuId+offsetId）获取样本的 VectorBatch。
*
* Parameters:
* @in state: CStoreScanState 信息
* @in cuId: 当前 CU 的 CuId
* @in maxOffset: 当前 CU 的最大 Offset
* @in offsetIds: 当前 CU 的随机 offsetIds
* @in tids: 通过 cuId 和 offsetIds 构建 tids 的 VectorBatch
* @in vbout: 返回 VectorBatch 的数值
*
* Returns: void
*/
void ColumnTableSample::getBatchBySamples(VectorBatch* vbout)
{
ScalarVector* vec = tids->m_arr;
tids->Reset();
/* 用 CuId 和 offsetId 填充 tids 的 VectorBatch。 */
for (int j = 0; j < batchRowCount; j++) {
/* 我们可以确定这不是死行。 */
vec->m_vals[j] = 0;
ItemPointer itemPtr = (ItemPointer)&vec->m_vals[j];
/* 注意，itemPtr->offset 从 1 开始。 */
ItemPointerSet(itemPtr, currentCuId, offsetIds[j]);
}
vec->m_rows = batchRowCount;
tids->m_rows = vec->m_rows;
/* 通过 tids 扫描 VectorBatch。 */
if (!BatchIsNull(tids)) {
CStoreIndexScanState* indexScanState = makeNode(CStoreIndexScanState);
indexScanState->m_indexOutAttrNo = 0;
vecsampleScanState->m_CStore->ScanByTids(indexScanState, tids, vbout);
vecsampleScanState->m_CStore->ResetLateRead();
}
}ColumnTableSample::resetVecSampleScan 函数
ColumnTableSample::resetVecSampleScan 函数是用于重置 VectoBatch 样本扫描参数的函数。在函数中，将 currentCuId 和 batchRowCount 设置为初始值 ，然后调用 resetSampleScan 函数重置表样本的通用参数 。接着，如果存在 tids 对象 ，将其重置 ；同时，如果存在 offsetIds 数组 ，使用 memset_s 函数将其清零 。这个函数主要用于准备进行下一轮 VectoBatch 样本扫描时的初始状态 。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 重置 VectoBatch 样本扫描参数。
*
* Parameters: 无
*
* Returns: void
*/
void ColumnTableSample::resetVecSampleScan()
{
currentCuId = 0;
batchRowCount = 0;
/* 重置表样本的通用参数。 */
(((ColumnTableSample*)vecsampleScanState->sampleScanInfo.tsm_state)->resetSampleScan)();
if (tids) {
tids->Reset();
}
if (offsetIds) {
errno_t rc = memset_s(offsetIds, sizeof(uint16) * BatchMaxSize, 0, sizeof(uint16) * BatchMaxSize);
securec_check(rc, "", "");
}
}BaseTableSample::system_nextsampletuple 函数
BaseTableSample::system_nextsampletuple 函数是用于获取下一个顺序偏移量的函数。函数首先记录当前偏移量 ，然后将其递增到页面上的下一个可能的偏移量 。如果当前偏移量为无效值 ，则将其设置为第一个偏移量 。接着，如果递增后的偏移量超过了当前块的最大偏移量 ，将其重新设置为无效值 。最后，更新对象的当前偏移量 。这个函数通常在对数据进行顺序扫描时使用，确保按顺序逐个获取数据行的偏移量。函数源码如下所示：（路径：src/gausskernel/runtime/executor/nodeSamplescan.cpp）
cpp
/*
* Description: 获取顺序下一个偏移量。
* Parameters: 无
* Returns: void
*/
void BaseTableSample::system_nextsampletuple()
{
// 记录当前偏移量
OffsetNumber tupoffset = currentOffset;
/* 向页面上的下一个可能的偏移量前进 */
if (tupoffset == InvalidOffsetNumber) {
tupoffset = FirstOffsetNumber;
} else {
tupoffset++;
}
// 如果偏移量超过当前块的最大偏移量，则将其设置为无效值
if (tupoffset > curBlockMaxoffset) {
tupoffset = InvalidOffsetNumber;
}
// 更新当前偏移量
currentOffset = tupoffset;
}案例
下面我们还是以一个案例来调试一下代码吧，首先执行以下 sql 语句：
sql
-- 创建表
CREATE TABLE column_store_table (
id INT,
name VARCHAR(50),
age INT,
salary DECIMAL(10, 2),
email VARCHAR(100)
)WITH (ORIENTATION = COLUMN);
-- 插入数据
INSERT INTO column_store_table VALUES
(1, 'John', 30, 50000.00, 'john@example.com'),
(2, 'Alice', 28, 60000.50, NULL),
(3, 'Bob', NULL, NULL, 'bob@example.com');
-- 执行列存查询操作
select * from column_store_table where id > 1;
- 在 ExecCStoreScan 函数中打上断点。
函数调用关系如下所示：
bash
#0 ExecCStoreScan (node=0x7f15ae082060) at veccstore.cpp:314
#1 0x000000000173425f in VectorEngine (node=0x7f15ae082060) at vecexecutor.cpp:171
#2 0x0000000001687fd5 in ExecVecToRow (state=0x7f15adeea060) at vectortorow.cpp:149
#3 0x000000000159a439 in ExecProcNodeByType (node=0x7f15adeea060) at execProcnode.cpp:677
#4 0x000000000159a8dd in ExecProcNode (node=0x7f15adeea060) at execProcnode.cpp:769
#5 0x0000000001595232 in ExecutePlan (estate=0x7f15b335c060, planstate=0x7f15adeea060, operation=CMD_SELECT, sendTuples=true, numberTuples=0,
direction=ForwardScanDirection, dest=0x7f15b3355d60) at execMain.cpp:2124
#6 0x0000000001591d6a in standard_ExecutorRun (queryDesc=0x7f15b3368c60, direction=ForwardScanDirection, count=0) at execMain.cpp:608
#7 0x000000000139a5d4 in explain_ExecutorRun (queryDesc=0x7f15b3368c60, direction=ForwardScanDirection, count=0) at auto_explain.cpp:116
#8 0x000000000159188f in ExecutorRun (queryDesc=0x7f15b3368c60, direction=ForwardScanDirection, count=0) at execMain.cpp:484
#9 0x000000000147298f in PortalRunSelect (portal=0x7f15adedc060, forward=true, count=0, dest=0x7f15b3355d60) at pquery.cpp:1396
#10 0x0000000001471b5c in PortalRun (portal=0x7f15adedc060, count=9223372036854775807, isTopLevel=true, dest=0x7f15b3355d60, altdest=0x7f15b3355d60,
completionTag=0x7f15abf27f90 "") at pquery.cpp:1134
---Type <return> to continue, or q <return> to quit---相关调试信息如下所示：
bash
(gdb) p *node
$1 = {<ScanState> = {ps = {type = T_CStoreScanState, plan = 0x7f15b9b1a0a0, state = 0x7f15b335c060, instrument = 0x0, targetlist = 0x7f15b9b242d0,
qual = 0x7f15b9b25530, lefttree = 0x0, righttree = 0x0, initPlan = 0x0, subPlan = 0x0, chgParam = 0x0, hbktScanSlot = {currSlot = 0},
ps_ResultTupleSlot = 0x7f15b9b24b98, ps_ExprContext = 0x7f15ae082288, ps_ProjInfo = 0x7f15b9b27e50, ps_TupFromTlist = false, vectorized = true,
nodeContext = 0x7f15adee0060, earlyFreed = false, stubType = 0 '\000', jitted_vectarget = 0x0, plan_issues = 0x0, recursive_reset = false,
qual_is_inited = false, ps_rownum = 0}, ss_currentRelation = 0x7f15adff8390, ss_currentScanDesc = 0x0, ss_ScanTupleSlot = 0x7f15b9b24d08,
ss_ReScan = false, ss_currentPartition = 0x0, isPartTbl = false, currentSlot = 0, partScanDirection = NoMovementScanDirection, partitions = 0x0,
lockMode = 0, runTimeParamPredicates = 0x0, runTimePredicatesReady = false, is_scan_end = false, ss_scanaccessor = 0x0, part_id = 0, startPartitionId = 0,
endPartitionId = 0, rangeScanInRedis = {isRangeScanInRedis = 0 '\000', sliceTotal = 0 '\000', sliceIndex = 0 '\000'}, isSampleScan = false,
sampleScanInfo = {args = 0x0, repeatable = 0x0, sampleType = SYSTEM_SAMPLE, tsm_state = 0x0}, ScanNextMtd = 0x0}, ss_currentDeltaRelation = 0x7f15adffb050,
ss_partition_parent = 0x0, ss_currentDeltaScanDesc = 0x7f15b8289060, ss_deltaScan = false, ss_deltaScanEnd = false, m_pScanBatch = 0x7f15b305b3d0,
m_pCurrentBatch = 0x7f15b9b25b20, m_pScanRunTimeKeys = 0x0, m_ScanRunTimeKeysNum = 0, m_ScanRunTimeKeysReady = false, m_CStore = 0x7f15b31f54f0,
csss_ScanKeys = 0x7f15b31f50c8, csss_NumScanKeys = 1, m_fSimpleMap = true, m_fUseColumnRef = false, jitted_vecqual = 0x0, m_isReplicaTable = false}
(gdb) p *p_out_batch
$2 = {<BaseObject> = {<No data fields>}, m_rows = 0, m_cols = 5, m_checkSel = false, m_sel = 0x7f15b9b25b88, m_arr = 0x7f15b2ddbdb0, m_sysColumns = 0x0,
m_pCompressBuf = 0x0}
(gdb) p *p_scan_batch
$3 = {<BaseObject> = {<No data fields>}, m_rows = 0, m_cols = 5, m_checkSel = false, m_sel = 0x7f15b305b438, m_arr = 0x7f15b9b27c30, m_sysColumns = 0x0,
m_pCompressBuf = 0x0}在这里，执行 select * from column_store_table where id > 1; 后 ExecCStoreScan 函数会调用 CStore::RunScan 对列存表进行扫描。这里，我们可以使用如下 SQL 来限制表扫描的范围：SELECT * FROM column_store_table TABLESAMPLE SYSTEM (10);
- 执行样本表扫描。
执行 SELECT * FROM column_store_table TABLESAMPLE SYSTEM (10); 后，可以看到ExecCStoreScan 函数会调用 ColumnTableSample::scanVecSample 函数进行样本表扫描。
bash
│354 if (!node->isSampleScan) { │
│355 node->m_CStore->RunScan(node, p_scan_batch); │
│356 } else { │
│357 /* │
│358 * Sample scan for column table. │
│359 */ │
>│360 (((ColumnTableSample*)node->sampleScanInfo.tsm_state)->scanVecSample)(p_scan_batch); │
│361 } │ 相关调试信息如下所示：
bash
(gdb) p * pOutBatch
$1 = {<BaseObject> = {<No data fields>}, m_rows = 0, m_cols = 5, m_checkSel = false, m_sel = 0x7f15b305c1c8, m_arr = 0x7f15b2dd3db0, m_sysColumns = 0x0,
m_pCompressBuf = 0x0}
(gdb) p totalBlockNum
$2 = 2
(gdb) p blockindex
$3 = 2
(gdb) p p_scan_batch->m_rows
$4 = 0这里由于 TABLESAMPLE SYSTEM (10) 表示从表中随机抽取约 10% 的行，所以当执行到如下判断时就会直接 return。
cpp
if (!BlockNumberIsValid(currentBlock)) {
/* 所有块已经扫描完成。 */
finished = true;
return;
}为了调试 ColumnTableSample::getMaxOffset 函数，我们这里修改 SQL 语句如下：SELECT * FROM column_store_table TABLESAMPLE SYSTEM (60);
- 步入 getMaxOffset 函数。
相关调试信息如下所示：
cpp
(gdb) p curBlockMaxoffset
$1 = 0
(gdb) p cu_desc.row_count
$2 = 1
(gdb) p curBlockMaxoffset
$3 = 1ColumnTableSample::getMaxOffset 函数的目的是获取当前块（Column Unit，CU ）的最大偏移量。在列存储数据库系统中，数据通常以列为单位进行组织，一个列可以被分成多个块，每个块包含一定数量的行 。偏移量是指在一个块中某一行的相对位置。
举个具体例子：假设有一个列存储表 sample_table 包含以下数据：
sql
id | name | value
---|-------|-------
1 | John | 10
2 | Alice | 20
3 | Bob | 15假设该表按照 value 列 进行列存储 ，每个 Column Unit （CU ）包含 2 行数据 。现在，我们来模拟一下 ColumnTableSample::getMaxOffset 函数的执行：
- 获取列存储描述符： 假设当前块的 CuId 为 1 ，即第一个 CU 。通过 CuId 获取列存储描述符 ，该描述符包含有关该列的元数据信息，例如每个 CU 中的行数。
- 检查行是否被删除：假设当前块的第一行数据被删除 ，但其他行有效 。函数检查列存储描述符 ，并确定第一行已被删除。
- 确定最大偏移量：由于第一行已被删除，最大偏移量将是第二行 ，因此最大偏移量为 2。
这样，在进行后续的列存储扫描 时，系统将从第二行开始扫描 ，忽略已被删除的第一行，从而避免不必要的数据读取和处理。这种方式有助于提高查询性能，特别是当表中包含大量被删除或不需要的数据时。
- 进入 GETDATA 状态。
相关调试信息如下所示：
bash
(gdb) p scanState
$1 = NEXTDATA返回 NEXTDATA 状态，这通常表示当前块中的数据已经全部扫描完毕，需要获取下一个块的数据。使用 (this->*nextSampleTuple_function)() 调用 BaseTableSample::system_nextsampletuple 函数获取下一个顺序偏移量的函数 。
相关调试信息如下所示：
bash
(gdb) p currentOffset
$1 = 1
(gdb) p curBlockMaxoffset
$2 = 1
(gdb) p tupoffset
$30 = 2
# 执行 if (tupoffset > curBlockMaxoffset) 后
(gdb) p tupoffset
$4 = 0
# 返回下一个符合条件的向量批次
(gdb) p *p_out_batch
$5 = {<BaseObject> = {<No data fields>}, m_rows = 1, m_cols = 5, m_checkSel = false, m_sel = 0x7f15b30505a0, m_arr = 0x7f15b9b27d58, m_sysColumns = 0x0,
m_pCompressBuf = 0x0}