【OpenGauss源码学习 —— 执行算子（SeqScan算子）】

已于 2024-02-27 14:14:23 修改
阅读量1k 收藏 1
点赞数 2
分类专栏： OpenGauss 数据库 文章标签： gaussdb 数据库
于 2023-08-09 17:35:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43899283/article/details/132184756
版权

执行算子（SeqScan算子）

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

执行算子概述

  在OpenGauss中，执行算子是用于执行数据库查询计划的基本操作单元。执行算子负责处理查询计划中的每个节点，执行各种操作，从而实现用户查询的功能。
  执行算子模块包含多种计划执行算子，是计划执行的独立单元，用于实现具体的计划动作。执行计划包含4类算子，分别是控制算子、扫描算子、物化算子和连接算子。这些算子统一使用节点（node）表示，具有统一的接口，执行流程采用递归模式。整体执行流程是：首先根据计划节点的类型初始化状态节点（函数名为“ExecInit+算子名”），然后再回调执行函数（函数名为“Exec+算子名”），最后是清理状态节点（函数名为“ExecEnd+算子名”）。本文主要介绍扫描算子，因为最近在做这方面的工作。
  执行算子类型如下所示：

算子类型说 明
控制算子处理特殊执行流程，如Union语句
扫描算子用于扫描表对象，从表中获取数据
物化算子缓存中间执行结果到临时存储
连接算子用于实现SQL中的各类连接操作，通常包含 nested loop join、bash join、merge-sort join等

扫描算子

  扫描算子用于表、结果集、链表子查询等结果遍历，每次获取一条元组作为上层节点的输入。控制算子中的 BitmapAnd/BitmapOr 函数所需的位图与扫描算子（索引扫描算子）密切相关。主要包括顺序扫描（SeqScan）、索引扫描（IndexScan）、位图扫描（BitmapHeapScan）、位图索引扫描（BitmapIndexScan）、元组TID扫描（TIDScan）、子查询扫描（SubqueryScan）、函数扫描（FunctionScan）等。扫描算子如下表所示。

算子名称说 明
SeqScan算子用于扫描基础表
IndexScan算子对表的扫描使用索引加速元组获取
BitmapIndexScan算子通过位图索引做扫描操作
BitMapHeapScan算子通过位图获取实际元组
TIDScan算子遍历元组的物理存储位置获取一个元组
SubqueryScan算子子查询生成的子执行计划
FunctionScan算子用于从函数返回的数据集中获取元组
ValuesScan算子用于处理“Values（···），（···），···”类型语句，从值列表中输出元组
CteScan算子用于处理With表达式对应的子查询
WorkTableScan算子用于递归工作表元组输出
PartIteratorScan算子用于支持分区表的 wise join加粗样式

SeqScan算子

  我们首先来看一下SeqScan算子，SeqScan 算子是最基本的扫描算子，对应 SeqScan 执行节点，对应的代码源文件是“src/gausskernel/runtime/executor/nodeSeqScan.cpp”，用于对基础表做顺序扫描。算子对应的主要函数如下表所示。

主要函数说 明
ExecInitSeqScan初始化SeqScan状态节点
ExecSeqScan迭代获取元组
ExecEndSeqScan清理SeqScan状态节点
ExecSeqMarkPos标记扫描位置
ExecSeqRestrPos重置扫描位置
ExecReScanSeqScan重置SeqScan
InitScanRelation初始化扫描表

  下面我们以一个案例来调试一下代码吧，首先执行sql语句：

postgres=# create table t2 (id int not null, name varchar);
CREATE TABLE
postgres=# insert into t2 values(1, 'Postgres');
INSERT 0 1
postgres=# insert into t2 values(2, 'OpenGauss');
INSERT 0 1
postgres=# select * from t2;

ExecInitSeqScan函数

  函数 ExecInitSeqScan 是 OpenGauss 数据库中用于初始化顺序扫描算子（SeqScan）的函数。它是执行计划中实际执行算子的初始化过程，用于准备执行算子所需的状态和资源。在函数 ExecInitSeqScan 中打上断点进行调试
在这里插入图片描述
  我们来解读一下 ExecInitSeqScan 函数的源码吧：（路径：src/gausskernel/runtime/executor/nodeSeqscan.cpp）
  在ExecInitSeqScan 函数中，有三个入参SeqScan* node, EState* estate, int eflags，下面分别来解释一下他们是什么：

  1. SeqScan* node：这是一个指向查询计划节点的指针，表示要初始化的顺序扫描算子节点。这个节点包含了构建查询计划所需的信息，如表信息、谓词条件等。
  2. EState* estate：这是一个指向执行状态的指针，表示当前查询的执行状态。执行状态包含了在查询执行过程中需要的各种上下文信息，如内存管理、参数信息等。
  3. int eflags：这是一个标志位，表示执行的选项和参数。可以用来控制执行算子的行为，如是否要在执行过程中收集统计信息等。
/* ----------------------------------------------------------------
 *		ExecInitSeqScan
 * ----------------------------------------------------------------
 */
