PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
nodeBitmapOr.h File Reference
#include "nodes/execnodes.h"
Include dependency graph for nodeBitmapOr.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

BitmapOrStateExecInitBitmapOr (BitmapOr *node, EState *estate, int eflags)
 
NodeMultiExecBitmapOr (BitmapOrState *node)
 
void ExecEndBitmapOr (BitmapOrState *node)
 
void ExecReScanBitmapOr (BitmapOrState *node)
 

Function Documentation

void ExecEndBitmapOr ( BitmapOrState node)

Definition at line 182 of file nodeBitmapOr.c.

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

Referenced by ExecEndNode().

183 {
184  PlanState **bitmapplans;
185  int nplans;
186  int i;
187 
188  /*
189  * get information from the node
190  */
191  bitmapplans = node->bitmapplans;
192  nplans = node->nplans;
193 
194  /*
195  * shut down each of the subscans (that we've initialized)
196  */
197  for (i = 0; i < nplans; i++)
198  {
199  if (bitmapplans[i])
200  ExecEndNode(bitmapplans[i]);
201  }
202 }
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:654
PlanState ** bitmapplans
Definition: execnodes.h:1033
int i
BitmapOrState* ExecInitBitmapOr ( BitmapOr node,
EState estate,
int  eflags 
)

Definition at line 43 of file nodeBitmapOr.c.

References Assert, BitmapOr::bitmapplans, BitmapOrState::bitmapplans, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecInitNode(), i, lfirst, list_length(), makeNode, BitmapOrState::nplans, palloc0(), PlanState::plan, BitmapOrState::ps, and PlanState::state.

Referenced by ExecInitNode().

44 {
45  BitmapOrState *bitmaporstate = makeNode(BitmapOrState);
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 BitmapOrState for our BitmapOr node
64  */
65  bitmaporstate->ps.plan = (Plan *) node;
66  bitmaporstate->ps.state = estate;
67  bitmaporstate->bitmapplans = bitmapplanstates;
68  bitmaporstate->nplans = nplans;
69 
70  /*
71  * Miscellaneous initialization
72  *
73  * BitmapOr 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  /*
78  * call ExecInitNode on each of the plans to be executed and save the
79  * results into the array "bitmapplanstates".
80  */
81  i = 0;
82  foreach(l, node->bitmapplans)
83  {
84  initNode = (Plan *) lfirst(l);
85  bitmapplanstates[i] = ExecInitNode(initNode, estate, eflags);
86  i++;
87  }
88 
89  return bitmaporstate;
90 }
PlanState ps
Definition: execnodes.h:1032
EState * state
Definition: execnodes.h:815
PlanState ** bitmapplans
Definition: execnodes.h:1033
#define EXEC_FLAG_BACKWARD
Definition: executor.h:60
List * bitmapplans
Definition: plannodes.h:318
void * palloc0(Size size)
Definition: mcxt.c:878
Plan * plan
Definition: execnodes.h:813
#define makeNode(_type_)
Definition: nodes.h:557
#define Assert(condition)
Definition: c.h:675
#define lfirst(lc)
Definition: pg_list.h:106
#define EXEC_FLAG_MARK
Definition: executor.h:61
static int list_length(const List *l)
Definition: pg_list.h:89
int i
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:140
void ExecReScanBitmapOr ( BitmapOrState node)

Definition at line 205 of file nodeBitmapOr.c.

References BitmapOrState::bitmapplans, PlanState::chgParam, ExecReScan(), i, BitmapOrState::nplans, NULL, BitmapOrState::ps, and UpdateChangedParamSet().

Referenced by ExecReScan().

206 {
207  int i;
208 
209  for (i = 0; i < node->nplans; i++)
210  {
211  PlanState *subnode = node->bitmapplans[i];
212 
213  /*
214  * ExecReScan doesn't know about my subplans, so I have to do
215  * changed-parameter signaling myself.
216  */
217  if (node->ps.chgParam != NULL)
218  UpdateChangedParamSet(subnode, node->ps.chgParam);
219 
220  /*
221  * If chgParam of subnode is not null then plan will be re-scanned by
222  * first ExecProcNode.
223  */
224  if (subnode->chgParam == NULL)
225  ExecReScan(subnode);
226  }
227 }
PlanState ps
Definition: execnodes.h:1032
void ExecReScan(PlanState *node)
Definition: execAmi.c:75
PlanState ** bitmapplans
Definition: execnodes.h:1033
Bitmapset * chgParam
Definition: execnodes.h:837
void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
Definition: execUtils.c:671
#define NULL
Definition: c.h:229
int i
Node* MultiExecBitmapOr ( BitmapOrState node)

