granicus.if.org Git - postgresql/blob - src/include/executor/executor.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * executor.h
   4  *        support for the POSTGRES executor module
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * $PostgreSQL: pgsql/src/include/executor/executor.h,v 1.123 2005/12/03 05:51:03 tgl Exp $
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef EXECUTOR_H
  15 #define EXECUTOR_H
  16
  17 #include "executor/execdesc.h"
  18
  19
  20 /*
  21  * ExecEvalExpr was formerly a function containing a switch statement;
  22  * now it's just a macro invoking the function pointed to by an ExprState
  23  * node.  Beware of double evaluation of the ExprState argument!
  24  */
  25 #define ExecEvalExpr(expr, econtext, isNull, isDone) \
  26         ((*(expr)->evalfunc) (expr, econtext, isNull, isDone))
  27
  28
  29 /*
  30  * prototypes from functions in execAmi.c
  31  */
  32 extern void ExecReScan(PlanState *node, ExprContext *exprCtxt);
  33 extern void ExecMarkPos(PlanState *node);
  34 extern void ExecRestrPos(PlanState *node);
  35 extern bool ExecSupportsMarkRestore(NodeTag plantype);
  36 extern bool ExecSupportsBackwardScan(Plan *node);
  37 extern bool ExecMayReturnRawTuples(PlanState *node);
  38
  39 /*
  40  * prototypes from functions in execGrouping.c
  41  */
  42 extern bool execTuplesMatch(TupleTableSlot *slot1,
  43                                 TupleTableSlot *slot2,
  44                                 int numCols,
  45                                 AttrNumber *matchColIdx,
  46                                 FmgrInfo *eqfunctions,
  47                                 MemoryContext evalContext);
  48 extern bool execTuplesUnequal(TupleTableSlot *slot1,
  49                                   TupleTableSlot *slot2,
  50                                   int numCols,
  51                                   AttrNumber *matchColIdx,
  52                                   FmgrInfo *eqfunctions,
  53                                   MemoryContext evalContext);
  54 extern FmgrInfo *execTuplesMatchPrepare(TupleDesc tupdesc,
  55                                            int numCols,
  56                                            AttrNumber *matchColIdx);
  57 extern void execTuplesHashPrepare(TupleDesc tupdesc,
  58                                           int numCols,
  59                                           AttrNumber *matchColIdx,
  60                                           FmgrInfo **eqfunctions,
  61                                           FmgrInfo **hashfunctions);
  62 extern TupleHashTable BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
  63                                         FmgrInfo *eqfunctions,
  64                                         FmgrInfo *hashfunctions,
  65                                         int nbuckets, Size entrysize,
  66                                         MemoryContext tablecxt,
  67                                         MemoryContext tempcxt);
  68 extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable,
  69                                          TupleTableSlot *slot,
  70                                          bool *isnew);
  71
  72 /*
  73  * prototypes from functions in execJunk.c
  74  */
  75 extern JunkFilter *ExecInitJunkFilter(List *targetList, bool hasoid,
  76                                    TupleTableSlot *slot);
  77 extern JunkFilter *ExecInitJunkFilterConversion(List *targetList,
  78                                                          TupleDesc cleanTupType,
  79                                                          TupleTableSlot *slot);
  80 extern bool ExecGetJunkAttribute(JunkFilter *junkfilter, TupleTableSlot *slot,
  81                                          char *attrName, Datum *value, bool *isNull);
  82 extern TupleTableSlot *ExecFilterJunk(JunkFilter *junkfilter,
  83                            TupleTableSlot *slot);
  84 extern HeapTuple ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot);
  85
  86
  87 /*
  88  * prototypes from functions in execMain.c
  89  */
  90 extern void ExecutorStart(QueryDesc *queryDesc, bool explainOnly);
  91 extern TupleTableSlot *ExecutorRun(QueryDesc *queryDesc,
  92                         ScanDirection direction, long count);
  93 extern void ExecutorEnd(QueryDesc *queryDesc);
  94 extern void ExecutorRewind(QueryDesc *queryDesc);
  95 extern void ExecCheckRTPerms(List *rangeTable);
  96 extern void ExecEndPlan(PlanState *planstate, EState *estate);
  97 extern bool ExecContextForcesOids(PlanState *planstate, bool *hasoids);
  98 extern void ExecConstraints(ResultRelInfo *resultRelInfo,
  99                                 TupleTableSlot *slot, EState *estate);
 100 extern TupleTableSlot *EvalPlanQual(EState *estate, Index rti,
 101                          ItemPointer tid, TransactionId priorXmax);
 102
 103 /*
 104  * prototypes from functions in execProcnode.c
 105  */
 106 extern PlanState *ExecInitNode(Plan *node, EState *estate);
 107 extern TupleTableSlot *ExecProcNode(PlanState *node);
 108 extern Node *MultiExecProcNode(PlanState *node);
 109 extern int      ExecCountSlotsNode(Plan *node);
 110 extern void ExecEndNode(PlanState *node);
 111
 112 /*
 113  * prototypes from functions in execQual.c
 114  */
 115 extern Datum GetAttributeByNum(HeapTupleHeader tuple, AttrNumber attrno,
 116                                   bool *isNull);
 117 extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
 118                                    bool *isNull);
 119 extern void init_fcache(Oid foid, FuncExprState *fcache,
 120                         MemoryContext fcacheCxt);
 121 extern Datum ExecMakeFunctionResult(FuncExprState *fcache,
 122                                            ExprContext *econtext,
 123                                            bool *isNull,
 124                                            ExprDoneCond *isDone);
 125 extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
 126                                                         ExprContext *econtext,
 127                                                         TupleDesc expectedDesc,
 128                                                         TupleDesc *returnDesc);
 129 extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,
 130                                                   bool *isNull, ExprDoneCond *isDone);
 131 extern ExprState *ExecInitExpr(Expr *node, PlanState *parent);
 132 extern SubPlanState *ExecInitExprInitPlan(SubPlan *node, PlanState *parent);
 133 extern ExprState *ExecPrepareExpr(Expr *node, EState *estate);
 134 extern bool ExecQual(List *qual, ExprContext *econtext, bool resultForNull);
 135 extern int      ExecTargetListLength(List *targetlist);
 136 extern int      ExecCleanTargetListLength(List *targetlist);
 137 extern TupleTableSlot *ExecProject(ProjectionInfo *projInfo,
 138                         ExprDoneCond *isDone);
 139
 140 /*
 141  * prototypes from functions in execScan.c
 142  */
 143 typedef TupleTableSlot *(*ExecScanAccessMtd) (ScanState *node);
 144
 145 extern TupleTableSlot *ExecScan(ScanState *node, ExecScanAccessMtd accessMtd);
 146 extern void ExecAssignScanProjectionInfo(ScanState *node);
 147
 148 /*
 149  * prototypes from functions in execTuples.c
 150  */
 151 extern void ExecInitResultTupleSlot(EState *estate, PlanState *planstate);
 152 extern void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate);
 153 extern TupleTableSlot *ExecInitExtraTupleSlot(EState *estate);
 154 extern TupleTableSlot *ExecInitNullTupleSlot(EState *estate,
 155                                           TupleDesc tupType);
 156 extern TupleDesc ExecTypeFromTL(List *targetList, bool hasoid);
 157 extern TupleDesc ExecCleanTypeFromTL(List *targetList, bool hasoid);
 158 extern TupleDesc ExecTypeFromExprList(List *exprList);
 159 extern void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg);
 160
 161 typedef struct TupOutputState
 162 {
 163         /* use "struct" here to allow forward reference */
 164         struct AttInMetadata *metadata;
 165         TupleTableSlot *slot;
 166         DestReceiver *dest;
 167 } TupOutputState;
 168
 169 extern TupOutputState *begin_tup_output_tupdesc(DestReceiver *dest,
 170                                                  TupleDesc tupdesc);
 171 extern void do_tup_output(TupOutputState *tstate, char **values);
 172 extern void do_text_output_multiline(TupOutputState *tstate, char *text);
 173 extern void end_tup_output(TupOutputState *tstate);
 174
 175 /*
 176  * Write a single line of text given as a C string.
 177  *
 178  * Should only be used with a single-TEXT-attribute tupdesc.
 179  */
 180 #define do_text_output_oneline(tstate, text_to_emit) \
 181         do { \
 182                 char *values_[1]; \
 183                 values_[0] = (text_to_emit); \
 184                 do_tup_output(tstate, values_); \
 185         } while (0)
 186
 187
 188 /*
 189  * prototypes from functions in execUtils.c
 190  */
 191 extern EState *CreateExecutorState(void);
 192 extern void FreeExecutorState(EState *estate);
 193 extern ExprContext *CreateExprContext(EState *estate);
 194 extern void FreeExprContext(ExprContext *econtext);
 195 extern void ReScanExprContext(ExprContext *econtext);
 196
 197 #define ResetExprContext(econtext) \
 198         MemoryContextReset((econtext)->ecxt_per_tuple_memory)
 199
 200 extern ExprContext *MakePerTupleExprContext(EState *estate);
 201
 202 /* Get an EState's per-output-tuple exprcontext, making it if first use */
 203 #define GetPerTupleExprContext(estate) \
 204         ((estate)->es_per_tuple_exprcontext ? \
 205          (estate)->es_per_tuple_exprcontext : \
 206          MakePerTupleExprContext(estate))
 207
 208 #define GetPerTupleMemoryContext(estate) \
 209         (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)
 210
 211 /* Reset an EState's per-output-tuple exprcontext, if one's been created */
 212 #define ResetPerTupleExprContext(estate) \
 213         do { \
 214                 if ((estate)->es_per_tuple_exprcontext) \
 215                         ResetExprContext((estate)->es_per_tuple_exprcontext); \
 216         } while (0)
 217
 218 extern void ExecAssignExprContext(EState *estate, PlanState *planstate);
 219 extern void ExecAssignResultType(PlanState *planstate,
 220                                          TupleDesc tupDesc, bool shouldFree);
 221 extern void ExecAssignResultTypeFromTL(PlanState *planstate);
 222 extern TupleDesc ExecGetResultType(PlanState *planstate);
 223 extern ProjectionInfo *ExecBuildProjectionInfo(List *targetList,
 224                                                 ExprContext *econtext,
 225                                                 TupleTableSlot *slot);
 226 extern void ExecAssignProjectionInfo(PlanState *planstate);
 227 extern void ExecFreeExprContext(PlanState *planstate);
 228 extern TupleDesc ExecGetScanType(ScanState *scanstate);
 229 extern void ExecAssignScanType(ScanState *scanstate,
 230                                    TupleDesc tupDesc, bool shouldFree);
 231 extern void ExecAssignScanTypeFromOuterPlan(ScanState *scanstate);
 232
 233 extern bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid);
 234
 235 extern Relation ExecOpenScanRelation(EState *estate, Index scanrelid);
 236 extern void ExecCloseScanRelation(Relation scanrel);
 237
 238 extern void ExecOpenIndices(ResultRelInfo *resultRelInfo);
 239 extern void ExecCloseIndices(ResultRelInfo *resultRelInfo);
 240 extern void ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
 241                                           EState *estate, bool is_vacuum);
 242
 243 extern void RegisterExprContextCallback(ExprContext *econtext,
 244                                                         ExprContextCallbackFunction function,
 245                                                         Datum arg);
 246 extern void UnregisterExprContextCallback(ExprContext *econtext,
 247                                                           ExprContextCallbackFunction function,
 248                                                           Datum arg);
 249
 250 #endif   /* EXECUTOR_H  */