PostgreSQL在何处处理 sql查询之四十二

接前面，再次上溯。可以知道：

ExecProcNode: 会根据情况不同，将PlanNode转为各种类型Node再参与运算:

TupleTableSlot *

ExecProcNode(PlanState *node)

{



    //ExecProcNode
 fprintf(stderr,"ExecProcNode:node->ss_currentScanDesc->rs_startblock is: %d by process %d\n",
            ((SeqScanState *) node)->ss_currentScanDesc->rs_startblock,getpid());



    TupleTableSlot *result;



    CHECK_FOR_INTERRUPTS();



    if (node->chgParam != NULL) /* something changed */

        ExecReScan(node);        /* let ReScan handle this */



    if (node->instrument)

        InstrStartNode(node->instrument);



    switch (nodeTag(node))

    {

            /*

             * control nodes

             */

        case T_ResultState:

            result = ExecResult((ResultState *) node);

            break;



        ...



            /*

             * scan nodes

             */

        case T_SeqScanState:

            result = ExecSeqScan((SeqScanState *) node);

            break;



        case T_IndexScanState:

            result = ExecIndexScan((IndexScanState *) node);

            break;



        ...



        default:

            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));

            result = NULL;

            break;

    }



    if (node->instrument)

        InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);



    return result;

}

各种 Node，有点像 Java里的 类和基类，这是如何实现的呢？

看下面就清楚了：

/* ----------------                                

 *        PlanState node                        

 *                                

 * We never actually instantiate any PlanState nodes; this is just the common                                

 * abstract superclass for all PlanState-type nodes.                                

 * ----------------                                

 */                                

typedef struct PlanState                                

{                                

    NodeTag        type;                    

                                

    Plan       *plan;            /* associated Plan node */            

                                

    EState       *state;            /* at execution time, states of individual            

                     * nodes point to one EState for the whole            

                     * top-level plan */            

                                

    Instrumentation *instrument;    /* Optional runtime stats for this node */                        

                                

    /*                            

     * Common structural data for all Plan types.  These links to subsidiary                            

     * state trees parallel links in the associated plan tree (except for the                            

     * subPlan list, which does not exist in the plan tree).                            

     */                            

    List       *targetlist;        /* target list to be computed at this node */                

    List       *qual;            /* implicitly-ANDed qual conditions */            

    struct PlanState *lefttree; /* input plan tree(s) */                            

    struct PlanState *righttree;                            

    List       *initPlan;        /* Init SubPlanState nodes (un-correlated expr                

                                 * subselects) */

    List       *subPlan;        /* SubPlanState nodes in my expressions */                

                                

    /*                            

     * State for management of parameter-change-driven rescanning                            

     */                            

    Bitmapset  *chgParam;        /* set of IDs of changed Params */                    

                                

    /*                            

     * Other run-time state needed by most if not all node types.                            

     */                            

    TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */                            

    ExprContext *ps_ExprContext;    /* node's expression-evaluation context */                        

    ProjectionInfo *ps_ProjInfo;    /* info for doing tuple projection */                        

    bool        ps_TupFromTlist;/* state flag for processing set-valued                    

                         * functions in targetlist */        

} PlanState;                                

再看：

/* ----------------                        

 *     ResultState information                    

 * ----------------                        

 */                        

typedef struct ResultState                        

{                        

    PlanState    ps;                /* its first field is NodeTag */

    ExprState  *resconstantqual;                    

    bool        rs_done;        /* are we done? */    

    bool        rs_checkqual;    /* do we need to check the qual? */        

} ResultState;                        

再看：

/* ----------------                        

 *     ScanState information                    

 *                        

 *        ScanState extends PlanState for node types that represent                

 *        scans of an underlying relation.  It can also be used for nodes                

 *        that scan the output of an underlying plan node --- in that case,                

 *        only ScanTupleSlot is actually useful, and it refers to the tuple                

 *        retrieved from the subplan.                

 *                        

 *        currentRelation    relation being scanned (NULL if none)                

 *        currentScanDesc    current scan descriptor for scan (NULL if none)                

 *        ScanTupleSlot       pointer to slot in tuple table holding scan tuple            

 * ----------------                        

 */                        

typedef struct ScanState                        

{                        

    PlanState    ps;                /* its first field is NodeTag */

    Relation    ss_currentRelation;                

    HeapScanDesc ss_currentScanDesc;                    

    TupleTableSlot *ss_ScanTupleSlot;                    

} ScanState;                        

甚至还有这个：

/* ----------------                        

 *     IndexScanState information                    

 *                        

 *        indexqualorig       execution state for indexqualorig expressions            

 *        ScanKeys           Skey structures for index quals        

 *        NumScanKeys           number of ScanKeys        

 *        OrderByKeys           Skey structures for index ordering operators        

 *        NumOrderByKeys       number of OrderByKeys            

 *        RuntimeKeys           info about Skeys that must be evaluated at runtime        

 *        NumRuntimeKeys       number of RuntimeKeys            

 *        RuntimeKeysReady   true if runtime Skeys have been computed                

 *        RuntimeContext       expr context for evaling runtime Skeys            

 *        RelationDesc       index relation descriptor            

 *        ScanDesc           index scan descriptor        

 * ----------------                        

 */                        

typedef struct IndexScanState                        

{                        

    ScanState    ss;                /* its first field is NodeTag */

    List       *indexqualorig;                

    ScanKey        iss_ScanKeys;            

    int            iss_NumScanKeys;        

    ScanKey        iss_OrderByKeys;            

    int            iss_NumOrderByKeys;        

    IndexRuntimeKeyInfo *iss_RuntimeKeys;                    

    int            iss_NumRuntimeKeys;        

    bool        iss_RuntimeKeysReady;            

    ExprContext *iss_RuntimeContext;                    

    Relation    iss_RelationDesc;                

    IndexScanDesc iss_ScanDesc;                    

} IndexScanState;                        

那就相当于 子类的子类了。

我的感觉，与其说C语言是面向过程语言，不如说它是数据结构为中心的语言。

熟练掌握各类数据结构以及指针的用法，那就无往而不利了。