SeqScanState* ExecInitSeqScan(SeqScan* node, EState* estate, int eflags)
{
    TableSampleClause* tsc = NULL; /* 表样本子句 */

    /*
     * 曾经有可能在 SeqScan 的 outerPlan 中，但现在不再允许。
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);

    /*
     * 创建状态结构体
     */
    SeqScanState* scanstate = makeNode(SeqScanState);

    scanstate->ps.plan = (Plan*)node; /* 计划节点 */
    scanstate->ps.state = estate; /* 执行状态 */
    scanstate->isPartTbl = node->isPartTbl; /* 是否是分区表 */
    scanstate->currentSlot = 0; /* 当前迭代位置 */
    scanstate->partScanDirection = node->partScanDirection; /* 分区扫描方向 */
    scanstate->rangeScanInRedis = {false, 0, 0}; /* 分布时间的范围扫描 */

    if (!node->tablesample) {
        scanstate->isSampleScan = false; /* 是否是表样本扫描 */
    } else {
        scanstate->isSampleScan = true;
        tsc = node->tablesample;
    }

    /*
     * 杂项初始化
     *
     * 为节点创建表达式上下文
     */
    ExecAssignExprContext(estate, &scanstate->ps);

    /*
     * 初始化子表达式
     */
    scanstate->ps.targetlist = (List*)ExecInitExpr((Expr*)node->plan.targetlist, (PlanState*)scanstate);
	
	// 判断是否需要进行表样本扫描，如果 node 结构中的 tablesample 成员非空，就说明需要进行表样本扫描
    if (node->tablesample) {
        scanstate->sampleScanInfo.args = (List*)ExecInitExpr((Expr*)tsc->args, (PlanState*)scanstate);
        scanstate->sampleScanInfo.repeatable = ExecInitExpr(tsc->repeatable, (PlanState*)scanstate);

        scanstate->sampleScanInfo.sampleType = tsc->sampleType; //设置表样本类型 sampleType
        /*
         * 初始化 RowTableSample
         */
        if (scanstate->sampleScanInfo.tsm_state == NULL) {
            scanstate->sampleScanInfo.tsm_state = New(CurrentMemoryContext) RowTableSample(scanstate);
        }
    }

    /*
     * 元组表初始化
     */
    ExecInitResultTupleSlot(estate, &scanstate->ps);
    ExecInitScanTupleSlot(estate, scanstate);

    InitScanRelation(scanstate, estate);
    ADIO_RUN()
    {
        /* 添加预取相关信息 */
        scanstate->ss_scanaccessor = (SeqScanAccessor*)palloc(sizeof(SeqScanAccessor));
        SeqScan_Init(scanstate->ss_currentScanDesc, scanstate->ss_scanaccessor, scanstate->ss_currentRelation);
    }
    ADIO_END();

    /*
     * 初始化扫描关系
     */
    // 调用InitSeqNextMtd函数初始化ScanState结构体中的ScanNextMtd函数指针，用于执行具体的扫描操作。
    InitSeqNextMtd(node, scanstate);
    // 判断是否存在扫描描述符
    if (IsValidScanDesc(scanstate->ss_currentScanDesc)) {
    	// 初始化并行扫描的参数，包括指定的并行度、分区扫描方向等
        scan_handler_tbl_init_parallel_seqscan(scanstate->ss_currentScanDesc, 
            scanstate->ps.plan->dop, scanstate->partScanDirection);
    } else {
        scanstate->ps.stubType = PST_Scan;
    }

	// 表示扫描结果并不是直接从目标列表（即查询的目标列）中获取的，而是从其他地方获取的
    scanstate->ps.ps_TupFromTlist = false;

    /*
     * 初始化结果元组类型和投影信息。
     */
    ExecAssignResultTypeFromTL(
            &scanstate->ps,
            scanstate->ss_currentRelation->rd_tam_type);

    ExecAssignScanProjectionInfo(scanstate);

    return scanstate;
}

  以为下SeqScan* node的结构，可以看到，执行节点（Node）中的 type 字段的值为 T_SeqScan ，这表示这个执行节点是一个顺序扫描（Sequential Scan）节点。
在这里插入图片描述
  以为下EState* estate的结构，而 EState* estate 中的 type 字段的值为 T_EState，它表示这个结构体是一个执行状态（Execution State）的对象。在数据库查询执行过程中，EState 存储了查询执行过程中的中间状态。
在这里插入图片描述
  可以看到，“ExecInitSeqScan” 函数的返回类型是 “SeqScanState” 结构，SeqScanState 结构体是 OpenGauss 数据库中用于执行顺序扫描操作的状态信息的结构体。在数据库查询执行过程中，每个执行节点都会有相应的状态结构体来存储节点执行过程中的中间状态、结果等信息。对于顺序扫描操作，就是使用 SeqScanState 结构体来存储顺序扫描的状态信息。
  SeqScanState 结构体定义如下：（路径：src/include/nodes/execnodes.h）

typedef struct ScanState {
    PlanState ps;                     /* 计划状态，首字段是NodeTag */
    Relation ss_currentRelation;      /* 当前关系 */
    TableScanDesc ss_currentScanDesc; /* 当前扫描描述符 */
    TupleTableSlot* ss_ScanTupleSlot;  /* 扫描元组插槽 */
    bool ss_ReScan;                   /* 是否重扫描 */
    Relation ss_currentPartition;     /* 当前分区关系 */
    bool isPartTbl;                   /* 是否是分区表 */
    int currentSlot;                  /* 当前迭代位置 */
    ScanDirection partScanDirection;  /* 分区扫描方向 */
    List* partitions;                 /* 分区列表 */
    LOCKMODE lockMode;                /* 锁模式 */
    List* runTimeParamPredicates;     /* 运行时参数谓词 */
    bool runTimePredicatesReady;      /* 运行时谓词是否准备好 */
    bool is_scan_end;                 /* 是否结束扫描，用于扫描使用信息性约束的情况 */
    SeqScanAccessor* ss_scanaccessor; /* 预取相关 */
    int part_id;                      /* 分区ID */
    int startPartitionId;             /* 并行线程的起始分区ID */
    int endPartitionId;               /* 并行线程的结束分区ID */
    RangeScanInRedis rangeScanInRedis; /* 是否为分布时间的范围扫描 */
    bool isSampleScan;                /* 是否是表样本扫描 */
    SampleScanParams sampleScanInfo;  /* TABLESAMPLE 参数，包括类型/种子/可重复性 */
    ExecScanAccessMtd ScanNextMtd;    /* 扫描下一个方法 */
} ScanState;

/*
 * SeqScan uses a bare ScanState as its state node, since it needs
 * no additional fields.
 */
typedef ScanState SeqScanState;

  其中，ExecInitSeqScan 函数中的这段代码是在判断是否需要进行表样本扫描，如果 node 结构中的 tablesample 成员非空，就说明需要进行表样本扫描。

    if (node->tablesample) {
        scanstate->sampleScanInfo.args = (List*)ExecInitExpr((Expr*)tsc->args, (PlanState*)scanstate);
        scanstate->sampleScanInfo.repeatable = ExecInitExpr(tsc->repeatable, (PlanState*)scanstate);

        scanstate->sampleScanInfo.sampleType = tsc->sampleType; //设置表样本类型 sampleType
        /*
         * 初始化 RowTableSample
         */
        if (scanstate->sampleScanInfo.tsm_state == NULL) {
            scanstate->sampleScanInfo.tsm_state = New(CurrentMemoryContext) RowTableSample(scanstate);
        }
    }

注：什么是表样本扫描？
  表样本扫描（Table Sample Scan）是一种数据库查询优化技术，用于在大型表中进行随机或者有规律的采样，以减少查询的执行时间。它适用于那些数据量庞大的表，通过从表中抽取一小部分数据进行查询，可以在不影响查询结果准确性的前提下，显著减少查询所需的时间和资源消耗。

InitScanRelation函数

  接着，进入到 InitScanRelation 函数中进行初始化扫描表。InitScanRelation 函数源码如下：（路径：src/gausskernel/runtime/executor/nodeSeqscan.cpp）

/* ----------------------------------------------------------------
 *		InitScanRelation
 *
 *		此函数对扫描关系和扫描的子计划进行初始化。
 * ----------------------------------------------------------------
 */
