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;
}

/* ----------------                                
 *        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;