executor.h Source File (original) (raw)

14#ifndef EXECUTOR_H

15#define EXECUTOR_H

66#define EXEC_FLAG_EXPLAIN_ONLY 0x0001

67#define EXEC_FLAG_EXPLAIN_GENERIC 0x0002

68#define EXEC_FLAG_REWIND 0x0004

69#define EXEC_FLAG_BACKWARD 0x0008

70#define EXEC_FLAG_MARK 0x0010

71#define EXEC_FLAG_SKIP_TRIGGERS 0x0020

72#define EXEC_FLAG_WITH_NO_DATA 0x0040

95 List *rtePermInfos,

96 bool ereport_on_violation);

100

101

102

103struct Path;

104

111

112

113

114

117 Oid table_oid,

119

120

121

122

124 int numCols,

126 const Oid *eqOperators,

127 const Oid *collations,

130 const Oid *eqOperators,

131 Oid **eqFuncOids,

136 int numCols,

138 const Oid *eqfuncoids,

140 Oid *collations,

141 long nbuckets,

142 Size additionalsize,

146 bool use_variable_hash_iv);

160

161#ifndef FRONTEND

162

163

164

165static inline size_t

167{

169}

170

171

172

173

176{

178}

179

180

181

182

183

184

185

186

187

188static inline void *

190{

193 else

194 return NULL;

195}

196#endif

197

198

199

200

207 const char *attrName);

209 const char *attrName);

212

213

214

215

216

217

218

219

220#ifndef FRONTEND

221static inline Datum

223{

226}

227#endif

228

229

230

231

235 int query_index);

247 List *rteperminfos, bool ereport_on_violation);

249 List *mergeActions);

252 Index resultRelationIndex,

254 int instrument_options);

263 List *notnull_virtual_attrs);

273 int maxfieldlen);

280 Plan *subplan, List *auxrowmarks,

281 int epqParam, List *resultRelations);

283 Plan *subplan, List *auxrowmarks);

286

287#define EvalPlanQualSetSlot(epqstate, slot) ((epqstate)->origslot = (slot))

292

293

294

295

302

303

304

305

306

307

308

309

310static inline bool

312{

315}

316

317

318

319

320

321static inline bool

323{

326}

327

328

329

330

331

332

333

334#ifndef FRONTEND

337{

338 if (node->chgParam != NULL)

339 ExecReScan(node);

340

342}

343#endif

344

345

346

347

354 bool doSort, bool doHash, bool nullcheck);

358 Oid *collations,

359 int numCols,

365 const Oid *hashfunc_oids,

366 const List *collations,

367 const List *hash_exprs,

368 const bool *opstrict, PlanState *parent,

369 uint32 init_value, bool keep_nulls);

372 int numCols,

374 const Oid *eqfunctions,

375 const Oid *collations,

380 const Oid *eqfunctions,

381 const Oid *collations,

382 const List *param_exprs,

390 bool evalTargetList,

391 List *targetColnos,

400

401

402

403

404

405

406

407

408

409

410

411

412

413#ifndef FRONTEND

414static inline Datum

417 bool *isNull)

418{

419 return state->evalfunc(state, econtext, isNull);

420}

421#endif

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438#ifndef FRONTEND

439static inline void

442{

444

445 retDatum = state->evalfunc(state, econtext, NULL);

446

448}

449#endif

450

451

452

453

454

455

456#ifndef FRONTEND

457static inline Datum

460 bool *isNull)

461{

464

466 retDatum = state->evalfunc(state, econtext, isNull);

468 return retDatum;

469}

470#endif

471

472

473

474

475

476

477

478#ifndef FRONTEND

479static inline void

482{

484

488}

489#endif

490

491

492

493

494

495

496

497

498

499

500

501

502

503#ifndef FRONTEND

506{

510

511

512

513

514

516

517

519

520

521

522

523

524 slot->tts_flags &= ~TTS_FLAG_EMPTY;

526

527 return slot;

528}

529#endif

530

531

532

533

534

535

536

537

538

539#ifndef FRONTEND

540static inline bool

542{

544 bool isnull;

545

546

547 if (state == NULL)

548 return true;

549

550

552

554

555

557

559}

560#endif

561

562

563

564

565

566#ifndef FRONTEND

567static inline bool

569{

571

572

574 return ret;

575}

576#endif

577

579

580

581

582

589 bool randomAccess);

595 bool *isNull,

597

598

599

600

603

609

610

611

612

631

