openGauss 执行算子探究

{    ……    /*     * create state structure     */    SeqScanState* scanstate = makeNode(SeqScanState); // SeqScan状态节点     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};     ……    /*     * tuple table initialization     */    InitScanRelation(scanstate, estate, eflags); // 初始化扫描表   ……    /*     * initialize scan relation     */     InitSeqNextMtd(node, scanstate); // 设定获取元组的函数     ……     return scanstate;}

static inline void InitSeqNextMtd(SeqScan* node, SeqScanState* scanstate){    if (!node->tablesample) {        scanstate->ScanNextMtd = SeqNext;    ……}

static void ExecutePlan(EState *estate, PlanState *planstate, CmdType operation, bool sendTuples, long numberTuples,ScanDirection direction, DestReceiver *dest, JitExec::JitContext* motJitContext){    TupleTableSlot *slot = NULL;    long current_tuple_count = 0; // 初始化    ……    /*     * Loop until we've processed the proper number of tuples from the plan.     */    for (;;) { // 循环调用ExecProcNode    ……        if (unlikely(recursive_early_stop)) {            slot = NULL;        } else if (motJitContext && !IS_PGXC_COORDINATOR && JitExec::IsMotCodegenEnabled()) {            // MOT LLVM            int scanEnded = 0;            if (!motFinishedExecution) {                // previous iteration has not signaled end of scan                slot = planstate->ps_ResultTupleSlot;                uint64_t tuplesProcessed = 0;                int rc = JitExec::JitExecQuery(                    motJitContext, estate->es_param_list_info, slot, &tuplesProcessed, &scanEnded);                if (scanEnded || (tuplesProcessed == 0) || (rc != 0)) {                    // raise flag so that next round we will bail out (current tuple still must be reported to user)                    motFinishedExecution = true;                }            } else {                (void)ExecClearTuple(slot);            }        } else {            slot = ExecProcNode(planstate); // 调用ExecProcNode        }    ……        /*         * if the tuple is null, then we assume there is nothing more to         * process so we just end the loop...         */        if (TupIsNull(slot)) { // 元组为空即中止循环            if(!is_saved_recursive_union_plan_nodeid) {                break;            }            ExecEarlyFreeBody(planstate);            break;        }    ……        {            (*dest->receiveSlot)(slot, dest); // 简单select语句调用printtup函数        }    ……        /*         * check our tuple count.. if we've processed the proper number then         * quit, else loop again and process more tuples.  Zero numberTuples         * means no limit.         */        current_tuple_count++; // 计数元组数        if (numberTuples == current_tuple_count) {            break;        }    }    ……}

TupleTableSlot* ExecProcNode(PlanState* node){    TupleTableSlot* result = NULL;    ……    {        int index = (int)(nodeTag(node))-T_ResultState;        Assert(index >= 0 && index <= T_StreamState - T_ResultState);        result = g_execProcFuncTable[index](node);    }    ……    return result;}

ExecProcFuncType g_execProcFuncTable[] = {    ExecResultWrap,    ……    ExecSeqScanWrap,    ExecIndexScanWrap,    ExecIndexOnlyScanWrap,    ……};

static TupleTableSlot* ExecScanFetch(ScanState* node, ExecScanAccessMtd access_mtd, ExecScanRecheckMtd recheck_mtd){    ……    /*     * Run the node-type-specific access method function to get the next tuple     */    return (*access_mtd)(node); // 回调SeqNext}