executor.h Source File (original) (raw)

14#ifndef EXECUTOR_H

15#define EXECUTOR_H

65#define EXEC_FLAG_EXPLAIN_ONLY 0x0001

66#define EXEC_FLAG_EXPLAIN_GENERIC 0x0002

67#define EXEC_FLAG_REWIND 0x0004

68#define EXEC_FLAG_BACKWARD 0x0008

69#define EXEC_FLAG_MARK 0x0010

70#define EXEC_FLAG_SKIP_TRIGGERS 0x0020

71#define EXEC_FLAG_WITH_NO_DATA 0x0040

94 List *rtePermInfos,

95 bool ereport_on_violation);

100

101

102struct Path;

103

110

111

112

113

116 Oid table_oid,

118

119

120

121

123 int numCols,

125 const Oid *eqOperators,

126 const Oid *collations,

129 const Oid *eqOperators,

130 Oid **eqFuncOids,

135 int numCols,

137 const Oid *eqfuncoids,

139 Oid *collations,

140 long nbuckets,

141 Size additionalsize,

145 bool use_variable_hash_iv);

159

160#ifndef FRONTEND

161

162

163

164static inline size_t

166{

168}

169

170

171

172

175{

177}

178

179

180

181

182

183

184

185

186

187static inline void *

189{

192 else

193 return NULL;

194}

195#endif

196

197

198

199

206 const char *attrName);

208 const char *attrName);

211

212

213

214

215

216

217

218

219#ifndef FRONTEND

220static inline Datum

222{

225}

226#endif

227

228

229

230

243 List *rteperminfos, bool ereport_on_violation);

245 List *mergeActions);

248 Index resultRelationIndex,

250 int instrument_options);

259 List *notnull_virtual_attrs);

269 int maxfieldlen);

276 Plan *subplan, List *auxrowmarks,

277 int epqParam, List *resultRelations);

279 Plan *subplan, List *auxrowmarks);

282

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

288

289

290

291

298

299

300

301

302

303

304

305

306#ifndef FRONTEND

309{

310 if (node->chgParam != NULL)

311 ExecReScan(node);

312

314}

315#endif

316

317

318

319

326 bool doSort, bool doHash, bool nullcheck);

330 Oid *collations,

331 int numCols,

337 const Oid *hashfunc_oids,

338 const List *collations,

339 const List *hash_exprs,

340 const bool *opstrict, PlanState *parent,

341 uint32 init_value, bool keep_nulls);

344 int numCols,

346 const Oid *eqfunctions,

347 const Oid *collations,

352 const Oid *eqfunctions,

353 const Oid *collations,

354 const List *param_exprs,

362 bool evalTargetList,

363 List *targetColnos,

372

373

374

375

376

377

378

379

380

381

382

383

384

385#ifndef FRONTEND

386static inline Datum

389 bool *isNull)

390{

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

392}

393#endif

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410#ifndef FRONTEND

411static inline void

414{

416

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

418

420}

421#endif

422

423

424

425

426

427

428#ifndef FRONTEND

429static inline Datum

432 bool *isNull)

433{

436

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

440 return retDatum;

441}

442#endif

443

444

445

446

447

448

449

450#ifndef FRONTEND

451static inline void

454{

456

460}

461#endif

462

463

464

465

466

467

468

469

470

471

472

473

474

475#ifndef FRONTEND

478{

482

483

484

485

486

488

489

491

492

493

494

495

496 slot->tts_flags &= ~TTS_FLAG_EMPTY;

498

499 return slot;

500}

501#endif

502

503

504

505

506

507

508

509

510

511#ifndef FRONTEND

512static inline bool

514{

516 bool isnull;

517

518

519 if (state == NULL)

520 return true;

521

522

524

526

527

529

531}

532#endif

533

534

535

536

537

538#ifndef FRONTEND

539static inline bool

541{

543

544

546 return ret;

547}

548#endif

549

551

552

553

554

561 bool randomAccess);

567 bool *isNull,

569

570

571

572

575

581

582

583

584

603

605{

609

616

617

618

619

620

621

622#define do_text_output_oneline(tstate, str_to_emit) \

623 do { \

624 Datum values_[1]; \

625 bool isnull_[1]; \

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

627 isnull_[0] = false; \

628 do_tup_output(tstate, values_, isnull_); \

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

630 } while (0)

631

632

633

634

635

643

644#define ResetExprContext(econtext) \

645 MemoryContextReset((econtext)->ecxt_per_tuple_memory)

646

648

649

650#define GetPerTupleExprContext(estate) \

651 ((estate)->es_per_tuple_exprcontext ? \

652 (estate)->es_per_tuple_exprcontext : \

653 MakePerTupleExprContext(estate))

654

655#define GetPerTupleMemoryContext(estate) \

656 (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)

657

658

659#define ResetPerTupleExprContext(estate) \

660 do { \

661 if ((estate)->es_per_tuple_exprcontext) \

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

663 } while (0)

664

668 bool *isfixed);

670 int nplans);

680

682

684

689

692{

694}

695

697 bool isResultRel);

700

702

709

711 bool *isNull);

713 bool *isNull);

714

717

724

730

731

732

733

738 bool update,

739 bool noDupErr,

740 bool *specConflict, List *arbiterIndexes,

741 bool onlySummarizing);

746 List *arbiterIndexes);

751 EState *estate, bool newIndex);

752

753

754

755

762

772

775

776

777

778

783 Oid resultoid,

784 bool missing_ok,

785 bool update_cache);

786

787#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)

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)

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 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 standard_ExecutorStart(QueryDesc *queryDesc, int eflags)

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)

void ExecutorStart(QueryDesc *queryDesc, int eflags)

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)

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

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)

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)

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)

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 DatumGetBool(Datum X)

static unsigned hash(unsigned *uv, int n)

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)