633{

637

644

645

646

647

648

649

650#define do_text_output_oneline(tstate, str_to_emit) \

651 do { \

652 Datum values_[1]; \

653 bool isnull_[1]; \

654 values_[0] = PointerGetDatum(cstring_to_text(str_to_emit)); \

655 isnull_[0] = false; \

656 do_tup_output(tstate, values_, isnull_); \

657 pfree(DatumGetPointer(values_[0])); \

658 } while (0)

659

660

661

662

663

671

672#define ResetExprContext(econtext) \

673 MemoryContextReset((econtext)->ecxt_per_tuple_memory)

674

676

677

678#define GetPerTupleExprContext(estate) \

679 ((estate)->es_per_tuple_exprcontext ? \

680 (estate)->es_per_tuple_exprcontext : \

681 MakePerTupleExprContext(estate))

682

683#define GetPerTupleMemoryContext(estate) \

684 (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)

685

686

687#define ResetPerTupleExprContext(estate) \

688 do { \

689 if ((estate)->es_per_tuple_exprcontext) \

690 ResetExprContext((estate)->es_per_tuple_exprcontext); \

691 } while (0)

692

696 bool *isfixed);

698 int nplans);

708

710

712

717

720{

722}

723

725 bool isResultRel);

728

730

737

739 bool *isNull);

741 bool *isNull);

742

745

752

758

759

760

761

766 bool update,

767 bool noDupErr,

768 bool *specConflict, List *arbiterIndexes,

769 bool onlySummarizing);

774 List *arbiterIndexes);

779 EState *estate, bool newIndex);

780

781

782

783

790

800

803

804

805

806

811 Oid resultoid,

812 bool missing_ok,

813 bool update_cache);

814

815#endif

static Datum values[MAXATTR]

#define PG_USED_FOR_ASSERTS_ONLY

void(* ExprContextCallbackFunction)(Datum arg)

TupleTableSlot *(* ExecProcNodeMtd)(struct PlanState *pstate)

struct TupleHashEntryData TupleHashEntryData

static MinimalTuple TupleHashEntryGetTuple(TupleHashEntry entry)

TupleDesc ExecGetResultType(PlanState *planstate)

Relation ExecGetRangeTableRelation(EState *estate, Index rti, bool isResultRel)

bool RelationFindReplTupleSeq(Relation rel, LockTupleMode lockmode, TupleTableSlot *searchslot, TupleTableSlot *outslot)

bool RelationFindReplTupleByIndex(Relation rel, Oid idxoid, LockTupleMode lockmode, TupleTableSlot *searchslot, TupleTableSlot *outslot)

LockTupleMode ExecUpdateLockMode(EState *estate, ResultRelInfo *relinfo)

ResultRelInfo * ExecLookupResultRelByOid(ModifyTableState *node, Oid resultoid, bool missing_ok, bool update_cache)

ExprState * execTuplesMatchPrepare(TupleDesc desc, int numCols, const AttrNumber *keyColIdx, const Oid *eqOperators, const Oid *collations, PlanState *parent)

ExecRowMark * ExecFindRowMark(EState *estate, Index rti, bool missing_ok)

TupleConversionMap * ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)

ExecAuxRowMark * ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)

ResultRelInfo * ExecGetTriggerResultRel(EState *estate, Oid relid, ResultRelInfo *rootRelInfo)

void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation, List *mergeActions)

void ExecAssignScanProjectionInfoWithVarno(ScanState *node, int varno)

PGDLLIMPORT ExecutorEnd_hook_type ExecutorEnd_hook

TupleTableSlot * EvalPlanQualSlot(EPQState *epqstate, Relation relation, Index rti)

Bitmapset * ExecGetExtraUpdatedCols(ResultRelInfo *relinfo, EState *estate)

void ExecSimpleRelationDelete(ResultRelInfo *resultRelInfo, EState *estate, EPQState *epqstate, TupleTableSlot *searchslot)

void CheckSubscriptionRelkind(char relkind, const char *nspname, const char *relname)

void EvalPlanQualBegin(EPQState *epqstate)

Bitmapset * ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate)

TupleTableSlot * ExecGetTriggerNewSlot(EState *estate, ResultRelInfo *relInfo)

PGDLLIMPORT ExecutorStart_hook_type ExecutorStart_hook

char * ExecBuildSlotValueDescription(Oid reloid, TupleTableSlot *slot, TupleDesc tupdesc, Bitmapset *modifiedCols, int maxfieldlen)