Definition at line 97 of file nodeBitmapOr.c.

References BitmapOrState::bitmapplans, elog, ERROR, EState::es_query_dsa, i, InstrStartNode(), InstrStopNode(), PlanState::instrument, IsA, MultiExecProcNode(), BitmapOrState::nplans, NULL, PlanState::plan, BitmapOrState::ps, result, PlanState::state, tbm_create(), tbm_free(), tbm_union(), and work_mem.

Referenced by MultiExecProcNode().

98 {
99  PlanState **bitmapplans;
100  int nplans;
101  int i;
102  TIDBitmap *result = NULL;
103 
104  /* must provide our own instrumentation support */
105  if (node->ps.instrument)
107 
108  /*
109  * get information from the node
110  */
111  bitmapplans = node->bitmapplans;
112  nplans = node->nplans;
113 
114  /*
115  * Scan all the subplans and OR their result bitmaps
116  */
117  for (i = 0; i < nplans; i++)
118  {
119  PlanState *subnode = bitmapplans[i];
120  TIDBitmap *subresult;
121 
122  /*
123  * We can special-case BitmapIndexScan children to avoid an explicit
124  * tbm_union step for each child: just pass down the current result
125  * bitmap and let the child OR directly into it.
126  */
127  if (IsA(subnode, BitmapIndexScanState))
128  {
129  if (result == NULL) /* first subplan */
130  {
131  /* XXX should we use less than work_mem for this? */
132  result = tbm_create(work_mem * 1024L,
133  ((BitmapOr *) node->ps.plan)->isshared ?
134  node->ps.state->es_query_dsa : NULL);
135  }
136 
137  ((BitmapIndexScanState *) subnode)->biss_result = result;
138 
139  subresult = (TIDBitmap *) MultiExecProcNode(subnode);
140 
141  if (subresult != result)
142  elog(ERROR, "unrecognized result from subplan");
143  }
144  else
145  {
146  /* standard implementation */
147  subresult = (TIDBitmap *) MultiExecProcNode(subnode);
148 
149  if (!subresult || !IsA(subresult, TIDBitmap))
150  elog(ERROR, "unrecognized result from subplan");
151 
152  if (result == NULL)
153  result = subresult; /* first subplan */
154  else
155  {
156  tbm_union(result, subresult);
157  tbm_free(subresult);
158  }
159  }
160  }
161 
162  /* We could return an empty result set here? */
163  if (result == NULL)
164  elog(ERROR, "BitmapOr doesn't support zero inputs");
165 
166  /* must provide our own instrumentation support */
167  if (node->ps.instrument)
168  InstrStopNode(node->ps.instrument, 0 /* XXX */ );
169 
170  return (Node *) result;
171 }
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:80
struct dsa_area * es_query_dsa
Definition: execnodes.h:488
#define IsA(nodeptr, _type_)
Definition: nodes.h:560
Instrumentation * instrument
Definition: execnodes.h:819
PlanState ps
Definition: execnodes.h:1032
void tbm_union(TIDBitmap *a, const TIDBitmap *b)
Definition: tidbitmap.c:484
TIDBitmap * tbm_create(long maxbytes, dsa_area *dsa)
Definition: tidbitmap.c:281
Definition: nodes.h:509
return result
Definition: formatting.c:1632
EState * state
Definition: execnodes.h:815
#define ERROR
Definition: elog.h:43
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:63
PlanState ** bitmapplans
Definition: execnodes.h:1033
void tbm_free(TIDBitmap *tbm)
Definition: tidbitmap.c:348
int work_mem
Definition: globals.c:112
Plan * plan
Definition: execnodes.h:813
#define NULL
Definition: c.h:229
Node * MultiExecProcNode(PlanState *node)
Definition: execProcnode.c:601
int i
#define elog
Definition: elog.h:219