From e9689618f2889f224eb62e9ff4fb5251285ecdb3 Mon Sep 17 00:00:00 2001 From: Amit Langote Date: Tue, 11 Nov 2025 21:47:46 +0900 Subject: [PATCH v1 2/4] Introduce ExecutorPrep infrastructure for pre-execution setup Add ExecutorPrep() and ExecPrep to support setting up executor metadata like range table initialization and partition pruning ahead of actual execution. This enables execution paths to perform setup independently of running the plan. For example, plan validation can compute and consume this metadata without executing the query. Parallel query workers can receive pre-initialized state from the leader and pass it to ExecutorStart, avoiding redundant setup. ExecutorStart now accepts a prep-estate from QueryDesc to skip repeating initialization. The ExecPrep wrapper manages cleanup and signals ownership of the estate. PrepPlan() encapsulates shared setup logic. Call sites, including Portal, SPI, and EXPLAIN, are updated to support passing down the prep data. These changes are mostly mechanical and clarify the separation between setup and actual execution. --- src/backend/commands/copyto.c | 2 +- src/backend/commands/createas.c | 2 +- src/backend/commands/explain.c | 7 +- src/backend/commands/extension.c | 1 + src/backend/commands/matview.c | 2 +- src/backend/commands/portalcmds.c | 1 + src/backend/commands/prepare.c | 11 +- src/backend/executor/README | 9 +- src/backend/executor/execMain.c | 192 +++++++++++++++++++++++---- src/backend/executor/execParallel.c | 1 + src/backend/executor/execPartition.c | 3 + src/backend/executor/functions.c | 1 + src/backend/executor/spi.c | 10 ++ src/backend/tcop/postgres.c | 2 + src/backend/tcop/pquery.c | 27 +++- src/backend/utils/mmgr/portalmem.c | 2 + src/include/commands/explain.h | 3 +- src/include/executor/execdesc.h | 3 +- src/include/executor/executor.h | 10 ++ src/include/nodes/execnodes.h | 55 ++++++++ src/include/utils/portal.h | 2 + 21 files changed, 308 insertions(+), 38 deletions(-) diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c index cef452584e5..5efbb0949c2 100644 --- a/src/backend/commands/copyto.c +++ b/src/backend/commands/copyto.c @@ -870,7 +870,7 @@ BeginCopyTo(ParseState *pstate, ((DR_copy *) dest)->cstate = cstate; /* Create a QueryDesc requesting no output */ - cstate->queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext, + cstate->queryDesc = CreateQueryDesc(plan, NULL, pstate->p_sourcetext, GetActiveSnapshot(), InvalidSnapshot, dest, NULL, NULL, 0); diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c index 1ccc2e55c64..9eabe4920cd 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -334,7 +334,7 @@ ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt, UpdateActiveSnapshotCommandId(); /* Create a QueryDesc, redirecting output to our tuple receiver */ - queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext, + queryDesc = CreateQueryDesc(plan, NULL, pstate->p_sourcetext, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, 0); diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index 7e699f8595e..d6ab3697dd9 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -370,7 +370,7 @@ standard_ExplainOneQuery(Query *query, int cursorOptions, } /* run it (if needed) and produce output */ - ExplainOnePlan(plan, into, es, queryString, params, queryEnv, + ExplainOnePlan(plan, NULL, into, es, queryString, params, queryEnv, &planduration, (es->buffers ? &bufusage : NULL), es->memory ? &mem_counters : NULL); } @@ -492,7 +492,8 @@ ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, * to call it. */ void -ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, +ExplainOnePlan(PlannedStmt *plannedstmt, ExecPrep *prep, + IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage, @@ -548,7 +549,7 @@ ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, dest = None_Receiver; /* Create a QueryDesc for the query */ - queryDesc = CreateQueryDesc(plannedstmt, queryString, + queryDesc = CreateQueryDesc(plannedstmt, prep, queryString, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, instrument_option); diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index 93ef1ad106f..3cca6d45ec1 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -993,6 +993,7 @@ execute_sql_string(const char *sql, const char *filename) QueryDesc *qdesc; qdesc = CreateQueryDesc(stmt, + NULL, sql, GetActiveSnapshot(), NULL, dest, NULL, NULL, 0); diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c index ef7c0d624f1..30cbf9f264f 100644 --- a/src/backend/commands/matview.c +++ b/src/backend/commands/matview.c @@ -437,7 +437,7 @@ refresh_matview_datafill(DestReceiver *dest, Query *query, UpdateActiveSnapshotCommandId(); /* Create a QueryDesc, redirecting output to our tuple receiver */ - queryDesc = CreateQueryDesc(plan, queryString, + queryDesc = CreateQueryDesc(plan, NULL, queryString, GetActiveSnapshot(), InvalidSnapshot, dest, NULL, NULL, 0); diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c index ec96c2efcd3..ac1ddd25aba 100644 --- a/src/backend/commands/portalcmds.c +++ b/src/backend/commands/portalcmds.c @@ -118,6 +118,7 @@ PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo pa queryString, CMDTAG_SELECT, /* cursor's query is always a SELECT */ list_make1(plan), + list_make1(NULL), NULL); /*---------- diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index 34b6410d6a2..afd449c73ba 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -205,6 +205,7 @@ ExecuteQuery(ParseState *pstate, query_string, entry->plansource->commandTag, plan_list, + NIL, cplan); /* @@ -575,6 +576,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, const char *query_string; CachedPlan *cplan; List *plan_list; + List *prep_list; ListCell *p; ParamListInfo paramLI = NULL; EState *estate = NULL; @@ -585,6 +587,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, MemoryContextCounters mem_counters; MemoryContext planner_ctx = NULL; MemoryContext saved_ctx = NULL; + int i; if (es->memory) { @@ -650,14 +653,20 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, } plan_list = cplan->stmt_list; + prep_list = NIL; /* Explain each query */ + i = 0; foreach(p, plan_list) { PlannedStmt *pstmt = lfirst_node(PlannedStmt, p); + ExecPrep *prep = prep_list ? + (ExecPrep *) list_nth(prep_list, i) : NULL; + i++; if (pstmt->commandType != CMD_UTILITY) - ExplainOnePlan(pstmt, into, es, query_string, paramLI, pstate->p_queryEnv, + ExplainOnePlan(pstmt, prep, + into, es, query_string, paramLI, pstate->p_queryEnv, &planduration, (es->buffers ? &bufusage : NULL), es->memory ? &mem_counters : NULL); else diff --git a/src/backend/executor/README b/src/backend/executor/README index 54f4782f31b..6e481398f18 100644 --- a/src/backend/executor/README +++ b/src/backend/executor/README @@ -291,10 +291,17 @@ Query Processing Control Flow This is a sketch of control flow for full query processing: + [Optional] ExecutorPrep + - May be run before ExecutorStart (e.g., for plan validation). + - Performs range table initialization, permission checks, and + initial partition pruning. + - Returns an ExecPrep wrapper with EState that ExecutorStart may + reuse. + CreateQueryDesc ExecutorStart - CreateExecutorState + CreateExecutorState (or reuse one from ExecPrep if present) creates per-query context switch to per-query context to run ExecInitNode AfterTriggerBeginQuery diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index 27c9eec697b..1b96b251c34 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -75,6 +75,7 @@ ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook = NULL; /* decls for local routines only used within this module */ static void InitPlan(QueryDesc *queryDesc, int eflags); +static void PrepPlan(EState *estate, bool do_initial_pruning); static void CheckValidRowMarkRel(Relation rel, RowMarkType markType); static void ExecPostprocessPlan(EState *estate); static void ExecEndPlan(PlanState *planstate, EState *estate); @@ -171,8 +172,24 @@ standard_ExecutorStart(QueryDesc *queryDesc, int eflags) /* * Build EState, switch into per-query memory context for startup. + * + * If ExecutorPrep() ran earlier (e.g., to do initial pruning during plan + * validity checking), reuse its EState to avoid redoing range table setup + * and pruning. Otherwise, create a fresh EState as usual. */ - estate = CreateExecutorState(); + if (queryDesc->prep) + { + estate = queryDesc->prep->prep_estate; + + /* + * Executor is adopting the prep's EState. Mark it so ExecPrepCleanup() + * doesn't try to free it redundantly. + */ + queryDesc->prep->owns_estate = false; + } + else + estate = CreateExecutorState(); + queryDesc->estate = estate; oldcontext = MemoryContextSwitchTo(estate->es_query_cxt); @@ -263,6 +280,143 @@ standard_ExecutorStart(QueryDesc *queryDesc, int eflags) MemoryContextSwitchTo(oldcontext); } +/* + * ExecutorPrep: prepare executor state for a PlannedStmt outside ExecutorStart. + * + * Performs range table initialization, permission checks, and initial + * partition pruning if partPruneInfos are present and do_initial_pruning is + * true. + * + * This is intended for callers that need executor metadata ahead of actual + * execution. Typical use cases include: + * - determining which relations must be locked during plan cache validation; + * - initializing unpruned relids and valid subplans in parallel workers + * using state copied from the leader. + * + * The executor can reuse the resulting state to avoid redundant setup during + * ExecutorStart(); see InitPlan(). + * + * Returns an ExecPrep wrapper that owns the EState and can be reused + * or cleaned up later. Returns NULL if no prep is needed (e.g. no pruning). + */ +ExecPrep * +ExecutorPrep(PlannedStmt *pstmt, ParamListInfo params, ResourceOwner owner, + bool do_initial_pruning) +{ + ResourceOwner oldowner; + EState *estate; + + Assert(pstmt->commandType != CMD_UTILITY); + + /* No pruning needed -- let normal ExecutorStart handle setup later. */ + if (pstmt->partPruneInfos == NIL) + return NULL; + + estate = CreateExecutorState(); + estate->es_plannedstmt = pstmt; + estate->es_part_prune_infos = pstmt->partPruneInfos; + estate->es_param_list_info = params; + + /* + * Ensure locks taken during initial pruning are tracked under the given + * ResourceOwner (e.g., one associated with CachedPlan validation). + */ + oldowner = CurrentResourceOwner; + CurrentResourceOwner = owner; + + PrepPlan(estate, do_initial_pruning); + + CurrentResourceOwner = oldowner; + + return CreateExecPrep(estate, CurrentMemoryContext, NULL, NULL); +} + +/* + * PrepPlan: initialize executor metadata needed before plan execution. + * + * Sets up permissions, range table, and partition pruning infrastructure. + * If do_initial_pruning is true, performs initial pruning and stores the + * resulting subplan indexes in es_part_prune_results. Otherwise, this step + * is skipped, typically when results are provided externally (e.g., in + * parallel workers). + * + * Called from both ExecutorPrep() and InitPlan(). + */ +static void +PrepPlan(EState *estate, bool do_initial_pruning) +{ + PlannedStmt *pstmt = estate->es_plannedstmt; + + /* + * Do permissions checks. + */ + ExecCheckPermissions(pstmt->rtable, pstmt->permInfos, true); + + /* + * Initialize range table. + */ + ExecInitRangeTable(estate, pstmt->rtable, pstmt->permInfos, + bms_copy(pstmt->unprunableRelids)); + + /* + * Set up PartitionPruneState structures needed for both initial and + * runtime partition pruning. These structures are built from the + * PartitionPruneInfo entries in the plan tree. + * + * If do_initial_pruning is true, also perform initial pruning to compute + * the subset of child subplans that will be executed. The results, + * which are bitmapsets of selected child indexes, are saved in + * es_part_prune_results. This list is parallel to es_part_prune_infos. + * + * In parallel workers, do_initial_pruning should be false — they receive + * es_part_prune_results from the leader process and should only initialize + * the PartitionPruneStates. + */ + ExecCreatePartitionPruneStates(estate); + if (do_initial_pruning) + ExecDoInitialPruning(estate); +} + +/* + * CreateExecPrep: initialize ExecPrep wrapper with optional cleanup metadata. + */ +ExecPrep * +CreateExecPrep(EState *estate, MemoryContext context, + execprep_cleanup_fn cleanup, void *cleanup_arg) +{ + ExecPrep *prep = palloc0(sizeof(ExecPrep)); + + prep->prep_estate = estate; + prep->context = context; + prep->cleanup = cleanup; + prep->cleanup_arg = cleanup_arg; + prep->owns_estate = true; + + return prep; +} + +/* + * ExecPrepCleanup: free ExecPrep resources not adopted by the executor. + * + * Only frees the EState if it wasn't taken over by ExecutorStart(). + * Always runs the optional user-defined cleanup callback. + */ +void +ExecPrepCleanup(ExecPrep *prep) +{ + if (prep == NULL) + return; + + if (prep->prep_estate && prep->owns_estate) + { + ExecCloseRangeTableRelations(prep->prep_estate); + FreeExecutorState(prep->prep_estate); + } + + if (prep->cleanup) + prep->cleanup(prep->cleanup_arg); +} + /* ---------------------------------------------------------------- * ExecutorRun * @@ -824,7 +978,6 @@ ExecCheckXactReadOnly(PlannedStmt *plannedstmt) PreventCommandIfParallelMode(CreateCommandName((Node *) plannedstmt)); } - /* ---------------------------------------------------------------- * InitPlan * @@ -838,7 +991,6 @@ InitPlan(QueryDesc *queryDesc, int eflags) CmdType operation = queryDesc->operation; PlannedStmt *plannedstmt = queryDesc->plannedstmt; Plan *plan = plannedstmt->planTree; - List *rangeTable = plannedstmt->rtable; EState *estate = queryDesc->estate; PlanState *planstate; TupleDesc tupType; @@ -846,29 +998,19 @@ InitPlan(QueryDesc *queryDesc, int eflags) int i; /* - * Do permissions checks + * If ExecutorPrep() was not run earlier (e.g., during plan validation), + * perform InitPlan setup: init range table, check permissions, and run + * initial pruning. Otherwise, the executor will reuse the same information + * in queryDesc->prep->prep_estate. */ - ExecCheckPermissions(rangeTable, plannedstmt->permInfos, true); - - /* - * initialize the node's execution state - */ - ExecInitRangeTable(estate, rangeTable, plannedstmt->permInfos, - bms_copy(plannedstmt->unprunableRelids)); - - estate->es_plannedstmt = plannedstmt; - estate->es_part_prune_infos = plannedstmt->partPruneInfos; - - /* - * Perform runtime "initial" pruning to identify which child subplans, - * corresponding to the children of plan nodes that contain - * PartitionPruneInfo such as Append, will not be executed. The results, - * which are bitmapsets of indexes of the child subplans that will be - * executed, are saved in es_part_prune_results. These results correspond - * to each PartitionPruneInfo entry, and the es_part_prune_results list is - * parallel to es_part_prune_infos. - */ - ExecDoInitialPruning(estate); + if (queryDesc->prep == NULL) + { + estate->es_plannedstmt = plannedstmt; + estate->es_part_prune_infos = plannedstmt->partPruneInfos; + PrepPlan(estate, true); + } + else + Assert(estate == queryDesc->prep->prep_estate); /* * Next, build the ExecRowMark array from the PlanRowMark(s), if any. diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c index f098a5557cf..aedbd9566d6 100644 --- a/src/backend/executor/execParallel.c +++ b/src/backend/executor/execParallel.c @@ -1281,6 +1281,7 @@ ExecParallelGetQueryDesc(shm_toc *toc, DestReceiver *receiver, /* Create a QueryDesc for the query. */ return CreateQueryDesc(pstmt, + NULL, queryString, GetActiveSnapshot(), InvalidSnapshot, receiver, paramLI, NULL, instrument_options); diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c index 88b150c8d77..187a480e508 100644 --- a/src/backend/executor/execPartition.c +++ b/src/backend/executor/execPartition.c @@ -2368,6 +2368,9 @@ InitExecPartitionPruneContexts(PartitionPruneState *prunestate, Assert(parent_plan != NULL); estate = parent_plan->state; + /* Wouldn't be available at ExecutorPrep() time. */ + prunestate->econtext->ecxt_param_exec_vals = estate->es_param_exec_vals; + /* * No need to fix subplans maps if initial pruning didn't eliminate any * subplans. diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c index 630d708d2a3..633310c5f5b 100644 --- a/src/backend/executor/functions.c +++ b/src/backend/executor/functions.c @@ -1362,6 +1362,7 @@ postquel_start(execution_state *es, SQLFunctionCachePtr fcache) dest = None_Receiver; es->qd = CreateQueryDesc(es->stmt, + NULL, fcache->func->src, GetActiveSnapshot(), InvalidSnapshot, diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index 653500b38dc..7a3cb944d6f 100644 --- a/src/backend/executor/spi.c +++ b/src/backend/executor/spi.c @@ -1685,6 +1685,7 @@ SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, query_string, plansource->commandTag, stmt_list, + NIL, cplan); /* @@ -2500,6 +2501,8 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options, CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc1); List *stmt_list; ListCell *lc2; + List *prep_list; + int i; spicallbackarg.query = plansource->query_string; @@ -2578,6 +2581,7 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options, plan_owner, _SPI_current->queryEnv); stmt_list = cplan->stmt_list; + prep_list = NIL; /* * If we weren't given a specific snapshot to use, and the statement @@ -2615,12 +2619,17 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options, } } + i = 0; foreach(lc2, stmt_list) { PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2); + ExecPrep *prep = prep_list ? + list_nth(prep_list, i) : NULL; bool canSetTag = stmt->canSetTag; DestReceiver *dest; + i++; + /* * Reset output state. (Note that if a non-SPI receiver is used, * _SPI_current->processed will stay zero, and that's what we'll @@ -2690,6 +2699,7 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options, snap = InvalidSnapshot; qdesc = CreateQueryDesc(stmt, + prep, plansource->query_string, snap, crosscheck_snapshot, dest, diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 2bd89102686..d3964a12a14 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -1232,6 +1232,7 @@ exec_simple_query(const char *query_string) query_string, commandTag, plantree_list, + NIL, NULL); /* @@ -2033,6 +2034,7 @@ exec_bind_message(StringInfo input_message) query_string, psrc->commandTag, cplan->stmt_list, + NIL, cplan); /* Portal is defined, set the plan ID based on its contents. */ diff --git a/src/backend/tcop/pquery.c b/src/backend/tcop/pquery.c index fde78c55160..82c295502b0 100644 --- a/src/backend/tcop/pquery.c +++ b/src/backend/tcop/pquery.c @@ -37,6 +37,7 @@ Portal ActivePortal = NULL; static void ProcessQuery(PlannedStmt *plan, + ExecPrep *prep, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, @@ -66,6 +67,7 @@ static void DoPortalRewind(Portal portal); */ QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, + ExecPrep *prep, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, @@ -78,6 +80,7 @@ CreateQueryDesc(PlannedStmt *plannedstmt, qd->operation = plannedstmt->commandType; /* operation */ qd->plannedstmt = plannedstmt; /* plan */ + qd->prep = prep; /* executor prep output */ qd->sourceText = sourceText; /* query text */ qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */ /* RI check snapshot */ @@ -112,6 +115,13 @@ FreeQueryDesc(QueryDesc *qdesc) UnregisterSnapshot(qdesc->snapshot); UnregisterSnapshot(qdesc->crosscheck_snapshot); + /* ExecPrep cleanup if necessary */ + if (qdesc->prep) + { + ExecPrepCleanup(qdesc->prep); + qdesc->prep = NULL; + } + /* Only the QueryDesc itself need be freed */ pfree(qdesc); } @@ -123,6 +133,7 @@ FreeQueryDesc(QueryDesc *qdesc) * PORTAL_ONE_RETURNING, or PORTAL_ONE_MOD_WITH portal * * plan: the plan tree for the query + * prep: ExecPrep for the plan (output of ExecutorPrep()) * sourceText: the source text of the query * params: any parameters needed * dest: where to send results @@ -135,6 +146,7 @@ FreeQueryDesc(QueryDesc *qdesc) */ static void ProcessQuery(PlannedStmt *plan, + ExecPrep *prep, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, @@ -146,7 +158,7 @@ ProcessQuery(PlannedStmt *plan, /* * Create the QueryDesc object */ - queryDesc = CreateQueryDesc(plan, sourceText, + queryDesc = CreateQueryDesc(plan, prep, sourceText, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, 0); @@ -489,6 +501,9 @@ PortalStart(Portal portal, ParamListInfo params, * the destination to DestNone. */ queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts), + portal->preps ? + (ExecPrep *) linitial(portal->preps) : + NULL, portal->sourceText, GetActiveSnapshot(), InvalidSnapshot, @@ -1185,6 +1200,7 @@ PortalRunMulti(Portal portal, { bool active_snapshot_set = false; ListCell *stmtlist_item; + int i; /* * If the destination is DestRemoteExecute, change to DestNone. The @@ -1205,9 +1221,14 @@ PortalRunMulti(Portal portal, * Loop to handle the individual queries generated from a single parsetree * by analysis and rewrite. */ + i = 0; foreach(stmtlist_item, portal->stmts) { PlannedStmt *pstmt = lfirst_node(PlannedStmt, stmtlist_item); + ExecPrep *prep = portal->preps ? + list_nth(portal->preps, i) : NULL; + + i++; /* * If we got a cancel signal in prior command, quit @@ -1265,7 +1286,7 @@ PortalRunMulti(Portal portal, if (pstmt->canSetTag) { /* statement can set tag string */ - ProcessQuery(pstmt, + ProcessQuery(pstmt, prep, portal->sourceText, portal->portalParams, portal->queryEnv, @@ -1274,7 +1295,7 @@ PortalRunMulti(Portal portal, else { /* stmt added by rewrite cannot set tag */ - ProcessQuery(pstmt, + ProcessQuery(pstmt, prep, portal->sourceText, portal->portalParams, portal->queryEnv, diff --git a/src/backend/utils/mmgr/portalmem.c b/src/backend/utils/mmgr/portalmem.c index 943da087c9f..313f8ef2fdc 100644 --- a/src/backend/utils/mmgr/portalmem.c +++ b/src/backend/utils/mmgr/portalmem.c @@ -284,6 +284,7 @@ PortalDefineQuery(Portal portal, const char *sourceText, CommandTag commandTag, List *stmts, + List *preps, CachedPlan *cplan) { Assert(PortalIsValid(portal)); @@ -298,6 +299,7 @@ PortalDefineQuery(Portal portal, portal->qc.nprocessed = 0; portal->commandTag = commandTag; portal->stmts = stmts; + portal->preps = preps; portal->cplan = cplan; portal->status = PORTAL_DEFINED; } diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h index 6e51d50efc7..6aa8b275aa2 100644 --- a/src/include/commands/explain.h +++ b/src/include/commands/explain.h @@ -63,7 +63,8 @@ extern void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params); -extern void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, +extern void ExplainOnePlan(PlannedStmt *plannedstmt, ExecPrep *prep, + IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, diff --git a/src/include/executor/execdesc.h b/src/include/executor/execdesc.h index 86db3dc8d0d..c18530f5d11 100644 --- a/src/include/executor/execdesc.h +++ b/src/include/executor/execdesc.h @@ -18,7 +18,6 @@ #include "nodes/execnodes.h" #include "tcop/dest.h" - /* ---------------- * query descriptor: * @@ -35,6 +34,7 @@ typedef struct QueryDesc /* These fields are provided by CreateQueryDesc */ CmdType operation; /* CMD_SELECT, CMD_UPDATE, etc. */ PlannedStmt *plannedstmt; /* planner's output (could be utility, too) */ + ExecPrep *prep; /* output of ExecutorPrep() or NULL */ const char *sourceText; /* source text of the query */ Snapshot snapshot; /* snapshot to use for query */ Snapshot crosscheck_snapshot; /* crosscheck for RI update/delete */ @@ -57,6 +57,7 @@ typedef struct QueryDesc /* in pquery.c */ extern QueryDesc *CreateQueryDesc(PlannedStmt *plannedstmt, + ExecPrep *prep, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h index fa2b657fb2f..bc90d0ea7ee 100644 --- a/src/include/executor/executor.h +++ b/src/include/executor/executor.h @@ -20,6 +20,7 @@ #include "nodes/lockoptions.h" #include "nodes/parsenodes.h" #include "utils/memutils.h" +#include "utils/resowner.h" /* @@ -234,6 +235,15 @@ ExecGetJunkAttribute(TupleTableSlot *slot, AttrNumber attno, bool *isNull) */ extern void ExecutorStart(QueryDesc *queryDesc, int eflags); extern void standard_ExecutorStart(QueryDesc *queryDesc, int eflags); + +extern ExecPrep *ExecutorPrep(PlannedStmt *pstmt, + ParamListInfo params, + ResourceOwner owner, + bool do_initial_pruning); +extern ExecPrep *CreateExecPrep(EState *estate, MemoryContext context, + execprep_cleanup_fn cleanup, void *cleanup_arg); +extern void ExecPrepCleanup(ExecPrep *prep); + extern void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count); extern void standard_ExecutorRun(QueryDesc *queryDesc, diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 18ae8f0d4bb..f569be3853f 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -772,6 +772,61 @@ typedef struct EState List *es_insert_pending_modifytables; } EState; +/* + * ExecPrep: encapsulates executor preparation results for a PlannedStmt. + * + * This is used when we want to perform executor setup steps -- such as + * initializing the range table, checking permissions, and executing initial + * partition pruning -- ahead of actual plan execution. A typical use case is + * in plan validation logic (e.g., when deciding whether to reuse a generic + * cached plan), where we need to determine exactly which partitions will be + * scanned and locked, without executing the full plan. + * + * The executor may later adopt the prepared EState (via ExecutorStart), + * avoiding redundant setup. In that case, the executor is responsible for + * freeing the state and ExecPrepCleanup() will skip it. + */ +struct ExecPrep; + +/* + * Optional callback to clean up user-specific resources associated with + * ExecPrep. + */ +typedef void (*execprep_cleanup_fn)(struct ExecPrep *prep); + +/* ExecutorPrep output */ +typedef struct ExecPrep +{ + /* + * Context in which this struct and all subsidiary allocations were made. + * This context must remain alive until ExecPrepCleanup is called. + */ + MemoryContext context; + + /* + * Partially-initialized executor state used for permission checks and + * pruning. May be adopted directly by ExecutorStart(), in which case + * ExecPrepCleanup will skip freeing it. + */ + EState *prep_estate; + + /* + * True if ExecPrepCleanup() must free the EState. If the executor adopts + * prep_estate, this is set to false to avoid double-free. + */ + bool owns_estate; + + /* + * Optional caller-supplied cleanup hook to run during ExecPrepCleanup. + * Useful for releasing external resources associated with the prep. + */ + execprep_cleanup_fn cleanup; + + /* + * Opaque pointer to pass to the cleanup hook. + */ + void *cleanup_arg; +} ExecPrep; /* * ExecRowMark - diff --git a/src/include/utils/portal.h b/src/include/utils/portal.h index 5ffa6fd5cc8..013bcc3bd8e 100644 --- a/src/include/utils/portal.h +++ b/src/include/utils/portal.h @@ -137,6 +137,7 @@ typedef struct PortalData CommandTag commandTag; /* command tag for original query */ QueryCompletion qc; /* command completion data for executed query */ List *stmts; /* list of PlannedStmts */ + List *preps; /* list of ExecPreps where needed */ CachedPlan *cplan; /* CachedPlan, if stmts are from one */ ParamListInfo portalParams; /* params to pass to query */ @@ -240,6 +241,7 @@ extern void PortalDefineQuery(Portal portal, const char *sourceText, CommandTag commandTag, List *stmts, + List *preps, CachedPlan *cplan); extern PlannedStmt *PortalGetPrimaryStmt(Portal portal); extern void PortalCreateHoldStore(Portal portal); -- 2.47.3