ExprState * ExecBuildHash32FromAttrs(TupleDesc desc, const TupleTableSlotOps *ops, FmgrInfo *hashfunctions, Oid *collations, int numCols, AttrNumber *keyColIdx, PlanState *parent, uint32 init_value)

bool ExecutorStart(QueryDesc *queryDesc, int eflags)

void ReScanExprContext(ExprContext *econtext)

static TupleTableSlot * ExecProject(ProjectionInfo *projInfo)

bool ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool emitError)

static void * TupleHashEntryGetAdditional(TupleHashTable hashtable, TupleHashEntry entry)

ExprState * ExecInitExpr(Expr *node, PlanState *parent)

JunkFilter * ExecInitJunkFilterConversion(List *targetList, TupleDesc cleanTupType, TupleTableSlot *slot)

void do_tup_output(TupOutputState *tstate, const Datum *values, const bool *isnull)

ExprState * ExecPrepareExpr(Expr *node, EState *estate)

static bool ExecShouldLockRelations(EState *estate)

bool ExecCheck(ExprState *state, ExprContext *econtext)

ExprContext * CreateExprContext(EState *estate)

ExprState * ExecInitCheck(List *qual, PlanState *parent)

SetExprState * ExecInitFunctionResultSet(Expr *expr, ExprContext *econtext, PlanState *parent)

void ExecutorStartCachedPlan(QueryDesc *queryDesc, int eflags, CachedPlanSource *plansource, int query_index)

void execTuplesHashPrepare(int numCols, const Oid *eqOperators, Oid **eqFuncOids, FmgrInfo **hashFunctions)

void(* ExecutorFinish_hook_type)(QueryDesc *queryDesc)

TupleConversionMap * ExecGetChildToRootMap(ResultRelInfo *resultRelInfo)

ExprContext * CreateStandaloneExprContext(void)

void ExecutorEnd(QueryDesc *queryDesc)

void EvalPlanQualInit(EPQState *epqstate, EState *parentestate, Plan *subplan, List *auxrowmarks, int epqParam, List *resultRelations)

TupleTableSlot * ExecGetTriggerOldSlot(EState *estate, ResultRelInfo *relInfo)

TupleDesc ExecCleanTypeFromTL(List *targetList)

void ExecWithCheckOptions(WCOKind kind, ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)

int executor_errposition(EState *estate, int location)

void ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)

ProjectionInfo * ExecBuildProjectionInfo(List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)

void ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)

TupleHashEntry LookupTupleHashEntryHash(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)

bool ExecSupportsMarkRestore(struct Path *pathnode)

static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)

Tuplestorestate * ExecMakeTableFunctionResult(SetExprState *setexpr, ExprContext *econtext, MemoryContext argContext, TupleDesc expectedDesc, bool randomAccess)

Datum GetAttributeByNum(HeapTupleHeader tuple, AttrNumber attrno, bool *isNull)

void FreeExprContext(ExprContext *econtext, bool isCommit)

void ExecInitRangeTable(EState *estate, List *rangeTable, List *permInfos, Bitmapset *unpruned_relids)

TupleTableSlot * ExecFilterJunk(JunkFilter *junkfilter, TupleTableSlot *slot)

Node * MultiExecProcNode(PlanState *node)

AttrNumber ExecFindJunkAttributeInTlist(List *targetlist, const char *attrName)

Bitmapset * ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate)

TupleTableSlot * ExecGetUpdateNewTuple(ResultRelInfo *relinfo, TupleTableSlot *planSlot, TupleTableSlot *oldSlot)

const TupleTableSlotOps * ExecGetCommonSlotOps(PlanState **planstates, int nplans)

void ExecInitResultRelation(EState *estate, ResultRelInfo *resultRelInfo, Index rti)

void end_tup_output(TupOutputState *tstate)

void InitResultRelInfo(ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options)

void ExecMarkPos(PlanState *node)

void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)

TupleTableSlot * ExecScan(ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd)

Datum ExecMakeFunctionResultSet(SetExprState *fcache, ExprContext *econtext, MemoryContext argContext, bool *isNull, ExprDoneCond *isDone)

void ExecCreateScanSlotFromOuterPlan(EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)

void ExecutorFinish(QueryDesc *queryDesc)

void ExecEndNode(PlanState *node)

JunkFilter * ExecInitJunkFilter(List *targetList, TupleTableSlot *slot)

void ExecSimpleRelationUpdate(ResultRelInfo *resultRelInfo, EState *estate, EPQState *epqstate, TupleTableSlot *searchslot, TupleTableSlot *slot)