void InitScanRelation(SeqScanState* node, EState* estate)
{
    Relation current_relation;                      // 当前关系
    Relation current_part_rel = NULL;               // 当前分区关系
    SeqScan* plan = NULL;                           // SeqScan计划节点
    bool is_target_rel = false;                     // 是否为目标关系
    LOCKMODE lockmode = AccessShareLock;            // 锁模式
    TableScanDesc current_scan_desc = NULL;         // 当前扫描描述
	
	// 判断当前扫描操作是否针对目标关系（即是否用于更新、删除等操作的目标表）
    is_target_rel = ExecRelationIsTargetRelation(estate, ((SeqScan*)node->ps.plan)->scanrelid);

    /*
     * 从范围表的第scanrelid项获取关系对象id，打开该关系并在其上获取适当的锁。
     */
    current_relation = ExecOpenScanRelation(estate, ((SeqScan*)node->ps.plan)->scanrelid);

    /*
     * 元组表初始化
     */
    ExecInitResultTupleSlot(estate, &node->ps, current_relation->rd_tam_type);
    ExecInitScanTupleSlot(estate, node, current_relation->rd_tam_type);

	// 判断当前查询是否针对分区表（partitioned table）进行的。
	// node->isPartTbl 是一个标志，用于指示当前查询是否是针对一个分区表。
    if (!node->isPartTbl) {
        /* 为redis添加限制条件 */
        // 初始化表扫描的描述符（TableScanDesc），以便开始执行表的扫描操作。
        current_scan_desc = InitBeginScan(node, current_relation);
    } else {
    	// 将节点的计划部分转换为SeqScan类型，以便访问相关属性
        plan = (SeqScan*)node->ps.plan;

        /* 初始化分区列表 */
        node->partitions = NULL;
		
		// 如果当前关系不是目标关系，则将锁模式设置为AccessShareLock
        if (!is_target_rel) {
            lockmode = AccessShareLock;
        } else {
            switch (estate->es_plannedstmt->commandType) {
                case CMD_UPDATE:
                case CMD_DELETE:
                case CMD_MERGE:
                    lockmode = RowExclusiveLock;
                    break;

                case CMD_SELECT:
                    lockmode = AccessShareLock;
                    break;

                default:
                    ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OPERATION),
                            errmodule(MOD_EXECUTOR),
                            errmsg("无效操作 %d 用于序列扫描的分区，允许的操作为 UPDATE/DELETE/SELECT",
                                estate->es_plannedstmt->commandType)));
                    break;
            }
        }
        node->lockMode = lockmode;
        /* 生成node->partitions（如果存在） */
        if (plan->itrs > 0) { // 如果有分区迭代数
            Partition part = NULL;
            PruningResult* resultPlan = NULL;
			
			// 如果分区裁剪信息中的表达式不为空，获取分区信息
            if (plan->pruningInfo->expr != NULL) {
                resultPlan = GetPartitionInfo(plan->pruningInfo, estate, current_relation);
            } else {
                resultPlan = plan->pruningInfo;
            }

            ListCell* cell = NULL;
            List* part_seqs = resultPlan->ls_rangeSelectedPartitions;

			// 遍历选中的分区序号
            foreach (cell, part_seqs) {
                Oid tablepartitionid = InvalidOid;
                int partSeq = lfirst_int(cell);

				// 根据序号获取分区的Oid
                tablepartitionid = getPartitionOidFromSequence(current_relation, partSeq);
                // 打开分区
                part = partitionOpen(current_relation, tablepartitionid, lockmode);
                // 将打开的分区加入到分区列表中
                node->partitions = lappend(node->partitions, part);
            }
            // 设置分区数量
            if (resultPlan->ls_rangeSelectedPartitions != NULL) {
                node->part_id = resultPlan->ls_rangeSelectedPartitions->length;
            } else {
                node->part_id = 0;
            }
        }

		// 如果有分区
        if (node->partitions != NIL) {
            /* 构造第一个分区的HeapScanDesc */
            // 获取第一个分区
            Partition currentPart = (Partition)list_nth(node->partitions, 0);
            // 获取分区关系
            current_part_rel = partitionGetRelation(current_relation, currentPart);
            // 设置当前分区关系
            node->ss_currentPartition = current_part_rel;

            /* 为redis添加限制条件 */
            // 初始化第一个分区的扫描描述符
            current_scan_desc = InitBeginScan(node, current_part_rel);
        } else {
        	// 如果没有分区，则设置当前分区为NULL
            node->ss_currentPartition = NULL;
            // 初始化扫描条件
            node->ps.qual = (List*)ExecInitExpr((Expr*)node->ps.plan->qual, (PlanState*)&node->ps);
        }
    }
    // 将当前正在扫描的关系对象（表）赋值给SeqScanState结构体中的ss_currentRelation成员变量，以表示当前扫描的是哪个关系。
    node->ss_currentRelation = current_relation;
    // 将扫描描述符赋值给SeqScanState结构体中的ss_currentScanDesc成员变量，以便后续的扫描操作可以使用该描述符。
    node->ss_currentScanDesc = current_scan_desc;

	// 对扫描到的数据进行正确的解析和存储
    ExecAssignScanType(node, RelationGetDescr(current_relation));
}

  在上述代码中，ExecRelationIsTargetRelation 函数作用是判断当前扫描操作是否针对目标关系（即是否用于更新、删除等操作的目标表）。ExecRelationIsTargetRelation 会检查给定的扫描计划节点是否是一个目标关系，如果是的话返回true，否则返回false。这里打印结果为false，表示不是一个目标关系。
在这里插入图片描述

注解：在数据库操作中，一个目标关系通常是指执行更新（UPDATE）、删除（DELETE）或插入（INSERT）等修改数据操作的表。目标关系是被操作的主要表，对其进行的修改操作会直接影响到表中的数据。而非目标关系则是在操作过程中可能涉及到的其他表，但这些表不是直接受到操作影响的对象。
  在本案例中，执行 SQL 查询语句 SELECT * FROM t2; 时，如果查询的是表 t2 并且没有进行更新、删除等修改操作，那么这条查询语句并不会修改表的数据，因此表 t2 就不是一个目标关系。因此打印结果为false。

  而 InitBeginScan(node, current_relation) 函数作用是初始化表扫描的描述符（TableScanDesc），以便开始执行表的扫描操作。具体来说，它会根据传入的参数 node 和 current_relation ，生成一个用于表扫描的描述符。这个描述符包含了扫描相关的信息，比如扫描的表、锁模式等。然后，它将这个描述符返回，以便后续的表扫描操作可以使用。
  在这段代码中，如果 node 不是分区表（即 node->isPartTbl 为 false），则调用 InitBeginScan 来初始化扫描描述符，并将结果赋值给current_scan_desc。这意味着这段代码是在非分区表的情况下初始化表扫描描述符。如果是分区表，就不执行这个操作。
  源码及注释如下：（路径：src/gausskernel/runtime/executor/nodeSeqscan.cpp）

static TableScanDesc InitBeginScan(SeqScanState* node, Relation current_relation)
{
    // 声明一个变量来存储表扫描描述符
    TableScanDesc current_scan_desc = NULL;

    // 如果不是表样本扫描
    if (!node->isSampleScan) {
        // 调用scan_handler_tbl_beginscan函数来初始化表扫描描述符
        // 参数包括要扫描的关系、当前事务的快照、初始块号、分布式查询所需的信息，以及扫描状态
        current_scan_desc = scan_handler_tbl_beginscan(current_relation, node->ps.state->es_snapshot, 0, NULL, (ScanState*)node);
    } else {
        // 如果是表样本扫描，则调用InitSampleScanDesc函数来初始化表样本扫描描述符
        current_scan_desc = InitSampleScanDesc((ScanState*)node, current_relation);
    }

    // 返回初始化后的表扫描描述符
    return current_scan_desc;
}

