nodeBitmapAnd.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeBitmapAnd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BitmapAndState *	ExecInitBitmapAnd (BitmapAnd *node, EState *estate, int eflags)
Node *	MultiExecBitmapAnd (BitmapAndState *node)
void	ExecEndBitmapAnd (BitmapAndState *node)
void	ExecReScanBitmapAnd (BitmapAndState *node)

Function Documentation

ExecEndBitmapAnd()

void ExecEndBitmapAnd ( BitmapAndState *  node )

extern

Definition at line 178 of file nodeBitmapAnd.c.

{
    PlanState **bitmapplans;
    int         nplans;
    int         i;
 
    /*
     * get information from the node
     */
    bitmapplans = node->bitmapplans;
    nplans = node->nplans;
 
    /*
     * shut down each of the subscans (that we've initialized)
     */
    for (i = 0; i < nplans; i++)
    {
        if (bitmapplans[i])
            ExecEndNode(bitmapplans[i]);
    }
}

References BitmapAndState::bitmapplans, ExecEndNode(), i, and BitmapAndState::nplans.

Referenced by ExecEndNode().

ExecInitBitmapAnd()

BitmapAndState * ExecInitBitmapAnd ( BitmapAnd *  node, EState *  estate, int  eflags  )

extern

Definition at line 55 of file nodeBitmapAnd.c.

{
    BitmapAndState *bitmapandstate = makeNode(BitmapAndState);
    PlanState **bitmapplanstates;
    int         nplans;
    int         i;
    ListCell   *l;
    Plan       *initNode;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * Set up empty vector of subplan states
     */
    nplans = list_length(node->bitmapplans);
 
    bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *));
 
    /*
     * create new BitmapAndState for our BitmapAnd node
     */
    bitmapandstate->ps.plan = (Plan *) node;
    bitmapandstate->ps.state = estate;
    bitmapandstate->ps.ExecProcNode = ExecBitmapAnd;
    bitmapandstate->bitmapplans = bitmapplanstates;
    bitmapandstate->nplans = nplans;
 
    /*
     * call ExecInitNode on each of the plans to be executed and save the
     * results into the array "bitmapplanstates".
     */
    i = 0;
    foreach(l, node->bitmapplans)
    {
        initNode = (Plan *) lfirst(l);
        bitmapplanstates[i] = ExecInitNode(initNode, estate, eflags);
        i++;
    }
 
    /*
     * Miscellaneous initialization
     *
     * BitmapAnd plans don't have expression contexts because they never call
     * ExecQual or ExecProject.  They don't need any tuple slots either.
     */
 
    return bitmapandstate;
}

References Assert, BitmapAnd::bitmapplans, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecBitmapAnd(), ExecInitNode(), fb(), i, lfirst, list_length(), makeNode, and palloc0().

Referenced by ExecInitNode().

ExecReScanBitmapAnd()

void ExecReScanBitmapAnd ( BitmapAndState *  node )

extern

Definition at line 201 of file nodeBitmapAnd.c.

{
    int         i;
 
    for (i = 0; i < node->nplans; i++)
    {
        PlanState  *subnode = node->bitmapplans[i];
 
        /*
         * ExecReScan doesn't know about my subplans, so I have to do
         * changed-parameter signaling myself.
         */
        if (node->ps.chgParam != NULL)
            UpdateChangedParamSet(subnode, node->ps.chgParam);
 
        /*
         * If chgParam of subnode is not null then plan will be re-scanned by
         * first ExecProcNode.
         */
        if (subnode->chgParam == NULL)
            ExecReScan(subnode);
    }
}

References BitmapAndState::bitmapplans, PlanState::chgParam, ExecReScan(), fb(), i, BitmapAndState::nplans, BitmapAndState::ps, and UpdateChangedParamSet().

Referenced by ExecReScan().

MultiExecBitmapAnd()

Node * MultiExecBitmapAnd ( BitmapAndState *  node )

extern

Definition at line 110 of file nodeBitmapAnd.c.

{
    PlanState **bitmapplans;
    int         nplans;
    int         i;
    TIDBitmap  *result = NULL;
 
    /* must provide our own instrumentation support */
    if (node->ps.instrument)
        InstrStartNode(node->ps.instrument);
 
    /*
     * get information from the node
     */
    bitmapplans = node->bitmapplans;
    nplans = node->nplans;
 
    /*
     * Scan all the subplans and AND their result bitmaps
     */
    for (i = 0; i < nplans; i++)
    {
        PlanState  *subnode = bitmapplans[i];
        TIDBitmap  *subresult;
 
        subresult = (TIDBitmap *) MultiExecProcNode(subnode);
 
        if (!subresult || !IsA(subresult, TIDBitmap))
            elog(ERROR, "unrecognized result from subplan");
 
        if (result == NULL)
            result = subresult; /* first subplan */
        else
        {
            tbm_intersect(result, subresult);
            tbm_free(subresult);
        }
 
        /*
         * If at any stage we have a completely empty bitmap, we can fall out
         * without evaluating the remaining subplans, since ANDing them can no
         * longer change the result.  (Note: the fact that indxpath.c orders
         * the subplans by selectivity should make this case more likely to
         * occur.)
         */
        if (tbm_is_empty(result))
            break;
    }
 
    if (result == NULL)
        elog(ERROR, "BitmapAnd doesn't support zero inputs");
 
    /* must provide our own instrumentation support */
    if (node->ps.instrument)
        InstrStopNode(node->ps.instrument, 0 /* XXX */ );
 
    return (Node *) result;
}

References BitmapAndState::bitmapplans, elog, ERROR, fb(), i, InstrStartNode(), InstrStopNode(), PlanState::instrument, IsA, MultiExecProcNode(), BitmapAndState::nplans, BitmapAndState::ps, tbm_free(), tbm_intersect(), and tbm_is_empty().

Referenced by MultiExecProcNode().