void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)

TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 *hash)

void EvalPlanQualEnd(EPQState *epqstate)

void ExecInitResultTypeTL(PlanState *planstate)

void EvalPlanQualSetPlan(EPQState *epqstate, Plan *subplan, List *auxrowmarks)

void CheckCmdReplicaIdentity(Relation rel, CmdType cmd)

PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)

ExprState * ExecBuildAggTrans(AggState *aggstate, struct AggStatePerPhaseData *phase, bool doSort, bool doHash, bool nullcheck)

void(* ExecutorRun_hook_type)(QueryDesc *queryDesc, ScanDirection direction, uint64 count)

void ExecSimpleRelationInsert(ResultRelInfo *resultRelInfo, EState *estate, TupleTableSlot *slot)

AttrNumber ExecFindJunkAttribute(JunkFilter *junkfilter, const char *attrName)

PGDLLIMPORT ExecutorFinish_hook_type ExecutorFinish_hook

void ExecutorRewind(QueryDesc *queryDesc)

void do_text_output_multiline(TupOutputState *tstate, const char *txt)

void ExecShutdownNode(PlanState *node)

void ExecAssignExprContext(EState *estate, PlanState *planstate)

ExprState * ExecPrepareQual(List *qual, EState *estate)

AttrNumber ExecRelGenVirtualNotNull(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, List *notnull_virtual_attrs)

SetExprState * ExecInitTableFunctionResult(Expr *expr, ExprContext *econtext, PlanState *parent)

ExprState * ExecInitQual(List *qual, PlanState *parent)

TupleTableSlot * EvalPlanQual(EPQState *epqstate, Relation relation, Index rti, TupleTableSlot *inputslot)

void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)

static bool ExecQual(ExprState *state, ExprContext *econtext)

ExprContext * MakePerTupleExprContext(EState *estate)

void UnregisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)

void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc)

bool(* ExecScanRecheckMtd)(ScanState *node, TupleTableSlot *slot)

const TupleTableSlotOps * ExecGetCommonChildSlotOps(PlanState *ps)

TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)

bool(* ExecutorCheckPerms_hook_type)(List *rangeTable, List *rtePermInfos, bool ereport_on_violation)

bool(* ExecutorStart_hook_type)(QueryDesc *queryDesc, int eflags)

uint32 TupleHashTableHash(TupleHashTable hashtable, TupleTableSlot *slot)

bool EvalPlanQualFetchRowMark(EPQState *epqstate, Index rti, TupleTableSlot *slot)

List * ExecInitExprList(List *nodes, PlanState *parent)

void ExecConditionalAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc, int varno)

bool standard_ExecutorStart(QueryDesc *queryDesc, int eflags)

void(* ExecutorEnd_hook_type)(QueryDesc *queryDesc)

void ExecInitResultTupleSlotTL(PlanState *planstate, const TupleTableSlotOps *tts_ops)

void ExecCloseIndices(ResultRelInfo *resultRelInfo)

void RegisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)

static bool ExecQualAndReset(ExprState *state, ExprContext *econtext)

ExprState * ExecInitExprWithParams(Expr *node, ParamListInfo ext_params)

void ExecAssignScanProjectionInfo(ScanState *node)

int ExecTargetListLength(List *targetlist)

ProjectionInfo * ExecBuildUpdateProjection(List *targetList, bool evalTargetList, List *targetColnos, TupleDesc relDesc, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent)

void FreeExecutorState(EState *estate)

struct TupOutputState TupOutputState

static size_t TupleHashEntrySize(void)

bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid)

ExprState * ExecBuildGroupingEqual(TupleDesc ldesc, TupleDesc rdesc, const TupleTableSlotOps *lops, const TupleTableSlotOps *rops, int numCols, const AttrNumber *keyColIdx, const Oid *eqfunctions, const Oid *collations, PlanState *parent)

TupleHashEntry FindTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot, ExprState *eqcomp, ExprState *hashexpr)

void ExecCloseResultRelations(EState *estate)

static TupleTableSlot * ExecProcNode(PlanState *node)

TupleTableSlot * ExecGetAllNullSlot(EState *estate, ResultRelInfo *relInfo)

bool ExecMaterializesOutput(NodeTag plantype)

void ExecOpenIndices(ResultRelInfo *resultRelInfo, bool speculative)

int ExecCleanTargetListLength(List *targetlist)