ExecSeqScan函数

  ExecSeqScan 函数是 OpenGauss 中用于执行序列扫描（Sequential Scan）操作的函数。它执行基于序列扫描的查询计划，获取满足扫描条件的数据，并将结果放入一个元组表槽（TupleTableSlot）中返回。
  其函数调用关系如下：
在这里插入图片描述
   ExecSeqScan 函数实际上是通过通用的扫描函数 ExecScan 来执行具体的序列扫描操作。源码如下：（路径：src/gausskernel/runtime/executor/nodeSeqscan.cpp）

/* ----------------------------------------------------------------
 *		ExecSeqScan(node)
 *
 *		Scans the relation sequentially and returns the next qualifying
 *		tuple.
 *		We call the ExecScan() routine and pass it the appropriate
 *		access method functions.
 * ----------------------------------------------------------------
 */
TupleTableSlot* ExecSeqScan(SeqScanState* node)
{
    return ExecScan((ScanState*)node, node->ScanNextMtd, (ExecScanRecheckMtd)SeqRecheck);
}

  其三个入参的描述如下所示：

  1. node： SeqScanState* 类型，表示序列扫描操作的状态信息，其中包含了查询计划的相关信息以及当前扫描的状态。
  2. node->ScanNextMtd： 是一个函数指针，指向具体的序列扫描操作的实现函数，用于获取下一个满足条件的元组。
  3. (ExecScanRecheckMtd)SeqRecheck： 一个函数指针，指向重新检查操作的函数，用于在扫描过程中需要重新检查的情况下执行。

  TupleTableSlot 结构体是在数据库查询执行过程中用于存储元组数据的数据结构。它是一个用于临时存储从表中检索到的数据行（元组）的容器，通常在查询执行的不同阶段中用于传递和处理数据。来看一看 TupleTableSlot 结构体长什么样吧：（路径：src/include/executor/tuptable.h）

typedef struct TupleTableSlot {
    NodeTag type;                  /* 节点类型，用于标识数据结构类型 */
    bool tts_isempty;              /* true = 槽为空 */
    bool tts_shouldFree;           /* 是否应该释放 tts_tuple 内存？ */
    bool tts_shouldFreeMin;        /* 是否应该释放 tts_mintuple 内存？ */
    bool tts_slow;                 /* 用于 slot_deform_tuple 的保存状态 */

    Tuple tts_tuple;               /* 物理元组，如果是虚拟的则为 NULL */

#ifdef PGXC
    /*
     * PGXC 扩展，用于支持从远程 Datanode 发送的元组。
     */
    char* tts_dataRow;             /* DataRow 格式的元组数据 */
    int tts_dataLen;               /* 数据行的实际长度 */
    bool tts_shouldFreeRow;        /* 是否应该释放 tts_dataRow 内存？ */
    struct AttInMetadata* tts_attinmeta; /* 存储从 DataRow 中提取值所需的信息 */
    Oid tts_xcnodeoid;             /* 从哪个节点获取的数据行的 Oid */
    MemoryContext tts_per_tuple_mcxt;
#endif
    TupleDesc tts_tupleDescriptor; /* 槽的元组描述 */
    MemoryContext tts_mcxt;        /* 槽本身所在的内存上下文 */
    Buffer tts_buffer;             /* 元组的缓冲区，如果没有则为 InvalidBuffer */
    int tts_nvalid;                /* tts_values 中的有效值数 */
    Datum* tts_values;             /* 当前每个属性的值 */
    bool* tts_isnull;              /* 当前每个属性的是否为 NULL 的标志 */
    MinimalTuple tts_mintuple;     /* 最小元组，如果没有则为 NULL */
    HeapTupleData tts_minhdr;      /* 仅用于最小元组的情况下的工作空间 */
    long tts_off;                  /* 用于 slot_deform_tuple 的保存状态 */
    long tts_meta_off;             /* 用于 slot_deform_cmpr_tuple 的保存状态 */
    TableAmType tts_tupslotTableAm; /* 槽的元组表类型 */
} TupleTableSlot;

  调试信息如下：
在这里插入图片描述

  其中，TupleTableSlot 结构体中的属性 tts_values 可以用于存储元组的具体值。这是一个指向 Datum 数组的指针，其中每个元素对应于元组的每个属性的值。在 PostgreSQL 中，Datum 是一个通用的数据类型，可以表示各种数据类型的值。
  tts_isnull 是一个 bool 数组的指针，用于标识对应属性是否为 NULL。如果 tts_isnull[i] 为 true，表示属性值是 NULL；如果为 false，则表示属性值不是 NULL。
  这两个数组一起，构成了一个完整的元组的值和 NULL 信息的表示。通过遍历 tts_values 数组和 tts_isnull 数组，可以访问元组的每个属性的值和是否为 NULL 的信息。

不理解？？没关系，来看一个案例吧：

  假设有一个关系表 students 包含以下几个属性：student_id（整数）、name（字符串）、age（整数）和 grade（字符串）。我们可以使用 TupleTableSlot 结构体来表示从该表中获取的元组。
  假设我们从 students 表中获取了一个元组，具体的值如下：

属性值
student_id101
nameAlice
age25
gradeA

  我们可以将这个元组的值存储在 TupleTableSlot 结构体的 tts_values 和 tts_isnull 数组中，以便后续处理。具体表示如下：

tts_values 数组：

索引值
索引 0101（student_id）
索引 1Alice（name）
索引 225（age）
索引 3A（grade）

tts_isnull 数组：

索引值
索引 0false（student_id 不为 NULL）
索引 1false（name 不为 NULL）
索引 2false（age 不为 NULL）
索引 3false（grade 不为 NULL）

  通过这两个数组，我们可以知道元组的每个属性的值和是否为 NULL，进而在执行操作时进行处理和判断。

  ExecScan 函数源码如下：（路径：src/gausskernel/runtime/executor/execScan.cpp）

/* ----------------------------------------------------------------
 *		ExecScan
 *
 *		使用指定的 '访问方法' 扫描关系，根据全局变量 ExecDirection 返回下一个符合条件的元组。
 *		访问方法返回下一个元组，execScan() 负责将返回的元组与限定条件进行检查。
 *
 *		还必须提供一个 '重新检查方法'，它可以检查关系的任意元组是否符合实现在访问方法内部的任何限定条件。
 *
 *		条件：
 *		  -- AMI 维护的 "游标" 定位在之前返回的元组。
 *
 *		初始状态：
 *		  -- 指定的关系已打开进行扫描，以便 "游标" 定位在第一个符合条件的元组之前。
 * ----------------------------------------------------------------
 */
