src/backend/executor/nodeBitmapAnd.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeBitmapAnd.c
   4  *        routines to handle BitmapAnd nodes.
   5  *
   6  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL$
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 /* INTERFACE ROUTINES
  16  *              ExecInitBitmapAnd       - initialize the BitmapAnd node
  17  *              MultiExecBitmapAnd      - retrieve the result bitmap from the node
  18  *              ExecEndBitmapAnd        - shut down the BitmapAnd node
  19  *              ExecReScanBitmapAnd - rescan the BitmapAnd node
  20  *
  21  *       NOTES
  22  *              BitmapAnd nodes don't make use of their left and right
  23  *              subtrees, rather they maintain a list of subplans,
  24  *              much like Append nodes.  The logic is much simpler than
  25  *              Append, however, since we needn't cope with forward/backward
  26  *              execution.
  27  */
  28
  29 #include "postgres.h"
  30
  31 #include "executor/execdebug.h"
  32 #include "executor/instrument.h"
  33 #include "executor/nodeBitmapAnd.h"
  34
  35
  36 /* ----------------------------------------------------------------
  37  *              ExecInitBitmapAnd
  38  *
  39  *              Begin all of the subscans of the BitmapAnd node.
  40  * ----------------------------------------------------------------
  41  */
  42 BitmapAndState *
  43 ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
  44 {
  45         BitmapAndState *bitmapandstate = makeNode(BitmapAndState);
  46         PlanState **bitmapplanstates;
  47         int                     nplans;
  48         int                     i;
  49         ListCell   *l;
  50         Plan       *initNode;
  51
  52         /* check for unsupported flags */
  53         Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
  54
  55         /*
  56          * Set up empty vector of subplan states
  57          */
  58         nplans = list_length(node->bitmapplans);
  59
  60         bitmapplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *));
  61
  62         /*
  63          * create new BitmapAndState for our BitmapAnd node
  64          */
  65         bitmapandstate->ps.plan = (Plan *) node;
  66         bitmapandstate->ps.state = estate;
  67         bitmapandstate->bitmapplans = bitmapplanstates;
  68         bitmapandstate->nplans = nplans;
  69
  70         /*
  71          * Miscellaneous initialization
  72          *
  73          * BitmapAnd plans don't have expression contexts because they never call
  74          * ExecQual or ExecProject.  They don't need any tuple slots either.
  75          */
  76
  77 #define BITMAPAND_NSLOTS 0
  78
  79         /*
  80          * call ExecInitNode on each of the plans to be executed and save the
  81          * results into the array "bitmapplanstates".
  82          */
  83         i = 0;
  84         foreach(l, node->bitmapplans)
  85         {
  86                 initNode = (Plan *) lfirst(l);
  87                 bitmapplanstates[i] = ExecInitNode(initNode, estate, eflags);
  88                 i++;
  89         }
  90
  91         return bitmapandstate;
  92 }
  93
  94 int
  95 ExecCountSlotsBitmapAnd(BitmapAnd *node)
  96 {
  97         ListCell   *plan;
  98         int                     nSlots = 0;
  99
 100         foreach(plan, node->bitmapplans)
 101                 nSlots += ExecCountSlotsNode((Plan *) lfirst(plan));
 102         return nSlots + BITMAPAND_NSLOTS;
 103 }
 104
 105 /* ----------------------------------------------------------------
 106  *         MultiExecBitmapAnd
 107  * ----------------------------------------------------------------
 108  */
 109 Node *
 110 MultiExecBitmapAnd(BitmapAndState *node)
 111 {
 112         PlanState **bitmapplans;
 113         int                     nplans;
 114         int                     i;
 115         TIDBitmap  *result = NULL;
 116
 117         /* must provide our own instrumentation support */
 118         if (node->ps.instrument)
 119                 InstrStartNode(node->ps.instrument);
 120
 121         /*
 122          * get information from the node
 123          */
 124         bitmapplans = node->bitmapplans;
 125         nplans = node->nplans;
 126
 127         /*
 128          * Scan all the subplans and AND their result bitmaps
 129          */
 130         for (i = 0; i < nplans; i++)
 131         {
 132                 PlanState  *subnode = bitmapplans[i];
 133                 TIDBitmap  *subresult;
 134
 135                 subresult = (TIDBitmap *) MultiExecProcNode(subnode);
 136
 137                 if (!subresult || !IsA(subresult, TIDBitmap))
 138                         elog(ERROR, "unrecognized result from subplan");
 139
 140                 if (result == NULL)
 141                         result = subresult; /* first subplan */
 142                 else
 143                 {
 144                         tbm_intersect(result, subresult);
 145                         tbm_free(subresult);
 146                 }
 147
 148                 /*
 149                  * If at any stage we have a completely empty bitmap, we can fall out
 150                  * without evaluating the remaining subplans, since ANDing them can no
 151                  * longer change the result.  (Note: the fact that indxpath.c orders
 152                  * the subplans by selectivity should make this case more likely to
 153                  * occur.)
 154                  */
 155                 if (tbm_is_empty(result))
 156                         break;
 157         }
 158
 159         if (result == NULL)
 160                 elog(ERROR, "BitmapAnd doesn't support zero inputs");
 161
 162         /* must provide our own instrumentation support */
 163         if (node->ps.instrument)
 164                 InstrStopNode(node->ps.instrument, 0 /* XXX */ );
 165
 166         return (Node *) result;
 167 }
 168
 169 /* ----------------------------------------------------------------
 170  *              ExecEndBitmapAnd
 171  *
 172  *              Shuts down the subscans of the BitmapAnd node.
 173  *
 174  *              Returns nothing of interest.
 175  * ----------------------------------------------------------------
 176  */
 177 void
 178 ExecEndBitmapAnd(BitmapAndState *node)
 179 {
 180         PlanState **bitmapplans;
 181         int                     nplans;
 182         int                     i;
 183
 184         /*
 185          * get information from the node
 186          */
 187         bitmapplans = node->bitmapplans;
 188         nplans = node->nplans;
 189
 190         /*
 191          * shut down each of the subscans (that we've initialized)
 192          */
 193         for (i = 0; i < nplans; i++)
 194         {
 195                 if (bitmapplans[i])
 196                         ExecEndNode(bitmapplans[i]);
 197         }
 198 }
 199
 200 void
 201 ExecReScanBitmapAnd(BitmapAndState *node, ExprContext *exprCtxt)
 202 {
 203         int                     i;
 204
 205         for (i = 0; i < node->nplans; i++)
 206         {
 207                 PlanState  *subnode = node->bitmapplans[i];
 208
 209                 /*
 210                  * ExecReScan doesn't know about my subplans, so I have to do
 211                  * changed-parameter signaling myself.
 212                  */
 213                 if (node->ps.chgParam != NULL)
 214                         UpdateChangedParamSet(subnode, node->ps.chgParam);
 215
 216                 /*
 217                  * Always rescan the inputs immediately, to ensure we can pass down
 218                  * any outer tuple that might be used in index quals.
 219                  */
 220                 ExecReScan(subnode, exprCtxt);
 221         }
 222 }