ExprContext * CreateWorkExprContext(EState *estate)

static bool ExecPlanStillValid(EState *estate)

TupOutputState * begin_tup_output_tupdesc(DestReceiver *dest, TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)

TupleTableSlot *(* ExecScanAccessMtd)(ScanState *node)

void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)

void ExecScanReScan(ScanState *node)

bool ExecSupportsBackwardScan(Plan *node)

const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)

Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)

TupleHashTable BuildTupleHashTable(PlanState *parent, TupleDesc inputDesc, const TupleTableSlotOps *inputOps, int numCols, AttrNumber *keyColIdx, const Oid *eqfuncoids, FmgrInfo *hashfunctions, Oid *collations, long nbuckets, Size additionalsize, MemoryContext metacxt, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv)

PGDLLIMPORT ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook

bool ExecCheckIndexConstraints(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, ItemPointer conflictTid, ItemPointer tupleid, List *arbiterIndexes)

Bitmapset * ExecGetAllUpdatedCols(ResultRelInfo *relinfo, EState *estate)

void ExecReScan(PlanState *node)

static void ExecEvalExprNoReturn(ExprState *state, ExprContext *econtext)

PGDLLIMPORT ExecutorRun_hook_type ExecutorRun_hook

TupleDesc ExecTypeFromExprList(List *exprList)

List * ExecInsertIndexTuples(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool update, bool noDupErr, bool *specConflict, List *arbiterIndexes, bool onlySummarizing)

TupleDesc ExecTypeFromTL(List *targetList)

void standard_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)

static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)

bool execCurrentOf(CurrentOfExpr *cexpr, ExprContext *econtext, Oid table_oid, ItemPointer current_tid)

void ResetTupleHashTable(TupleHashTable hashtable)

List * ExecPrepareExprList(List *nodes, EState *estate)

void standard_ExecutorEnd(QueryDesc *queryDesc)

void ExecRestrPos(PlanState *node)

static void ExecEvalExprNoReturnSwitchContext(ExprState *state, ExprContext *econtext)

void ExecCloseRangeTableRelations(EState *estate)

static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)

void check_exclusion_constraint(Relation heap, Relation index, IndexInfo *indexInfo, ItemPointer tupleid, const Datum *values, const bool *isnull, EState *estate, bool newIndex)

void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)

void ExecPartitionCheckEmitError(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)

ExprState * ExecBuildParamSetEqual(TupleDesc desc, const TupleTableSlotOps *lops, const TupleTableSlotOps *rops, const Oid *eqfunctions, const Oid *collations, const List *param_exprs, PlanState *parent)

void ExecConstraints(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)

TupleTableSlot * ExecInitNullTupleSlot(EState *estate, TupleDesc tupType, const TupleTableSlotOps *tts_ops)

TupleTableSlot * ExecGetReturningSlot(EState *estate, ResultRelInfo *relInfo)

Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)

bool ExecCheckPermissions(List *rangeTable, List *rteperminfos, bool ereport_on_violation)

static Datum ExecGetJunkAttribute(TupleTableSlot *slot, AttrNumber attno, bool *isNull)

void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)

Oid ExecGetResultRelCheckAsUser(ResultRelInfo *relInfo, EState *estate)

ExprState * ExecBuildHash32Expr(TupleDesc desc, const TupleTableSlotOps *ops, const Oid *hashfunc_oids, const List *collations, const List *hash_exprs, const bool *opstrict, PlanState *parent, uint32 init_value, bool keep_nulls)

EState * CreateExecutorState(void)

ExprState * ExecPrepareCheck(List *qual, EState *estate)

List * ExecGetAncestorResultRels(EState *estate, ResultRelInfo *resultRelInfo)

TupleTableSlot * EvalPlanQualNext(EPQState *epqstate)

void standard_ExecutorFinish(QueryDesc *queryDesc)

Assert(PointerIsAligned(start, uint64))

void MemoryContextReset(MemoryContext context)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

on_exit_nicely_callback function

static void * list_nth(const List *list, int n)

static bool CachedPlanRequiresLocking(CachedPlan *cplan)

static bool CachedPlanValid(CachedPlan *cplan)

static bool DatumGetBool(Datum X)

static unsigned hash(unsigned *uv, int n)

CachedPlan * es_cachedplan

MemoryContext ecxt_per_tuple_memory

ExecProcNodeMtd ExecProcNode

ExprContext * pi_exprContext

TupleDesc tts_tupleDescriptor

static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)

static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)