TupleTableSlot* ExecScan(ScanState* node, ExecScanAccessMtd access_mtd, /* 返回元组的函数 */
    ExecScanRecheckMtd recheck_mtd)
{
    ExprContext* econtext = NULL;  /* 表达式计算上下文 */
    List* qual = NIL;              /* 限定条件 */
    ProjectionInfo* proj_info = NULL;  /* 投影信息 */
    ExprDoneCond is_done;          /* 判断投影是否结束的标志 */
    TupleTableSlot* result_slot = NULL;  /* 存储结果的槽 */

    if (node->isPartTbl && !PointerIsValid(node->partitions))
        return NULL;

    /*
     * 获取来自节点的数据
     */
    qual = node->ps.qual;
    proj_info = node->ps.ps_ProjInfo;
    econtext = node->ps.ps_ExprContext;

    /*
     * 如果既没有需要检查的限定条件，也没有需要进行投影的操作，直接跳过全部开销，返回原始扫描元组。
     */
    if (qual == NULL && proj_info == NULL) {
        ResetExprContext(econtext);
        return ExecScanFetch(node, access_mtd, recheck_mtd);
    }

    /*
     * 检查是否仍在从之前的扫描元组中投影出元组（因为在投影表达式中存在函数返回集合的情况）。如果是，则尝试投影另一个。
     */
    if (node->ps.ps_TupFromTlist) {
        Assert(proj_info); /* 如果不进行投影，不会到达这里 */
        result_slot = ExecProject(proj_info, &is_done);
        if (is_done == ExprMultipleResult)
            return result_slot;
        /* 完成了这个源元组... */
        node->ps.ps_TupFromTlist = false;
    }

    /*
     * @hdfs
     * 通过使用信息性约束来优化扫描。
     * 如果 is_scan_end 为 true，则迭代结束。
     */
    if (node->is_scan_end) {
        return NULL;
    }

    /*
     * 重置每个元组内存上下文，以释放在上一个元组循环中分配的表达式计算存储。
     * 注意，这只有在我们完成了从扫描元组投影出元组后才能发生。
     */
    ResetExprContext(econtext);

    /*
     * 从访问方法中获取一个元组。循环直到获取到符合条件的元组为止。
     */
    for (;;) {
        TupleTableSlot* slot = NULL;

        CHECK_FOR_INTERRUPTS();

        slot = ExecScanFetch(node, access_mtd, recheck_mtd);
        /* 在每次循环中刷新限定条件 */
        qual = node->ps.qual;
        /*
         * 如果 accessMtd 返回的 slot 包含 NULL，那么意味着没有更多要扫描的元组，因此我们只返回一个空的槽，
         * 要小心使用投影结果槽，以便其具有正确的 tupleDesc。
         */
        if (TupIsNull(slot) || unlikely(executorEarlyStop())) {
            if (proj_info != NULL)
                return ExecClearTuple(proj_info->pi_slot);
            else
                return slot;
        }

        /*
         * 将当前元组放入表达式上下文中
         */
        econtext->ecxt_scantuple = slot;

        /*
         * 检查当前元组是否符合限定条件
         *
         * 在此检查非空限定条件，以避免在限定条件为空时调用 ExecQual() 函数的开销... 节省一些循环周期，但它们会累积...
         */
        if (qual == NULL || ExecQual(qual, econtext, false)) {
            /*
             * 找到了满足条件的扫描元组。
             */
            if (proj_info != NULL) {
                /*
                 * 构造投影元组，将其存储在结果元组槽中并返回，除非我们发现无法从这个扫描元组中投影出元组，
                 * 在这种情况下继续扫描。
                 */
                result_slot = ExecProject(proj_info, &is_done);
#ifdef PGXC
                /* 如果底层扫描的槽具有 xcnodeoid，则复制 xcnodeoid */
                result_slot->tts_xcnodeoid = slot->tts_xcnodeoid;
#endif /* PGXC */
                if (is_done != ExprEndResult) {
                    node->ps.ps_TupFromTlist = (is_done == ExprMultipleResult);

                    /*
                     * @hdfs
                     * 通过使用信息性约束来优化外部扫描。
                     */
                    if (IsA(node->ps.plan, ForeignScan)) {
                        ForeignScan* foreign_scan = (ForeignScan*)(node->ps.plan);
                        if (foreign_scan->scan.scan_qual_optimized) {
                            /*
                             * 如果找到了合适的元组，则设置 is_scan_end 值为 true。
                             * 这意味着在下一次迭代中找不到合适的元组，迭代结束。
                             */
                            node->is_scan_end = true;
                        }
                    }
                    return result_slot;
                }
            } else {
                /*
                 * 通过使用信息性约束来优化外部扫描。
                 */
                if (IsA(node->ps.plan, ForeignScan)) {
                    ForeignScan* foreign_scan = (ForeignScan*)(node->ps.plan);
                    if (foreign_scan->scan.scan_qual_optimized) {
                        /*
                         * 如果找到了合适的元组，则设置 is_scan_end 值为 true。
                         * 这意味着在下一次迭代中找不到合适的元组，迭代结束。
                         */
                        node->is_scan_end = true;
                    }
                }
                /*
                 * 在这里，我们不进行投影，因此直接返回扫描元组。
                 */
                return slot;
            }
        } else
            InstrCountFiltered1(node, 1);

        /*
         * 元组不符合限定条件，因此释放每个元组内存并重试。
         */
        ResetExprContext(econtext);
    }
}

  在执行查询计划时，扫描节点会通过 ExecScan 函数调用 ExecScanFetch 函数来获取符合条件的元组，然后再进行投影、过滤等操作。
  ExecScanFetch 函数的核心任务是从关系中获取下一个元组，以及根据重新检查方法检查该元组是否满足内部的限定条件。这个函数的逻辑会根据当前的扫描方向（正向或反向）和访问方法的实现来决定如何获取下一个元组。
  我们来详细的看一看 ExecScanFetch 函数到底是怎样运行的吧， ExecScanFetch 函数源码如下：（路径：src/gausskernel/runtime/executor/execScan.cpp）

/*
 * ExecScanFetch -- 获取下一个潜在元组
 *
 * 这个函数主要用于在 EvalPlanQual 重新检查时替换测试元组。
 * 如果不是在 EvalPlanQual 中，就执行访问方法的下一个元组操作。
 */
