database/openGauss-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!2363 执行器优化

Browse Source 
Merge pull request !2363 from wanghao19920907/PR_2101
This commit is contained in:
opengauss-bot
2023-02-21 08:38:07 +00:00
committed by Gitee
parent e08956f596 cbb5b4fe37
commit d1c46bb20f
77 changed files with 378 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/include/executor/exec/execStream.h
View File

@ -118,7 +118,6 @@ typedef struct StreamState {
} StreamState;
extern StreamState* ExecInitStream(Stream* node, EState* estate, int eflags);
extern TupleTableSlot* ExecStream(StreamState* node);
extern void ExecEndStream(StreamState* node);
extern int HandleStreamResponse(PGXCNodeHandle* conn, StreamState* node);
extern void StreamPrepareRequest(StreamState* node);

43
src/include/executor/executor.h
View File

@ -252,10 +252,9 @@ extern void EvalPlanQualBegin(EPQState* epqstate, EState* parentestate, bool isU
extern void EvalPlanQualEnd(EPQState* epqstate);
/*
* prototypes from functions in execProcnode.c
* functions in execProcnode.c
*/
extern PlanState* ExecInitNode(Plan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecProcNode(PlanState* node);
extern Node* MultiExecProcNode(PlanState* node);
extern void ExecEndNode(PlanState* node);
extern bool NeedStubExecution(Plan* plan);
@ -263,6 +262,46 @@ extern TupleTableSlot* FetchPlanSlot(PlanState* subPlanState, ProjectionInfo** p
extern long ExecGetPlanMemCost(Plan* node);
/* ----------------------------------------------------------------
* ExecProcNode
*
* Execute the given node to return a(nother) tuple.
* ----------------------------------------------------------------
*/
#ifndef FRONTEND
#ifndef ENABLE_MULTIPLE_NODES
static inline TupleTableSlot *ExecProcNode(PlanState *node)
{
TupleTableSlot* result;
Assert(node->ExecProcNode);
if (unlikely(node->nodeContext)) {
MemoryContext old_context = MemoryContextSwitchTo(node->nodeContext); /* Switch to Node Level Memory Context */
if (node->chgParam != NULL) /* something changed? */
ExecReScan(node); /* let ReScan handle this */
result = node->ExecProcNode(node);
MemoryContextSwitchTo(old_context);
} else {
if (node->chgParam != NULL) /* something changed? */
ExecReScan(node);
result = node->ExecProcNode(node);
}
node->ps_rownum++;
return result;
}
#else /*ENABLE_MULTIPLE_NODES*/
static inline TupleTableSlot *ExecProcNode(PlanState *node)
{
//TODO: FIX ENABLE_MULTIPLE_NODES
return NULL;
}
#endif /*ENABLE_MULTIPLE_NODES*/
#endif /*FRONTEND*/
/*
* prototypes from functions in execQual.c
*/

1
src/include/executor/node/nodeAgg.h
View File

@ -268,7 +268,6 @@ typedef struct AggHashEntryData {
} AggHashEntryData; /* VARIABLE LENGTH STRUCT */
extern AggState* ExecInitAgg(Agg* node, EState* estate, int eflags);
extern TupleTableSlot* ExecAgg(AggState* node);
extern void ExecEndAgg(AggState* node);
extern void ExecReScanAgg(AggState* node);
extern Datum GetAggInitVal(Datum textInitVal, Oid transtype);

1
src/include/executor/node/nodeAppend.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern AppendState* ExecInitAppend(Append* node, EState* estate, int eflags);
extern TupleTableSlot* ExecAppend(AppendState* node);
extern void ExecEndAppend(AppendState* node);
extern void ExecReScanAppend(AppendState* node);
extern bool exec_append_initialize_next(AppendState* appendstate);

1
src/include/executor/node/nodeBitmapHeapscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern BitmapHeapScanState* ExecInitBitmapHeapScan(BitmapHeapScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecBitmapHeapScan(BitmapHeapScanState* node);
extern void ExecEndBitmapHeapScan(BitmapHeapScanState* node);
extern void ExecReScanBitmapHeapScan(BitmapHeapScanState* node);

2
src/include/executor/node/nodeCtescan.h
View File

@ -18,7 +18,6 @@
#include "nodes/execnodes.h"
extern CteScanState* ExecInitCteScan(CteScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecCteScan(CteScanState* node);
extern void ExecEndCteScan(CteScanState* node);
extern void ExecReScanCteScan(CteScanState* node);
@ -38,7 +37,6 @@ typedef struct StartWithFuncEvalState
} StartWithFuncEvalState;
extern StartWithOpState* ExecInitStartWithOp(StartWithOp* node, EState* estate, int eflags);
extern TupleTableSlot* ExecStartWithOp(StartWithOpState *node);
extern void ExecEndStartWithOp(StartWithOpState *node);
extern void ExecReScanStartWithOp(StartWithOpState *node);

1
src/include/executor/node/nodeExtensible.h
View File

@ -31,7 +31,6 @@
* General executor code
*/
extern ExtensiblePlanState* ExecInitExtensiblePlan(ExtensiblePlan* eplan, EState* estate, int eflags);
extern TupleTableSlot* ExecExtensiblePlan(ExtensiblePlanState* node);
extern void ExecEndExtensiblePlan(ExtensiblePlanState* node);
extern void ExecReScanExtensiblePlan(ExtensiblePlanState* node);

1
src/include/executor/node/nodeForeignscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern ForeignScanState* ExecInitForeignScan(ForeignScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecForeignScan(ForeignScanState* node);
extern void ExecEndForeignScan(ForeignScanState* node);
extern void ExecReScanForeignScan(ForeignScanState* node);

1
src/include/executor/node/nodeFunctionscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern FunctionScanState* ExecInitFunctionScan(FunctionScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecFunctionScan(FunctionScanState* node);
extern void ExecEndFunctionScan(FunctionScanState* node);
extern void ExecReScanFunctionScan(FunctionScanState* node);

1
src/include/executor/node/nodeGroup.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern GroupState* ExecInitGroup(Group* node, EState* estate, int eflags);
extern TupleTableSlot* ExecGroup(GroupState* node);
extern void ExecEndGroup(GroupState* node);
extern void ExecReScanGroup(GroupState* node);

1
src/include/executor/node/nodeHash.h
View File

@ -21,7 +21,6 @@
#define BUCKET_OVERHEAD 8
extern HashState* ExecInitHash(Hash* node, EState* estate, int eflags);
extern TupleTableSlot* ExecHash(void);
extern Node* MultiExecHash(HashState* node);
extern void ExecEndHash(HashState* node);
extern void ExecReScanHash(HashState* node);

1
src/include/executor/node/nodeHashjoin.h
View File

@ -19,7 +19,6 @@
#include "optimizer/planmem_walker.h"
extern HashJoinState* ExecInitHashJoin(HashJoin* node, EState* estate, int eflags);
extern TupleTableSlot* ExecHashJoin(HashJoinState* node);
extern void ExecEndHashJoin(HashJoinState* node);
extern void ExecReScanHashJoin(HashJoinState* node);
extern void ExecHashJoinSaveTuple(MinimalTuple tuple, uint32 hashvalue, BufFile** fileptr);

1
src/include/executor/node/nodeIndexonlyscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern IndexOnlyScanState* ExecInitIndexOnlyScan(IndexOnlyScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecIndexOnlyScan(IndexOnlyScanState* node);
extern void ExecEndIndexOnlyScan(IndexOnlyScanState* node);
extern void ExecIndexOnlyMarkPos(IndexOnlyScanState* node);
extern void ExecIndexOnlyRestrPos(IndexOnlyScanState* node);

1
src/include/executor/node/nodeIndexscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern IndexScanState* ExecInitIndexScan(IndexScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecIndexScan(IndexScanState* node);
extern void ExecEndIndexScan(IndexScanState* node);
extern void ExecIndexMarkPos(IndexScanState* node);
extern void ExecIndexRestrPos(IndexScanState* node);

1
src/include/executor/node/nodeLimit.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern LimitState* ExecInitLimit(Limit* node, EState* estate, int eflags);
extern TupleTableSlot* ExecLimit(LimitState* node);
extern void ExecEndLimit(LimitState* node);
extern void ExecReScanLimit(LimitState* node);
extern void recompute_limits(LimitState* node);

1
src/include/executor/node/nodeLockRows.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern LockRowsState* ExecInitLockRows(LockRows* node, EState* estate, int eflags);
extern TupleTableSlot* ExecLockRows(LockRowsState* node);
extern void ExecEndLockRows(LockRowsState* node);
extern void ExecReScanLockRows(LockRowsState* node);

1
src/include/executor/node/nodeMaterial.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern MaterialState* ExecInitMaterial(Material* node, EState* estate, int eflags);
extern TupleTableSlot* ExecMaterial(MaterialState* node);
extern void ExecEndMaterial(MaterialState* node);
extern void ExecMaterialMarkPos(MaterialState* node);
extern void ExecMaterialRestrPos(MaterialState* node);

1
src/include/executor/node/nodeMergeAppend.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern MergeAppendState* ExecInitMergeAppend(MergeAppend* node, EState* estate, int eflags);
extern TupleTableSlot* ExecMergeAppend(MergeAppendState* node);
extern void ExecEndMergeAppend(MergeAppendState* node);
extern void ExecReScanMergeAppend(MergeAppendState* node);

1
src/include/executor/node/nodeMergejoin.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern MergeJoinState* ExecInitMergeJoin(MergeJoin* node, EState* estate, int eflags);
extern TupleTableSlot* ExecMergeJoin(MergeJoinState* node);
extern void ExecEndMergeJoin(MergeJoinState* node);
extern void ExecReScanMergeJoin(MergeJoinState* node);

1
src/include/executor/node/nodeModifyTable.h
View File

@ -22,7 +22,6 @@ typedef TupleTableSlot* (*ExecUpdateMtd)(ItemPointer, Oid, Oid, HeapTupleHeader,
TupleTableSlot*, EPQState*, ModifyTableState*, bool, bool);
extern ModifyTableState* ExecInitModifyTable(ModifyTable* node, EState* estate, int eflags);
extern TupleTableSlot* ExecModifyTable(ModifyTableState* node);
extern void ExecEndModifyTable(ModifyTableState* node);
extern void ExecReScanModifyTable(ModifyTableState* node);
extern void RecordDeletedTuple(Oid relid, int2 bucketid, const ItemPointer tupleid, const Relation deldelta_rel);

1
src/include/executor/node/nodeNestloop.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern NestLoopState* ExecInitNestLoop(NestLoop* node, EState* estate, int eflags);
extern TupleTableSlot* ExecNestLoop(NestLoopState* node);
extern void ExecEndNestLoop(NestLoopState* node);
extern void ExecReScanNestLoop(NestLoopState* node);

1
src/include/executor/node/nodePartIterator.h
View File

@ -32,7 +32,6 @@
extern void SetPartitionIteratorParamter(PartIteratorState* node, List* subPartLengthList);
extern PartIteratorState* ExecInitPartIterator(PartIterator* node, EState* estate, int eflags);
extern TupleTableSlot* ExecPartIterator(PartIteratorState* node);
extern void ExecEndPartIterator(PartIteratorState* node);
extern void ExecReScanPartIterator(PartIteratorState* node);

1
src/include/executor/node/nodeRecursiveunion.h
View File

@ -215,7 +215,6 @@ typedef struct RecursiveRefContext {
extern void set_recursive_cteplan_ref(Plan* node, RecursiveRefContext* context);
extern RecursiveUnionState* ExecInitRecursiveUnion(RecursiveUnion* node, EState* estate, int eflags);
extern TupleTableSlot* ExecRecursiveUnion(RecursiveUnionState* node);
extern void ExecEndRecursiveUnion(RecursiveUnionState* node);
extern void ExecReScanRecursiveUnion(RecursiveUnionState* node);
extern bool IsFirstLevelStreamStateNode(StreamState* node);

1
src/include/executor/node/nodeResult.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern ResultState* ExecInitResult(BaseResult* node, EState* estate, int eflags);
extern TupleTableSlot* ExecResult(ResultState* node);
extern void ExecEndResult(ResultState* node);
extern void ExecResultMarkPos(ResultState* node);
extern void ExecResultRestrPos(ResultState* node);

1
src/include/executor/node/nodeSeqscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern SeqScanState* ExecInitSeqScan(SeqScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecSeqScan(SeqScanState* node);
extern void ExecEndSeqScan(SeqScanState* node);
extern void ExecSeqMarkPos(SeqScanState* node);
extern void ExecSeqRestrPos(SeqScanState* node);

1
src/include/executor/node/nodeSetOp.h
View File

@ -29,7 +29,6 @@ typedef struct SetopWriteFileControl : public AggWriteFileControl {
} SetopWriteFileControl;
extern SetOpState* ExecInitSetOp(SetOp* node, EState* estate, int eflags);
extern TupleTableSlot* ExecSetOp(SetOpState* node);
extern void ExecEndSetOp(SetOpState* node);
extern void ExecReScanSetOp(SetOpState* node);
extern void ExecEarlyFreeHashedSetop(SetOpState* node);

1
src/include/executor/node/nodeSort.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern SortState* ExecInitSort(Sort* node, EState* estate, int eflags);
extern TupleTableSlot* ExecSort(SortState* node);
extern void ExecEndSort(SortState* node);
extern void ExecSortMarkPos(SortState* node);
extern void ExecSortRestrPos(SortState* node);

1
src/include/executor/node/nodeSubqueryscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern SubqueryScanState* ExecInitSubqueryScan(SubqueryScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecSubqueryScan(SubqueryScanState* node);
extern void ExecEndSubqueryScan(SubqueryScanState* node);
extern void ExecReScanSubqueryScan(SubqueryScanState* node);

1
src/include/executor/node/nodeTidscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern TidScanState* ExecInitTidScan(TidScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecTidScan(TidScanState* node);
extern void ExecEndTidScan(TidScanState* node);
extern void ExecTidMarkPos(TidScanState* node);
extern void ExecTidRestrPos(TidScanState* node);

1
src/include/executor/node/nodeTrainModel.h
View File

@ -27,7 +27,6 @@
#include "nodes/execnodes.h"
extern TrainModelState* ExecInitTrainModel(TrainModel* node, EState* estate, int eflags);
extern TupleTableSlot* ExecTrainModel(TrainModelState* state);
extern void ExecEndTrainModel(TrainModelState* state);
#endif /* NODE_TRAIN_MODEL_H */

1
src/include/executor/node/nodeUnique.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern UniqueState* ExecInitUnique(Unique* node, EState* estate, int eflags);
extern TupleTableSlot* ExecUnique(UniqueState* node);
extern void ExecEndUnique(UniqueState* node);
extern void ExecReScanUnique(UniqueState* node);

1
src/include/executor/node/nodeValuesscan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern ValuesScanState* ExecInitValuesScan(ValuesScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecValuesScan(ValuesScanState* node);
extern void ExecEndValuesScan(ValuesScanState* node);
extern void ExecValuesMarkPos(ValuesScanState* node);
extern void ExecValuesRestrPos(ValuesScanState* node);

1
src/include/executor/node/nodeWindowAgg.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern WindowAggState* ExecInitWindowAgg(WindowAgg* node, EState* estate, int eflags);
extern TupleTableSlot* ExecWindowAgg(WindowAggState* node);
extern void ExecEndWindowAgg(WindowAggState* node);
extern void ExecReScanWindowAgg(WindowAggState* node);

1
src/include/executor/node/nodeWorktablescan.h
View File

@ -17,7 +17,6 @@
#include "nodes/execnodes.h"
extern WorkTableScanState* ExecInitWorkTableScan(WorkTableScan* node, EState* estate, int eflags);
extern TupleTableSlot* ExecWorkTableScan(WorkTableScanState* node);
extern void ExecEndWorkTableScan(WorkTableScanState* node);
extern void ExecReScanWorkTableScan(WorkTableScanState* node);