static TupleTableSlot* ExecScanFetch(ScanState* node, ExecScanAccessMtd access_mtd, ExecScanRecheckMtd recheck_mtd)
{
	// 从node的执行状态结构体中获取执行状态estate
    EState* estate = node->ps.state;

	// 检查是否存在 EvalPlanQual（执行计划中的计划块），即是否正在执行 EvalPlanQual 重新检查
    if (estate->es_epqTuple != NULL) {
        /*
         * 我们在 EvalPlanQual 重新检查中。如果有测试元组可用，就在重新检查任何访问方法特定条件后返回该测试元组。
         */
        Index scan_rel_id = ((Scan*)node->ps.plan)->scanrelid;

        Assert(scan_rel_id > 0);
        if (estate->es_epqTupleSet[scan_rel_id - 1]) {
            TupleTableSlot* slot = node->ss_ScanTupleSlot;

            /* 如果我们已经返回了一个元组，则返回空槽 */
            if (estate->es_epqScanDone[scan_rel_id - 1])
                return ExecClearTuple(slot);
            /* 否则标记以记住不应该再返回更多元组 */
            estate->es_epqScanDone[scan_rel_id - 1] = true;

            /* 如果没有测试元组，就返回空槽 */
            if (estate->es_epqTuple[scan_rel_id - 1] == NULL)
                return ExecClearTuple(slot);

            /* 将测试元组存储在计划节点的扫描槽中 */
            (void)ExecStoreTuple(estate->es_epqTuple[scan_rel_id - 1], slot, InvalidBuffer, false);

            /* 检查是否满足访问方法的条件 */
            if (!(*recheck_mtd)(node, slot))
                (void)ExecClearTuple(slot); /* 不会被扫描返回 */

            return slot;
        }
    }

    /*
     * 运行节点类型特定的访问方法函数来获取下一个元组
     */
    return (*access_mtd)(node);
}

  再来看看 (*access_mtd)(node); 做了什么：SeqNext 函数是执行顺序扫描的核心工作函数。它从扫描描述中获取扫描信息和状态，然后通过调用 scan_handler_tbl_getnext 函数从表中获取下一个元组。获取到的元组会被保存到扫描元组槽中，并返回该槽。在这个过程中，还涉及到预取操作，以及缓冲区引用计数的处理。
  函数指针定义如下：（路径：src/gausskernel/runtime/executor/nodeSeqscan.cpp）

static TupleTableSlot* SeqNext(SeqScanState* node);

/* ----------------------------------------------------------------
 *						Scan Support
 * ----------------------------------------------------------------
 */
/* ----------------------------------------------------------------
 *		SeqNext
 *
 *		这是 ExecSeqScan 的工作函数
 * ----------------------------------------------------------------
 */
static TupleTableSlot* SeqNext(SeqScanState* node)
{
    Tuple tuple;
    TableScanDesc scanDesc;
    EState* estate = NULL;
    ScanDirection direction;
    TupleTableSlot* slot = NULL;

    /*
     * 从 estate 和扫描状态中获取信息
     */
    scanDesc = node->ss_currentScanDesc;
    estate = node->ps.state;
    direction = estate->es_direction;
    slot = node->ss_ScanTupleSlot;
    GetTableScanDesc(scanDesc, node->ss_currentRelation)->rs_ss_accessor = node->ss_scanaccessor;

    /*
     * 从表中获取下一个元组用于顺序扫描。
     */
    tuple = scan_handler_tbl_getnext(scanDesc, direction, node->ss_currentRelation);

    ADIO_RUN()
    {
        Start_Prefetch(GetTableScanDesc(scanDesc, node->ss_currentRelation), node->ss_scanaccessor, direction);
    }
    ADIO_END();

    /*
     * 将返回的元组和缓冲区保存在扫描元组槽中，并返回该槽。
     * 注意：我们传递 'false'，因为由 heap_getnext() 返回的元组是指向磁盘页上的指针，不是使用 palloc() 创建的，
     * 因此不应使用 pfree_ext() 进行释放。另外注意，ExecStoreTuple 将增加缓冲区的引用计数；引用计数将不会减少，
     * 直到清除元组表槽为止。
     */
    return ExecMakeTupleSlot(tuple, GetTableScanDesc(scanDesc, node->ss_currentRelation), slot, node->ss_currentRelation->rd_tam_type);
}

  SeqNext 函数中 使用 GetTableScanDesc 函数来处理分桶表（Bucketed Table）的情况。GetTableScanDesc 获取表扫描描述符（TableScanDesc）的函数，它根据输入的扫描描述符和关系（表）来返回对应的有效的扫描描述符。

注解：分桶表（Bucketed Table）是一种数据库表的存储组织方式，主要用于在分布式数据库系统中提高查询性能和并行处理能力。分桶表将表的数据按照某个列的值分成多个桶（bucket），每个桶包含相近的数据，从而可以使查询和分析操作更加高效。

函数源码如下：（路径：src/gausskernel/storage/access/hbstore/hbucket_am.cpp）

TableScanDesc GetTableScanDesc(TableScanDesc scan, Relation rel)
{
    if (scan != NULL && rel != NULL && RELATION_CREATE_BUCKET(scan->rs_rd)) {
        return (TableScanDesc)((HBktTblScanDesc)scan)->currBktScan;
    } else {
        return scan;
    }
}

  该函数返回一个 TableScanDesc 类型的指针，表示有效的扫描描述符。调试结果如下：
在这里插入图片描述
  SeqNext 函数调用 ExecMakeTupleSlot 函数主要用于将获取到的元组（tuple）存储到一个元组表槽（TupleTableSlot）中，同时关联元组的信息，如元组来自的扫描描述符、关联的缓冲区等。这个函数在数据库查询执行过程中扮演了重要的角色，用于将从数据库表中获取的数据以一种可管理的形式存储在内存中，以便后续的处理和返回。
  函数定义如下：（路径：src/gausskernel/runtime/executor/execTuples.cpp）

TupleTableSlot* ExecMakeTupleSlot(Tuple tuple, TableScanDesc tableScan, TupleTableSlot* slot, TableAmType tableAm)
{
    if (unlikely(RELATION_CREATE_BUCKET(tableScan->rs_rd))) {
        tableScan = ((HBktTblScanDesc)tableScan)->currBktScan;
    }

    if (tuple != NULL) {
        Assert(tableScan != NULL);
        slot->tts_tupslotTableAm = tableAm;
        return ExecStoreTuple(tuple, /* tuple to store */
            slot, /* slot to store in */
            tableScan->rs_cbuf, /* buffer associated with this tuple */
            false); /* don't pfree this pointer */
    }

    return ExecClearTuple(slot);
}

  在函数 ExecMakeTupleSlot 中，ExecStoreTuple 函数用于将一个元组存储到一个 TupleTableSlot 中。TupleTableSlot 是一种用于存储元组数据的数据结构，通常用于在查询计划的不同节点之间传递元组数据。
  源码如下：（路径：src/gausskernel/runtime/executor/execTuples.cpp）

/* --------------------------------
 *		ExecStoreTuple
 *
 *		This function is used to store a physical tuple into a specified
 *		slot in the tuple table.
 *
 *		tuple:	tuple to store
 *		slot:	slot to store it in
 *		buffer: disk buffer if tuple is in a disk page, else InvalidBuffer
 *		shouldFree: true if ExecClearTuple should pfree_ext() the tuple
 *					when done with it
 *
 * If 'buffer' is not InvalidBuffer, the tuple table code acquires a pin
 * on the buffer which is held until the slot is cleared, so that the tuple
 * won't go away on us.
 *
 * shouldFree is normally set 'true' for tuples constructed on-the-fly.
 * It must always be 'false' for tuples that are stored in disk pages,
 * since we don't want to try to pfree those.
 *
 * Another case where it is 'false' is when the referenced tuple is held
 * in a tuple table slot belonging to a lower-level executor Proc node.
 * In this case the lower-level slot retains ownership and responsibility
 * for eventually releasing the tuple.	When this method is used, we must
 * be certain that the upper-level Proc node will lose interest in the tuple
 * sooner than the lower-level one does!  If you're not certain, copy the
 * lower-level tuple with heap_copytuple and let the upper-level table
 * slot assume ownership of the copy!
 *
 * Return value is just the passed-in slot pointer.
 *
 * NOTE: before PostgreSQL 8.1, this function would accept a NULL tuple
 * pointer and effectively behave like ExecClearTuple (though you could
 * still specify a buffer to pin, which would be an odd combination).
 * This saved a couple lines of code in a few places, but seemed more likely
 * to mask logic errors than to be really useful, so it's now disallowed.
 * --------------------------------
 */
TupleTableSlot* ExecStoreTuple(Tuple tuple, TupleTableSlot* slot, Buffer buffer, bool should_free)
{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);

    tableam_tslot_store_tuple(tuple, slot, buffer, should_free);

    return slot;
}

总结

  ExecInitSeqScan 函数初始化 SeqScan 状态节点，负责节点状态结构构造，并初始化用于存储结果的元组表。
  ExecSeqScan 函数是 SeqScan 算子执行的主体函数，用于迭代获取每一个元组。ExecSeqScan 函数通过回调函数调用SeqNext 函数、HbktSeqSampleNext 函数、SeqSampleNext 函数实现获取元组。非采样获取元组时调用 SeqNext 函数；如果需要采样且对应的表采用哈希桶方式存储则调用 HbktSeqSampleNext 函数，否则调用 SeqSampleNext 函数。
  以下是 SeqScan 算子的执行过程的完整阐述：

  1. 查询解析和分析： 在 PostgreSQL 中，查询首先经过解析和分析阶段，确定了要查询的表、选择的列以及过滤条件等。
  2. 执行计划生成： 根据解析和分析的结果，系统生成一个查询执行计划。在这个阶段，PostgreSQL 的查询优化器会考虑各种访问路径、连接顺序和操作顺序，以生成一个优化的执行计划。
  3. 初始化执行环境： 执行计划生成后，会为查询执行创建一个执行环境（EState），其中包括查询的状态信息、内存上下文等。此时还会初始化一些查询中使用到的辅助数据结构。
  4. 初始化 SeqScanState： 对于 SeqScan 算子，会创建一个 SeqScanState 结构，用于存储该算子的执行状态。这个结构包含了 ScanState 的通用字段，以及一些特定于 SeqScan 的字段，如当前的扫描状态、分区信息等。
  5. 初始化扫描关系： SeqScan 需要初始化扫描关系，即要从哪个表中扫描数据。这包括打开表、获取相关的元数据等操作。
  6. 初始化元组插槽： 在查询执行过程中，需要使用 TupleTableSlot 来存储和传递元组数据。SeqScanState 中会初始化一个 TupleTableSlot，用于存储从表中读取的元组数据。
  7. 执行扫描： 正式进入执行阶段，SeqScan 开始逐行地扫描数据。具体步骤如下：
  • 获取下一个扫描元组：通过底层的存储访问接口获取表中的下一个元组。
  • 将元组存储到插槽：将扫描到的元组存储到初始化的 TupleTableSlot 中
    以便后续操作使用。
  • 应用过滤条件：如果查询中存在过滤条件（WHERE 子句），会对当前扫描到的元组应用过滤条件，确定是否满足条件。
  • 如果满足条件，元组会被返回给上层的操作节点进行进一步处理，例如投影、排序等。
  • 如果不满足条件，会继续扫描下一个元组。
  1. 结束扫描： 一旦所有的元组都被扫描完毕，或者查询的其他操作已经得到了结果，SeqScan 算子的执行就会结束。这时会释放相关的资源，关闭表，清理内存等操作。
  2. 返回结果： 执行完成后，根据查询的需要，可能会返回一个结果集或者进行其他的操作，如数据插入、更新等。
J.Kuchiki
关注
专栏目录
【OpenGauss源码学习 —— 执行算子（IndexScan算子）】
qq_43899283的博客
11-04 458
IndexScan是一种查询计划节点，用于执行索引扫描操作。它通常用于加速基于查询条件的数据检索操作，特别是在大型数据表中。IndexScan算子通常用于SELECT查询操作，特别是在需要快速检索数据的情况下，或需要按特定顺序排序数据时。本文仅作简单介绍，其中个别函数可能未涉及，感兴趣的读者可以自行阅读源码。
【OpenGauss源码学习 —— 执行算子（hash join 算子）】
qq_43899283的博客
08-17 967
hash join 算子的核心思想是通过哈希表将两个表的数据进行分组和关联，以加速连接操作。函数之间的调用关系确保了哈希表的正确构建、匹配和处理。这个算法对于大规模数据连接操作能够提供高效的性能。
PostgreSQL数据库查询执行——SeqScan节点执行
肥叔菌的博客
12-28 1292
SeqScan节点代码处于src/backend/executor/nodeSeqscan.c文件中，包含了4个重要函数：ExecInitSeqScan、ExecSeqScan、ExecReScanSeqScan和 ExecEndSeqScan。
postgresql 数据不多却很慢，seq scan的问题
华 英雄
10-13 2310
What is the difference between Seq Scan and Bitmap heap scan in postgres optimization - What is the difference between Seq Scan and Bitmap heap scan in postgres? - Stack Overflow where条件里用in的时候，有时候使用seq scan反而会导致異常慢，可以指定关掉 SET ENABLE_SEQSCAN to OFF;
PostgreSQL源码分析——SeqScan
最新发布
让我思考一下
06-18 710
这里，我们分析一下顺序扫描的过程，以最简单的语句为例，分析一下查询的过程。
spark算子的执行
qq_38976693的博客
08-21 437
【openGauss数据库内核分析系列】：执行算子探究
Gauss松鼠会
09-27 2504
执行引擎位于优化器和存储引擎之间，负责将数据从存储引擎读取出来，根据计划将数据处理加工返回给客户端。执行器接收到的指令就是优化器应对SQL查询而翻译出来的关系代数运算符所组成的执行树，一个具体关系运算代数符，我们称之为算子，每个算子有统一的接口，从下层的一个或者多个算子获得输入，然后将运算结果返回给上层算子。
【OpenGauss源码学习 —— 执行算子（Nest Loop 算子）】
qq_43899283的博客
02-28 707
连接算子用于处理表关联，openGauss支持12种连接类型（等），提供了3算子；其中，在先前的学习中，【OpenGauss源码学习 —— 执行算子（hash join 算子）】一文中详细介绍了hash join算子的执行过程。【OpenGauss源码学习 —— 执行算子（Merge Join 算子）】一文中学习了Merge Join算子的执行过程。本文则来继续学习另一个扫描算子Nest Loop算子。Nest Loop可以处理各种连接类型，包括内连接左连接右连接和全连接。对于小型数据集或者。
openGauss数据库源码解析——慢SQL检测
scp091的博客
12-06 1960
openGauss数据库源码解析——慢SQL检测 慢SQL检测的定义： 基于历史SQL语句信息进行模型训练，并用训练好的模型进行SQL语句的预测，利用预测结果判断该SQL语句是否是潜在的慢SQL。当发现潜在的慢SQL后，开发者便可以进行针对性优化或者风险评估，以防业务上线后发生问题。 慢SQL检测的功能： 上线业务预检测：上线一批新业务前，使用SQL诊断功能评估此次上线业务的预估执行时长，便于用户参考是否应该修改上线业务。workload分析：能够对现有workload进行分析，将现有workloa
openGauss数据库源码解析系列文章—— 执行器解析（二）_param_extern param_exec param_sublink
2401_84264244的博客
04-28 573
（2） 计算表达式结果。（3） 判断结果中itemIsDone[resind]参数并生成最后的元组。ExecTargetList函数的执行流程如图7-19所示。图7-19 ExecTargetList函数执行流程ExecProject函数的作用是进行投影操作，投影操作是一种属性过滤过程，该操作将对元组的属性进行精简，把在上层计划节点中不需要用的属性从元组中去掉，从而构造一个精简版的元组。投影操作中被保留下来的那些属性被称为投影属性。ExecProject函数的主要执行流程如下。
OpenGauss数据库源码编译安装过程学习笔记
qq_40310161的博客
01-25 1223
目 录 OpenGauss数据库源码编译安装过程学习笔记 编译openGauss需要openGauss-server和binarylibs两个组件。 openGauss-server：openGauss的主要代码。可以从开源社区获取。 binarylibs：openGauss依赖的第三方开源软件，你可以直接编译openGauss-third_party代码获取，也可以从开源社区下载已经编译好的并上传的一个副本。 注：软件依赖包版本需尽量与openGauss-server版本一致 对于数据库、三方库、GC.
openGauss内核分析（八）：执行算子探究
gallopingdb的博客
07-27 146
图中每一个方块代表一个具体关系运算代数符，我们称之为算子，每个算子有统一的接口，从下层的一个或者多个算子获得输入，然后将运算结果返回给上层算子。物化算子一般指算法要求，在做算子逻辑处理的时候，要求把下层的数据进行缓存处理，因为对于下层算子返回的数据量不可提前预知，因此需要在算法上考虑数据无法全部放置到内存的情况。执行器的整体目标就是在每一个由优化器构建出来的执行树上，通过控制流驱动数据流在执行树上高效的流动，其流动的速度决定了执行器的处理效率。下面重点分析Seqscan算子的代码流程。
对PostgreSQL的 seq scan , bitmap index scan 和 index scan 的进一步理解
weixin_34335458的博客
11-09 456
开始 参考momjian 的文章： http://momjian.us/main/writings/pgsql/optimizer.pdf 首先，构造一个数据分布明显倾斜的表（有的值占据了70%以上的分布） postgres=# CREATE TEMPORARY TABLE sample (letter, junk) AS postgres-# SELECT substring(re...
【OpenGauss源码学习 —— 执行算子（Result 算子）】
qq_43899283的博客
08-22 1188
Result 算子对应的代码源文件是 “nodeResult.cpp”，用于处理只有一个结果（如通过SELECT调用可执行函数或表达式，或者INSERT语句只包含Values字句）或者WHERE表达式中的结果是常量（如“SELECT * FROM emp WHERE 2 > 1”，过滤条件“2 > 1”是常量只需要计算一次即可）的流程。由于openGauss没有提供单独的投影算子（Projection）和选择算子（Selection），Result算子也可以起到类似的作用。Result算子提供的主要函数如下
openGauss源码学习（四）SeqScan扫描算子 执行器部分
qq_42282731的博客
04-25 1530
上篇文章介绍了一个简单查询里如何为基表生成SeqScan计划，这篇文章从执行器和存储引擎的角度介绍一下SeqScan算子是如何执行的。执行器框架有很多博主都做了全面并且详细的分析，可以参考博文PostgreSQL内核学习（十五）—— （ExecutorRun）本篇博客简单介绍了OpenGauss执行器和astore存储引擎的SeqScan逻辑，可以清晰看到火山模型运行过程中是如何处理一行记录的。
openGauss源码学习（三）SeqScan扫描算子 优化器部分
qq_42282731的博客
12-02 277
关于优化器、执行器的主要逻辑有很多文章和书籍进行说明，比如查询解析、查询重写、路径生成、计划生成和执行器及算子。所以系列博客还是准备对源码做较多的分析，计划后面的文章从一个算子的优化器到执行器进行详细的代码走读与分析。那么这篇文章先对SeqScan的优化器部分进行分析，从行数估算、代价估算以及路径/计划生成做一个整体的介绍。下篇文章对执行器和存储引擎进行介绍，全面地了解一个表内的数据是如何读取并返回给客户端。以上就是一条简单SQL。
如何插件化地为openGauss添加算子
weixin_53596073的博客
03-18 581
1.1 openGauss执行算子汇总 openGauss的算子按类型可分为四类：控制算子、连接算子、扫描算子和物化算子。下面汇总了当前（openGauss2.0.0）已有的算子。 算子 文件 类型 Agg nodeAgg.cpp 物化算子 Append nodeAppend.cpp 控制算子 BitmapAnd nodeBitmapAnd.cpp 控制算子 BitmapHeapscan nodeBitmapHeapscan.cpp
postgres执行计划 seqscan,indexscan,bitmapscan实验性分析
热门推荐
yibei8811的专栏
06-16 1万+
执行以下代码create table t1(c1 int4); insert into t1 select generate_series(1,10); explain analyze select * from t1 where c1 =4 显示为 "Seq Scan on t1 (cost=0.00..40.00 rows=12 width=4) (actual time=0.007.
postgresql分页用法_PostgreSQL 分页, offset, 返回顺序, 扫描方法原理(seqscan, index scan, index only scan, bitmap scan...
weixin_39695954的博客
01-14 754
标签PostgreSQL , 数据离散性 , 扫描性能 , 重复扫 , bitmap index scan , 排序扫描 , 扫描方法 , 顺序背景一个这样的问题：为什么select x from tbl offset x limit x;两次查询连续的OFFSET，会有重复数据呢？select ctid,* from tbl where ... offset 0 limit 10;select ...
Postgresql | 执行计划
Albirostris
03-09 3497
postgresql 执行计划
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值