From beff511dd6d4b87b763a3f70de26988a37c82d31 Mon Sep 17 00:00:00 2001 From: Amit Langote Date: Fri, 25 Oct 2024 15:45:38 +0900 Subject: [PATCH v57 4/5] Defer locking of runtime-prunable relations to executor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When preparing a cached plan for execution, plancache.c locks the relations in the plan's range table to ensure they are safe for execution. However, this approach, implemented in AcquireExecutorLocks(), results in unnecessarily locking relations that might be pruned during "initial" runtime pruning. To optimize this, locking is now deferred for relations subject to "initial" runtime pruning. The planner now provides a set of "unprunable" relations through the new PlannedStmt.unprunableRelids field. AcquireExecutorLocks() will only lock these unprunable relations. PlannedStmt.unprunableRelids is populated by subtracting the set of initially prunable relids from all RT indexes. The prunable relids are identified by examining all PartitionPruneInfos during set_plan_refs() and storing the RT indexes of partitions subject to "initial" pruning steps in PlannerGlobal.prunableRelids. Deferred locks are taken, if necessary, after ExecDoInitialPruning() determines the set of unpruned partitions. To enable this, the CachedPlan is now available via QueryDesc, allowing the executor to determine if the plan tree it’s executing is cached and may contain unlocked relations. The executor calls CachedPlanRequiresLocking() to check whether a cached plan might contain such unlocked relations, ensuring that appropriate locks are acquired before execution. Plan nodes like Append are already updated to consider only unpruned relations. However, child RowMarks and child result relations are not directly informed about unpruned partitions. Code handling child RowMarks and result relations has therefore been modified to ensure they don’t belong to pruned partitions. ExecDoInitialPruning() now adds RT indexes of unpruned partitions to es_unpruned_relids, initially populated with PlannedStmt.unprunableRelids. This ensures only those child RowMarks and result relations whose owning relations are in this set are processed. For ModifyTable nodes, ExecInitModifyTable truncates the resultRelations list (and parallel lists like withCheckOptionLists, returningLists, and updateColnosLists) to consider only unpruned relations, and creates ResultRelInfo structs only for those. To obtain RT indexes of unpruned leaf partitions for es_unpruned_relids, each PartitionedRelPruneInfo and the corresponding PartitionedRelPruningData now includes a mapping from partition indexes (from get_matching_partitions()) to their RT indexes in a leafpart_rti_map[] array. An Assert in ExecCheckPermissions() ensures that all relations undergoing permission checks are properly locked, helping to catch any missed additions to the unprunableRelids set. Deferring locking introduces a window where prunable relations may be altered by concurrent DDL, which can invalidate the plan. This might cause errors if the executor attempts to use an invalid plan, such as failing to locate a dropped partition index during ExecInitIndexScan(). Future commits will add support for the executor to validate the plan during ExecutorStart() and retry with a new plan if the original becomes invalid after deferred locks. --- 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/prepare.c | 3 +- src/backend/executor/execMain.c | 75 ++++++++++++++++++- src/backend/executor/execParallel.c | 9 ++- src/backend/executor/execPartition.c | 36 +++++++-- src/backend/executor/functions.c | 1 + src/backend/executor/nodeAppend.c | 8 +- src/backend/executor/nodeLockRows.c | 9 ++- src/backend/executor/nodeMergeAppend.c | 2 +- src/backend/executor/nodeModifyTable.c | 71 +++++++++++++++--- src/backend/executor/spi.c | 1 + src/backend/optimizer/plan/planner.c | 2 + src/backend/optimizer/plan/setrefs.c | 29 ++++++- src/backend/partitioning/partprune.c | 22 ++++++ src/backend/tcop/pquery.c | 10 ++- src/backend/utils/cache/plancache.c | 47 +++++++----- src/include/commands/explain.h | 5 +- src/include/executor/execPartition.h | 6 +- src/include/executor/execdesc.h | 2 + src/include/nodes/execnodes.h | 12 +++ src/include/nodes/pathnodes.h | 8 ++ src/include/nodes/plannodes.h | 7 ++ src/include/utils/plancache.h | 18 +++++ src/test/regress/expected/partition_prune.out | 44 +++++++++++ src/test/regress/sql/partition_prune.sql | 18 +++++ 29 files changed, 400 insertions(+), 59 deletions(-) diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c index f55e6d9675..27b6f6f069 100644 --- a/src/backend/commands/copyto.c +++ b/src/backend/commands/copyto.c @@ -556,7 +556,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 68ec122dbf..290c8bd240 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -324,7 +324,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 18a5af6b91..b699089bd8 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -515,7 +515,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); } @@ -623,7 +623,8 @@ ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, * to call it. */ void -ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, +ExplainOnePlan(PlannedStmt *plannedstmt, CachedPlan *cplan, + IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage, @@ -679,7 +680,7 @@ ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, dest = None_Receiver; /* Create a QueryDesc for the query */ - queryDesc = CreateQueryDesc(plannedstmt, queryString, + queryDesc = CreateQueryDesc(plannedstmt, cplan, queryString, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, instrument_option); diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c index 86ea9cd9da..cb168ab6dd 100644 --- a/src/backend/commands/extension.c +++ b/src/backend/commands/extension.c @@ -903,6 +903,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 010097873d..69be74b4bd 100644 --- a/src/backend/commands/matview.c +++ b/src/backend/commands/matview.c @@ -438,7 +438,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/prepare.c b/src/backend/commands/prepare.c index 07257d4db9..311b9ebd5b 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -655,7 +655,8 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, PlannedStmt *pstmt = lfirst_node(PlannedStmt, p); if (pstmt->commandType != CMD_UTILITY) - ExplainOnePlan(pstmt, into, es, query_string, paramLI, queryEnv, + ExplainOnePlan(pstmt, cplan, into, es, query_string, paramLI, + queryEnv, &planduration, (es->buffers ? &bufusage : NULL), es->memory ? &mem_counters : NULL); else diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c index 2fcec32dcb..ed783236eb 100644 --- a/src/backend/executor/execMain.c +++ b/src/backend/executor/execMain.c @@ -54,6 +54,7 @@ #include "nodes/queryjumble.h" #include "parser/parse_relation.h" #include "rewrite/rewriteHandler.h" +#include "storage/lmgr.h" #include "tcop/utility.h" #include "utils/acl.h" #include "utils/backend_status.h" @@ -91,6 +92,7 @@ static bool ExecCheckPermissionsModified(Oid relOid, Oid userid, AclMode requiredPerms); static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt); static void EvalPlanQualStart(EPQState *epqstate, Plan *planTree); +static inline bool ExecShouldLockRelations(EState *estate); /* end of local decls */ @@ -601,6 +603,21 @@ ExecCheckPermissions(List *rangeTable, List *rteperminfos, (rte->rtekind == RTE_SUBQUERY && rte->relkind == RELKIND_VIEW)); + /* + * Ensure that we have at least an AccessShareLock on relations + * whose permissions need to be checked. + * + * Skip this check in a parallel worker because locks won't be + * taken until ExecInitNode() performs plan initialization. + * + * XXX: ExecCheckPermissions() in a parallel worker may be + * redundant with the checks done in the leader process, so this + * should be reviewed to ensure it’s necessary. + */ + Assert(IsParallelWorker() || + CheckRelationOidLockedByMe(rte->relid, AccessShareLock, + true)); + (void) getRTEPermissionInfo(rteperminfos, rte); /* Many-to-one mapping not allowed */ Assert(!bms_is_member(rte->perminfoindex, indexset)); @@ -862,12 +879,46 @@ ExecDoInitialPruning(EState *estate) * bitmapset or NULL as described in the header comment. */ if (prunestate->do_initial_prune) - validsubplans = ExecFindMatchingSubPlans(prunestate, true); + { + Bitmapset *validsubplan_rtis = NULL; + + validsubplans = ExecFindMatchingSubPlans(prunestate, true, + &validsubplan_rtis); + if (ExecShouldLockRelations(estate)) + { + int rtindex = -1; + + rtindex = -1; + while ((rtindex = bms_next_member(validsubplan_rtis, + rtindex)) >= 0) + { + RangeTblEntry *rte = exec_rt_fetch(rtindex, estate); + + Assert(rte->rtekind == RTE_RELATION && + rte->rellockmode != NoLock); + LockRelationOid(rte->relid, rte->rellockmode); + } + } + estate->es_unpruned_relids = bms_add_members(estate->es_unpruned_relids, + validsubplan_rtis); + } + estate->es_part_prune_results = lappend(estate->es_part_prune_results, validsubplans); } } +/* + * Locks might be needed only if running a cached plan that might contain + * unlocked relations, such as reused generic plans. + */ +static inline bool +ExecShouldLockRelations(EState *estate) +{ + return estate->es_cachedplan == NULL ? false : + CachedPlanRequiresLocking(estate->es_cachedplan); +} + /* ---------------------------------------------------------------- * InitPlan * @@ -880,6 +931,7 @@ InitPlan(QueryDesc *queryDesc, int eflags) { CmdType operation = queryDesc->operation; PlannedStmt *plannedstmt = queryDesc->plannedstmt; + CachedPlan *cachedplan = queryDesc->cplan; Plan *plan = plannedstmt->planTree; List *rangeTable = plannedstmt->rtable; EState *estate = queryDesc->estate; @@ -899,6 +951,8 @@ InitPlan(QueryDesc *queryDesc, int eflags) ExecInitRangeTable(estate, rangeTable, plannedstmt->permInfos); estate->es_plannedstmt = plannedstmt; + estate->es_cachedplan = cachedplan; + estate->es_unpruned_relids = bms_copy(plannedstmt->unprunableRelids); /* * Perform runtime "initial" pruning to identify which child subplans, @@ -908,6 +962,9 @@ InitPlan(QueryDesc *queryDesc, int eflags) * 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. + * + * This will also add the RT indexes of surviving leaf partitions to + * es_unpruned_relids. */ estate->es_part_prune_infos = plannedstmt->partPruneInfos; ExecDoInitialPruning(estate); @@ -926,8 +983,13 @@ InitPlan(QueryDesc *queryDesc, int eflags) Relation relation; ExecRowMark *erm; - /* ignore "parent" rowmarks; they are irrelevant at runtime */ - if (rc->isParent) + /* + * Ignore "parent" rowmarks, because they are irrelevant at + * runtime. Also ignore the rowmarks belonging to child tables + * that have been pruned in ExecDoInitialPruning(). + */ + if (rc->isParent || + !bms_is_member(rc->rti, estate->es_unpruned_relids)) continue; /* get relation's OID (will produce InvalidOid if subquery) */ @@ -2970,6 +3032,13 @@ EvalPlanQualStart(EPQState *epqstate, Plan *planTree) } } + /* + * Copy es_unpruned_relids so that RowMarks of pruned relations are + * ignored in ExecInitLockRows() and ExecInitModifyTable() when + * initializing the plan trees below. + */ + rcestate->es_unpruned_relids = parentestate->es_unpruned_relids; + /* * Initialize private state information for each SubPlan. We must do this * before running ExecInitNode on the main query tree, since diff --git a/src/backend/executor/execParallel.c b/src/backend/executor/execParallel.c index b01a2fdfdd..7519c9a860 100644 --- a/src/backend/executor/execParallel.c +++ b/src/backend/executor/execParallel.c @@ -1257,8 +1257,15 @@ ExecParallelGetQueryDesc(shm_toc *toc, DestReceiver *receiver, paramspace = shm_toc_lookup(toc, PARALLEL_KEY_PARAMLISTINFO, false); paramLI = RestoreParamList(¶mspace); - /* Create a QueryDesc for the query. */ + /* + * Create a QueryDesc for the query. We pass NULL for cachedplan, because + * we don't have a pointer to the CachedPlan in the leader's process. It's + * fine because the only reason the executor needs to see it is to decide + * if it should take locks on certain relations, but paraller workers + * always take locks anyway. + */ 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 83d1b61101..802a16b6fa 100644 --- a/src/backend/executor/execPartition.c +++ b/src/backend/executor/execPartition.c @@ -192,7 +192,8 @@ static void find_matching_subplans_recurse(PlanState *parent_plan, PartitionPruningData *prunedata, PartitionedRelPruningData *pprune, bool initial_prune, - Bitmapset **validsubplans); + Bitmapset **validsubplans, + Bitmapset **validsubplan_rtis); /* @@ -1987,8 +1988,8 @@ ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo) * The set of partitions that exist now might not be the same that * existed when the plan was made. The normal case is that it is; * optimize for that case with a quick comparison, and just copy - * the subplan_map and make subpart_map point to the one in - * PruneInfo. + * the subplan_map and make subpart_map, leafpart_rti_map point to + * the ones in PruneInfo. * * For the case where they aren't identical, we could have more * partitions on either side; or even exactly the same number of @@ -2007,6 +2008,7 @@ ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo) sizeof(int) * partdesc->nparts) == 0) { pprune->subpart_map = pinfo->subpart_map; + pprune->leafpart_rti_map = pinfo->leafpart_rti_map; memcpy(pprune->subplan_map, pinfo->subplan_map, sizeof(int) * pinfo->nparts); } @@ -2027,6 +2029,7 @@ ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo) * mismatches. */ pprune->subpart_map = palloc(sizeof(int) * partdesc->nparts); + pprune->leafpart_rti_map = palloc(sizeof(int) * partdesc->nparts); for (pp_idx = 0; pp_idx < partdesc->nparts; pp_idx++) { @@ -2044,6 +2047,8 @@ ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo) pinfo->subplan_map[pd_idx]; pprune->subpart_map[pp_idx] = pinfo->subpart_map[pd_idx]; + pprune->leafpart_rti_map[pp_idx] = + pinfo->leafpart_rti_map[pd_idx]; pd_idx++; continue; } @@ -2081,6 +2086,7 @@ ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo) pprune->subpart_map[pp_idx] = -1; pprune->subplan_map[pp_idx] = -1; + pprune->leafpart_rti_map[pp_idx] = 0; } } @@ -2359,10 +2365,13 @@ PartitionPruneFixSubPlanMap(PartitionPruneState *prunestate, * Pass initial_prune if PARAM_EXEC Params cannot yet be evaluated. This * differentiates the initial executor-time pruning step from later * runtime pruning. + * + * valisubplan_rtis must be non-NULL if initial_prune is true. */ Bitmapset * ExecFindMatchingSubPlans(PartitionPruneState *prunestate, - bool initial_prune) + bool initial_prune, + Bitmapset **validsubplan_rtis) { Bitmapset *result = NULL; MemoryContext oldcontext; @@ -2398,7 +2407,7 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate, pprune = &prunedata->partrelprunedata[0]; find_matching_subplans_recurse(prunestate->parent_plan, prunedata, pprune, initial_prune, - &result); + &result, validsubplan_rtis); /* Expression eval may have used space in ExprContext too */ if (pprune->exec_context.is_valid) @@ -2415,6 +2424,8 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate, /* Copy result out of the temp context before we reset it */ result = bms_copy(result); + if (validsubplan_rtis) + *validsubplan_rtis = bms_copy(*validsubplan_rtis); MemoryContextReset(prunestate->prune_context); @@ -2425,14 +2436,17 @@ ExecFindMatchingSubPlans(PartitionPruneState *prunestate, * find_matching_subplans_recurse * Recursive worker function for ExecFindMatchingSubPlans * - * Adds valid (non-prunable) subplan IDs to *validsubplans + * Adds valid (non-prunable) subplan IDs to *validsubplans and the RT indexes + * of their corresponding leaf partitions to *validsubplan_rtis if + * it's non-NULL. */ static void find_matching_subplans_recurse(PlanState *parent_plan, PartitionPruningData *prunedata, PartitionedRelPruningData *pprune, bool initial_prune, - Bitmapset **validsubplans) + Bitmapset **validsubplans, + Bitmapset **validsubplan_rtis) { Bitmapset *partset; int i; @@ -2475,8 +2489,13 @@ find_matching_subplans_recurse(PlanState *parent_plan, while ((i = bms_next_member(partset, i)) >= 0) { if (pprune->subplan_map[i] >= 0) + { *validsubplans = bms_add_member(*validsubplans, pprune->subplan_map[i]); + if (validsubplan_rtis) + *validsubplan_rtis = bms_add_member(*validsubplan_rtis, + pprune->leafpart_rti_map[i]); + } else { int partidx = pprune->subpart_map[i]; @@ -2485,7 +2504,8 @@ find_matching_subplans_recurse(PlanState *parent_plan, find_matching_subplans_recurse(parent_plan, prunedata, &prunedata->partrelprunedata[partidx], - initial_prune, validsubplans); + initial_prune, validsubplans, + validsubplan_rtis); else { /* diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c index 692854e2b3..6f6f45e0ad 100644 --- a/src/backend/executor/functions.c +++ b/src/backend/executor/functions.c @@ -840,6 +840,7 @@ postquel_start(execution_state *es, SQLFunctionCachePtr fcache) dest = None_Receiver; es->qd = CreateQueryDesc(es->stmt, + NULL, fcache->src, GetActiveSnapshot(), InvalidSnapshot, diff --git a/src/backend/executor/nodeAppend.c b/src/backend/executor/nodeAppend.c index de7ebab5c2..006bdafaea 100644 --- a/src/backend/executor/nodeAppend.c +++ b/src/backend/executor/nodeAppend.c @@ -581,7 +581,7 @@ choose_next_subplan_locally(AppendState *node) else if (!node->as_valid_subplans_identified) { node->as_valid_subplans = - ExecFindMatchingSubPlans(node->as_prune_state, false); + ExecFindMatchingSubPlans(node->as_prune_state, false, NULL); node->as_valid_subplans_identified = true; } @@ -648,7 +648,7 @@ choose_next_subplan_for_leader(AppendState *node) if (!node->as_valid_subplans_identified) { node->as_valid_subplans = - ExecFindMatchingSubPlans(node->as_prune_state, false); + ExecFindMatchingSubPlans(node->as_prune_state, false, NULL); node->as_valid_subplans_identified = true; /* @@ -724,7 +724,7 @@ choose_next_subplan_for_worker(AppendState *node) else if (!node->as_valid_subplans_identified) { node->as_valid_subplans = - ExecFindMatchingSubPlans(node->as_prune_state, false); + ExecFindMatchingSubPlans(node->as_prune_state, false, NULL); node->as_valid_subplans_identified = true; mark_invalid_subplans_as_finished(node); @@ -877,7 +877,7 @@ ExecAppendAsyncBegin(AppendState *node) if (!node->as_valid_subplans_identified) { node->as_valid_subplans = - ExecFindMatchingSubPlans(node->as_prune_state, false); + ExecFindMatchingSubPlans(node->as_prune_state, false, NULL); node->as_valid_subplans_identified = true; classify_matching_subplans(node); diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c index 41754ddfea..cfead7ded2 100644 --- a/src/backend/executor/nodeLockRows.c +++ b/src/backend/executor/nodeLockRows.c @@ -347,8 +347,13 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags) ExecRowMark *erm; ExecAuxRowMark *aerm; - /* ignore "parent" rowmarks; they are irrelevant at runtime */ - if (rc->isParent) + /* + * Ignore "parent" rowmarks, because they are irrelevant at + * runtime. Also ignore the rowmarks belonging to child tables + * that have been pruned in ExecDoInitialPruning(). + */ + if (rc->isParent || + !bms_is_member(rc->rti, estate->es_unpruned_relids)) continue; /* find ExecRowMark and build ExecAuxRowMark */ diff --git a/src/backend/executor/nodeMergeAppend.c b/src/backend/executor/nodeMergeAppend.c index 3ed91808dd..f7821aa178 100644 --- a/src/backend/executor/nodeMergeAppend.c +++ b/src/backend/executor/nodeMergeAppend.c @@ -219,7 +219,7 @@ ExecMergeAppend(PlanState *pstate) */ if (node->ms_valid_subplans == NULL) node->ms_valid_subplans = - ExecFindMatchingSubPlans(node->ms_prune_state, false); + ExecFindMatchingSubPlans(node->ms_prune_state, false, NULL); /* * First time through: pull the first tuple from each valid subplan, diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 1161520f76..004273f868 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -636,7 +636,7 @@ ExecInitUpdateProjection(ModifyTableState *mtstate, Assert(whichrel >= 0 && whichrel < mtstate->mt_nrels); } - updateColnos = (List *) list_nth(node->updateColnosLists, whichrel); + updateColnos = (List *) list_nth(mtstate->mt_updateColnosLists, whichrel); /* * For UPDATE, we use the old tuple to fill up missing values in the tuple @@ -4245,6 +4245,7 @@ ExecLookupResultRelByOid(ModifyTableState *node, Oid resultoid, node->mt_lastResultOid = resultoid; node->mt_lastResultIndex = mtlookup->relationIndex; } + return node->resultRelInfo + mtlookup->relationIndex; } } @@ -4282,7 +4283,11 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) ModifyTableState *mtstate; Plan *subplan = outerPlan(node); CmdType operation = node->operation; - int nrels = list_length(node->resultRelations); + int nrels; + List *resultRelations = NIL; + List *withCheckOptionLists = NIL; + List *returningLists = NIL; + List *updateColnosLists = NIL; ResultRelInfo *resultRelInfo; List *arowmarks; ListCell *l; @@ -4292,6 +4297,45 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) /* check for unsupported flags */ Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK))); + /* + * Only consider unpruned relations for initializing their ResultRelInfo + * struct and other fields such as withCheckOptions, etc. + */ + i = 0; + foreach(l, node->resultRelations) + { + Index rti = lfirst_int(l); + + if (bms_is_member(rti, estate->es_unpruned_relids)) + { + resultRelations = lappend_int(resultRelations, rti); + if (node->withCheckOptionLists) + { + List *withCheckOptions = list_nth_node(List, + node->withCheckOptionLists, + i); + + withCheckOptionLists = lappend(withCheckOptionLists, withCheckOptions); + } + if (node->returningLists) + { + List *returningList = list_nth_node(List, + node->returningLists, + i); + + returningLists = lappend(returningLists, returningList); + } + if (node->updateColnosLists) + { + List *updateColnosList = list_nth(node->updateColnosLists, i); + + updateColnosLists = lappend(updateColnosLists, updateColnosList); + } + } + i++; + } + nrels = list_length(resultRelations); + /* * create state structure */ @@ -4312,6 +4356,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) mtstate->mt_merge_inserted = 0; mtstate->mt_merge_updated = 0; mtstate->mt_merge_deleted = 0; + mtstate->mt_updateColnosLists = updateColnosLists; /*---------- * Resolve the target relation. This is the same as: @@ -4329,6 +4374,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) */ if (node->rootRelation > 0) { + Assert(bms_is_member(node->rootRelation, estate->es_unpruned_relids)); mtstate->rootResultRelInfo = makeNode(ResultRelInfo); ExecInitResultRelation(estate, mtstate->rootResultRelInfo, node->rootRelation); @@ -4343,7 +4389,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) /* set up epqstate with dummy subplan data for the moment */ EvalPlanQualInit(&mtstate->mt_epqstate, estate, NULL, NIL, - node->epqParam, node->resultRelations); + node->epqParam, resultRelations); mtstate->fireBSTriggers = true; /* @@ -4361,7 +4407,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) */ resultRelInfo = mtstate->resultRelInfo; i = 0; - foreach(l, node->resultRelations) + foreach(l, resultRelations) { Index resultRelation = lfirst_int(l); List *mergeActions = NIL; @@ -4505,7 +4551,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) * Initialize any WITH CHECK OPTION constraints if needed. */ resultRelInfo = mtstate->resultRelInfo; - foreach(l, node->withCheckOptionLists) + foreach(l, withCheckOptionLists) { List *wcoList = (List *) lfirst(l); List *wcoExprs = NIL; @@ -4528,7 +4574,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) /* * Initialize RETURNING projections if needed. */ - if (node->returningLists) + if (returningLists) { TupleTableSlot *slot; ExprContext *econtext; @@ -4537,7 +4583,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) * Initialize result tuple slot and assign its rowtype using the first * RETURNING list. We assume the rest will look the same. */ - mtstate->ps.plan->targetlist = (List *) linitial(node->returningLists); + mtstate->ps.plan->targetlist = (List *) linitial(returningLists); /* Set up a slot for the output of the RETURNING projection(s) */ ExecInitResultTupleSlotTL(&mtstate->ps, &TTSOpsVirtual); @@ -4552,7 +4598,7 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) * Build a projection for each result rel. */ resultRelInfo = mtstate->resultRelInfo; - foreach(l, node->returningLists) + foreach(l, returningLists) { List *rlist = (List *) lfirst(l); @@ -4653,8 +4699,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) ExecRowMark *erm; ExecAuxRowMark *aerm; - /* ignore "parent" rowmarks; they are irrelevant at runtime */ - if (rc->isParent) + /* + * Ignore "parent" rowmarks, because they are irrelevant at + * runtime. Also ignore the rowmarks belonging to child tables + * that have been pruned in ExecDoInitialPruning(). + */ + if (rc->isParent || + !bms_is_member(rc->rti, estate->es_unpruned_relids)) continue; /* Find ExecRowMark and build ExecAuxRowMark */ diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index 2fb2e73604..e2b781e939 100644 --- a/src/backend/executor/spi.c +++ b/src/backend/executor/spi.c @@ -2690,6 +2690,7 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options, snap = InvalidSnapshot; qdesc = CreateQueryDesc(stmt, + cplan, plansource->query_string, snap, crosscheck_snapshot, dest, diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index cce226fff1..c98895976e 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -555,6 +555,8 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions, result->planTree = top_plan; result->partPruneInfos = glob->partPruneInfos; result->rtable = glob->finalrtable; + result->unprunableRelids = bms_difference(glob->allRelids, + glob->prunableRelids); result->permInfos = glob->finalrteperminfos; result->resultRelations = glob->resultRelations; result->appendRelations = glob->appendRelations; diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index 8deb012d8e..a6899e100f 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -565,7 +565,8 @@ add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos, /* * If it's a plain relation RTE (or a subquery that was once a view - * reference), add the relation OID to relationOids. + * reference), add the relation OID to relationOids. Also add its new RT + * index to the set of relations that need to be locked for execution. * * We do this even though the RTE might be unreferenced in the plan tree; * this would correspond to cases such as views that were expanded, child @@ -577,7 +578,11 @@ add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos, */ if (newrte->rtekind == RTE_RELATION || (newrte->rtekind == RTE_SUBQUERY && OidIsValid(newrte->relid))) + { glob->relationOids = lappend_oid(glob->relationOids, newrte->relid); + glob->allRelids = bms_add_member(glob->allRelids, + list_length(glob->finalrtable)); + } /* * Add a copy of the RTEPermissionInfo, if any, corresponding to this RTE @@ -1741,6 +1746,11 @@ set_customscan_references(PlannerInfo *root, * * Also update the RT indexes present in PartitionedRelPruneInfos to add the * offset. + * + * Finally, if there are initial pruning steps, add the RT indexes of the + * leaf partitions to the set of relations prunable at execution startup time. + * This set indicates which relations should not be locked before executor + * startup, as they may be pruned during initial pruning. */ static int register_partpruneinfo(PlannerInfo *root, int part_prune_index, int rtoffset) @@ -1763,8 +1773,25 @@ register_partpruneinfo(PlannerInfo *root, int part_prune_index, int rtoffset) foreach(l2, prune_infos) { PartitionedRelPruneInfo *prelinfo = lfirst(l2); + int i; prelinfo->rtindex += rtoffset; + + for (i = 0; i < prelinfo->nparts; i++) + { + /* + * Non-leaf partitions and partitions that do not have a + * subplan are not included in this map as mentioned in + * make_partitionedrel_pruneinfo(). + */ + if (prelinfo->leafpart_rti_map[i]) + { + prelinfo->leafpart_rti_map[i] += rtoffset; + if (prelinfo->initial_pruning_steps) + glob->prunableRelids = bms_add_member(glob->prunableRelids, + prelinfo->leafpart_rti_map[i]); + } + } } } diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c index df767f9e5b..5a518e99bc 100644 --- a/src/backend/partitioning/partprune.c +++ b/src/backend/partitioning/partprune.c @@ -645,6 +645,7 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, int *subplan_map; int *subpart_map; Oid *relid_map; + int *leafpart_rti_map; /* * Construct the subplan and subpart maps for this partitioning level. @@ -657,6 +658,7 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, subpart_map = (int *) palloc(nparts * sizeof(int)); memset(subpart_map, -1, nparts * sizeof(int)); relid_map = (Oid *) palloc0(nparts * sizeof(Oid)); + leafpart_rti_map = (int *) palloc0(nparts * sizeof(int)); present_parts = NULL; i = -1; @@ -671,9 +673,28 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, subplan_map[i] = subplanidx = relid_subplan_map[partrel->relid] - 1; subpart_map[i] = subpartidx = relid_subpart_map[partrel->relid] - 1; relid_map[i] = planner_rt_fetch(partrel->relid, root)->relid; + + /* + * Track the RT indexes of "leaf" partitions so they can be + * included in the PlannerGlobal.prunableRelids set, indicating + * relations whose locking is deferred until executor startup. + * + * We don’t defer locking of sub-partitioned partitions because + * setting up PartitionedRelPruningData currently occurs before + * initial pruning, so the relation must be locked at that stage, + * even if it may be pruned. + * + * Only leaf partitions with a valid subplan that are prunable + * using initial pruning are added to prunableRelids. So + * partitions without a subplan due to constraint exclusion will + * remain in PlannedStmt.unprunableRelids and thus their locking + * will not be deferred even if they may ultimately be pruned due + * to initial pruning. + */ if (subplanidx >= 0) { present_parts = bms_add_member(present_parts, i); + leafpart_rti_map[i] = (int) partrel->relid; /* Record finding this subplan */ subplansfound = bms_add_member(subplansfound, subplanidx); @@ -695,6 +716,7 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, pinfo->subplan_map = subplan_map; pinfo->subpart_map = subpart_map; pinfo->relid_map = relid_map; + pinfo->leafpart_rti_map = leafpart_rti_map; } pfree(relid_subpart_map); diff --git a/src/backend/tcop/pquery.c b/src/backend/tcop/pquery.c index a1f8d03db1..6e8f6b1b8f 100644 --- a/src/backend/tcop/pquery.c +++ b/src/backend/tcop/pquery.c @@ -36,6 +36,7 @@ Portal ActivePortal = NULL; static void ProcessQuery(PlannedStmt *plan, + CachedPlan *cplan, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, @@ -65,6 +66,7 @@ static void DoPortalRewind(Portal portal); */ QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, + CachedPlan *cplan, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, @@ -77,6 +79,7 @@ CreateQueryDesc(PlannedStmt *plannedstmt, qd->operation = plannedstmt->commandType; /* operation */ qd->plannedstmt = plannedstmt; /* plan */ + qd->cplan = cplan; /* CachedPlan supplying the plannedstmt */ qd->sourceText = sourceText; /* query text */ qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */ /* RI check snapshot */ @@ -122,6 +125,7 @@ FreeQueryDesc(QueryDesc *qdesc) * PORTAL_ONE_RETURNING, or PORTAL_ONE_MOD_WITH portal * * plan: the plan tree for the query + * cplan: CachedPlan supplying the plan * sourceText: the source text of the query * params: any parameters needed * dest: where to send results @@ -134,6 +138,7 @@ FreeQueryDesc(QueryDesc *qdesc) */ static void ProcessQuery(PlannedStmt *plan, + CachedPlan *cplan, const char *sourceText, ParamListInfo params, QueryEnvironment *queryEnv, @@ -145,7 +150,7 @@ ProcessQuery(PlannedStmt *plan, /* * Create the QueryDesc object */ - queryDesc = CreateQueryDesc(plan, sourceText, + queryDesc = CreateQueryDesc(plan, cplan, sourceText, GetActiveSnapshot(), InvalidSnapshot, dest, params, queryEnv, 0); @@ -493,6 +498,7 @@ PortalStart(Portal portal, ParamListInfo params, * the destination to DestNone. */ queryDesc = CreateQueryDesc(linitial_node(PlannedStmt, portal->stmts), + portal->cplan, portal->sourceText, GetActiveSnapshot(), InvalidSnapshot, @@ -1276,6 +1282,7 @@ PortalRunMulti(Portal portal, { /* statement can set tag string */ ProcessQuery(pstmt, + portal->cplan, portal->sourceText, portal->portalParams, portal->queryEnv, @@ -1285,6 +1292,7 @@ PortalRunMulti(Portal portal, { /* stmt added by rewrite cannot set tag */ ProcessQuery(pstmt, + portal->cplan, portal->sourceText, portal->portalParams, portal->queryEnv, diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c index 5af1a168ec..449fb8f4e2 100644 --- a/src/backend/utils/cache/plancache.c +++ b/src/backend/utils/cache/plancache.c @@ -104,7 +104,8 @@ static List *RevalidateCachedQuery(CachedPlanSource *plansource, QueryEnvironment *queryEnv); static bool CheckCachedPlan(CachedPlanSource *plansource); static CachedPlan *BuildCachedPlan(CachedPlanSource *plansource, List *qlist, - ParamListInfo boundParams, QueryEnvironment *queryEnv); + ParamListInfo boundParams, QueryEnvironment *queryEnv, + bool generic); static bool choose_custom_plan(CachedPlanSource *plansource, ParamListInfo boundParams); static double cached_plan_cost(CachedPlan *plan, bool include_planner); @@ -815,8 +816,11 @@ RevalidateCachedQuery(CachedPlanSource *plansource, * Caller must have already called RevalidateCachedQuery to verify that the * querytree is up to date. * - * On a "true" return, we have acquired the locks needed to run the plan. - * (We must do this for the "true" result to be race-condition-free.) + * On a "true" return, we have acquired locks on the "unprunableRelids" set + * for all plans in plansource->stmt_list. However, the plans are not fully + * race-condition-free until the executor acquires locks on the prunable + * relations that survive initial runtime pruning during executor + * initialization. */ static bool CheckCachedPlan(CachedPlanSource *plansource) @@ -893,10 +897,10 @@ CheckCachedPlan(CachedPlanSource *plansource) * or it can be set to NIL if we need to re-copy the plansource's query_list. * * To build a generic, parameter-value-independent plan, pass NULL for - * boundParams. To build a custom plan, pass the actual parameter values via - * boundParams. For best effect, the PARAM_FLAG_CONST flag should be set on - * each parameter value; otherwise the planner will treat the value as a - * hint rather than a hard constant. + * boundParams, and true for generic. To build a custom plan, pass the actual + * parameter values via boundParams, and false for generic. For best effect, + * the PARAM_FLAG_CONST flag should be set on each parameter value; otherwise + * the planner will treat the value as a hint rather than a hard constant. * * Planning work is done in the caller's memory context. The finished plan * is in a child memory context, which typically should get reparented @@ -904,7 +908,8 @@ CheckCachedPlan(CachedPlanSource *plansource) */ static CachedPlan * BuildCachedPlan(CachedPlanSource *plansource, List *qlist, - ParamListInfo boundParams, QueryEnvironment *queryEnv) + ParamListInfo boundParams, QueryEnvironment *queryEnv, + bool generic) { CachedPlan *plan; List *plist; @@ -1026,6 +1031,7 @@ BuildCachedPlan(CachedPlanSource *plansource, List *qlist, plan->refcount = 0; plan->context = plan_context; plan->is_oneshot = plansource->is_oneshot; + plan->is_generic = generic; plan->is_saved = false; plan->is_valid = true; @@ -1153,8 +1159,10 @@ cached_plan_cost(CachedPlan *plan, bool include_planner) * plan or a custom plan for the given parameters: the caller does not know * which it will get. * - * On return, the plan is valid and we have sufficient locks to begin - * execution. + * On return, the plan is valid, but not all locks are acquired if a cached + * generic plan is being reused. In such cases, locks on relations subject + * to initial runtime pruning are deferred until the execution startup phase, + * specifically when ExecDoInitialPruning() performs initial pruning. * * On return, the refcount of the plan has been incremented; a later * ReleaseCachedPlan() call is expected. If "owner" is not NULL then @@ -1196,7 +1204,7 @@ GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams, else { /* Build a new generic plan */ - plan = BuildCachedPlan(plansource, qlist, NULL, queryEnv); + plan = BuildCachedPlan(plansource, qlist, NULL, queryEnv, true); /* Just make real sure plansource->gplan is clear */ ReleaseGenericPlan(plansource); /* Link the new generic plan into the plansource */ @@ -1241,7 +1249,7 @@ GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams, if (customplan) { /* Build a custom plan */ - plan = BuildCachedPlan(plansource, qlist, boundParams, queryEnv); + plan = BuildCachedPlan(plansource, qlist, boundParams, queryEnv, false); /* Accumulate total costs of custom plans */ plansource->total_custom_cost += cached_plan_cost(plan, true); @@ -1776,7 +1784,7 @@ AcquireExecutorLocks(List *stmt_list, bool acquire) foreach(lc1, stmt_list) { PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc1); - ListCell *lc2; + int rtindex; if (plannedstmt->commandType == CMD_UTILITY) { @@ -1794,13 +1802,16 @@ AcquireExecutorLocks(List *stmt_list, bool acquire) continue; } - foreach(lc2, plannedstmt->rtable) + rtindex = -1; + while ((rtindex = bms_next_member(plannedstmt->unprunableRelids, + rtindex)) >= 0) { - RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2); + RangeTblEntry *rte = list_nth_node(RangeTblEntry, + plannedstmt->rtable, + rtindex - 1); - if (!(rte->rtekind == RTE_RELATION || - (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)))) - continue; + Assert(rte->rtekind == RTE_RELATION || + (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid))); /* * Acquire the appropriate type of lock on each relation OID. Note diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h index 3ab0aae78f..21c71e0d53 100644 --- a/src/include/commands/explain.h +++ b/src/include/commands/explain.h @@ -103,8 +103,9 @@ extern void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv); -extern void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, - ExplainState *es, const char *queryString, +extern void ExplainOnePlan(PlannedStmt *plannedstmt, CachedPlan *cplan, + IntoClause *into, ExplainState *es, + const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage, diff --git a/src/include/executor/execPartition.h b/src/include/executor/execPartition.h index 1497aed533..ec5cf4233e 100644 --- a/src/include/executor/execPartition.h +++ b/src/include/executor/execPartition.h @@ -49,6 +49,8 @@ extern void ExecCleanupTupleRouting(ModifyTableState *mtstate, * nparts Length of subplan_map[] and subpart_map[]. * subplan_map Subplan index by partition index, or -1. * subpart_map Subpart index by partition index, or -1. + * leafpart_rti_map RT index by partition index, or 0 if not a leaf + * partition. * present_parts A Bitmapset of the partition indexes that we * have subplans or subparts for. * initial_pruning_steps List of PartitionPruneSteps used to @@ -69,6 +71,7 @@ typedef struct PartitionedRelPruningData int nparts; int *subplan_map; int *subpart_map; + int *leafpart_rti_map; Bitmapset *present_parts; List *initial_pruning_steps; List *exec_pruning_steps; @@ -139,7 +142,8 @@ extern PartitionPruneState *ExecInitPartitionPruning(PlanState *planstate, Bitmapset *relids, Bitmapset **initially_valid_subplans); extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate, - bool initial_prune); + bool initial_prune, + Bitmapset **validsubplan_rtis); extern PartitionPruneState *ExecCreatePartitionPruneState(EState *estate, PartitionPruneInfo *pruneinfo); #endif /* EXECPARTITION_H */ diff --git a/src/include/executor/execdesc.h b/src/include/executor/execdesc.h index 0a7274e26c..0e7245435d 100644 --- a/src/include/executor/execdesc.h +++ b/src/include/executor/execdesc.h @@ -35,6 +35,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) */ + CachedPlan *cplan; /* CachedPlan that supplies the plannedstmt */ 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 +58,7 @@ typedef struct QueryDesc /* in pquery.c */ extern QueryDesc *CreateQueryDesc(PlannedStmt *plannedstmt, + CachedPlan *cplan, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index b0ceb1ab05..ac9be82e19 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -42,6 +42,7 @@ #include "storage/condition_variable.h" #include "utils/hsearch.h" #include "utils/queryenvironment.h" +#include "utils/plancache.h" #include "utils/reltrigger.h" #include "utils/sharedtuplestore.h" #include "utils/snapshot.h" @@ -639,9 +640,14 @@ typedef struct EState * ExecRowMarks, or NULL if none */ List *es_rteperminfos; /* List of RTEPermissionInfo */ PlannedStmt *es_plannedstmt; /* link to top of plan tree */ + CachedPlan *es_cachedplan; List *es_part_prune_infos; /* PlannedStmt.partPruneInfos */ List *es_part_prune_states; /* List of PartitionPruneState */ List *es_part_prune_results; /* List of Bitmapset */ + Bitmapset *es_unpruned_relids; /* PlannedStmt.unprunableRelids + RT + * indexes of leaf partitions that + * survive initial pruning; see + * ExecDoInitialPruning() */ const char *es_sourceText; /* Source text from QueryDesc */ JunkFilter *es_junkFilter; /* top-level junk filter, if any */ @@ -1427,6 +1433,12 @@ typedef struct ModifyTableState double mt_merge_inserted; double mt_merge_updated; double mt_merge_deleted; + + /* + * List of valid updateColnosLists. Contains only those belonging to + * unpruned relations from ModifyTable.updateColnosLists. + */ + List *mt_updateColnosLists; } ModifyTableState; /* ---------------- diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h index c603a9bb1c..ab33b8faf9 100644 --- a/src/include/nodes/pathnodes.h +++ b/src/include/nodes/pathnodes.h @@ -116,6 +116,14 @@ typedef struct PlannerGlobal /* "flat" rangetable for executor */ List *finalrtable; + /* + * RT indexes of all relation RTEs in finalrtable (RTE_RELATION and + * RTE_SUBQUERY RTEs of views) and of those that are subject to runtime + * pruning at plan initialization time ("initial" pruning). + */ + Bitmapset *allRelids; + Bitmapset *prunableRelids; + /* "flat" list of RTEPermissionInfos */ List *finalrteperminfos; diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h index ef89927471..59699a1f86 100644 --- a/src/include/nodes/plannodes.h +++ b/src/include/nodes/plannodes.h @@ -74,6 +74,10 @@ typedef struct PlannedStmt List *rtable; /* list of RangeTblEntry nodes */ + Bitmapset *unprunableRelids; /* RT indexes of relations that are not + * subject to runtime pruning; set for + * AcquireExecutorLocks(). */ + List *permInfos; /* list of RTEPermissionInfo nodes for rtable * entries needing one */ @@ -1476,6 +1480,9 @@ typedef struct PartitionedRelPruneInfo /* subpart index by partition index, or -1 */ int *subpart_map pg_node_attr(array_size(nparts)); + /* RT index by partition index, or 0 if not a leaf partition */ + int *leafpart_rti_map pg_node_attr(array_size(nparts)); + /* relation OID by partition index, or 0 */ Oid *relid_map pg_node_attr(array_size(nparts)); diff --git a/src/include/utils/plancache.h b/src/include/utils/plancache.h index a90dfdf906..e227c4f11b 100644 --- a/src/include/utils/plancache.h +++ b/src/include/utils/plancache.h @@ -149,6 +149,7 @@ typedef struct CachedPlan int magic; /* should equal CACHEDPLAN_MAGIC */ List *stmt_list; /* list of PlannedStmts */ bool is_oneshot; /* is it a "oneshot" plan? */ + bool is_generic; /* is it a reusable generic plan? */ bool is_saved; /* is CachedPlan in a long-lived context? */ bool is_valid; /* is the stmt_list currently valid? */ Oid planRoleId; /* Role ID the plan was created for */ @@ -235,4 +236,21 @@ extern bool CachedPlanIsSimplyValid(CachedPlanSource *plansource, extern CachedExpression *GetCachedExpression(Node *expr); extern void FreeCachedExpression(CachedExpression *cexpr); +/* + * CachedPlanRequiresLocking: should the executor acquire additional locks? + * + * If the plan is a saved generic plan, the executor must acquire locks for + * relations that are not covered by AcquireExecutorLocks(), such as partitions + * that are subject to initial runtime pruning. + * + * Note: These locks are unnecessary if the plan is executed immediately after + * its creation, since the planner would have already acquired them. However, + * we do not optimize for that case. + */ +static inline bool +CachedPlanRequiresLocking(CachedPlan *cplan) +{ + return !cplan->is_oneshot && cplan->is_generic; +} + #endif /* PLANCACHE_H */ diff --git a/src/test/regress/expected/partition_prune.out b/src/test/regress/expected/partition_prune.out index 7a03b4e360..705cd922fc 100644 --- a/src/test/regress/expected/partition_prune.out +++ b/src/test/regress/expected/partition_prune.out @@ -4440,3 +4440,47 @@ drop table hp_contradict_test; drop operator class part_test_int4_ops2 using hash; drop operator ===(int4, int4); drop function explain_analyze(text); +-- Runtime pruning on UPDATE using WITH CHECK OPTIONS and RETURNING +create table part_abc (a int, b text, c bool) partition by list (a); +create table part_abc_1 (b text, a int, c bool); +create table part_abc_2 (a int, c bool, b text); +alter table part_abc attach partition part_abc_1 for values in (1); +alter table part_abc attach partition part_abc_2 for values in (2); +insert into part_abc values (1, 'b', true); +insert into part_abc values (2, 'c', true); +create view part_abc_view as select * from part_abc where b <> 'a' with check option; +prepare update_part_abc_view as update part_abc_view set b = $2 where a = $1 returning *; +explain (costs off) execute update_part_abc_view (1, 'd'); + QUERY PLAN +------------------------------------------------------- + Update on part_abc + Update on part_abc_1 + -> Append + Subplans Removed: 1 + -> Seq Scan on part_abc_1 + Filter: ((b <> 'a'::text) AND (a = $1)) +(6 rows) + +execute update_part_abc_view (1, 'd'); + a | b | c +---+---+--- + 1 | d | t +(1 row) + +explain (costs off) execute update_part_abc_view (2, 'a'); + QUERY PLAN +------------------------------------------------------- + Update on part_abc + Update on part_abc_2 part_abc_1 + -> Append + Subplans Removed: 1 + -> Seq Scan on part_abc_2 part_abc_1 + Filter: ((b <> 'a'::text) AND (a = $1)) +(6 rows) + +execute update_part_abc_view (2, 'a'); +ERROR: new row violates check option for view "part_abc_view" +DETAIL: Failing row contains (2, a, t). +deallocate update_part_abc_view; +drop view part_abc_view; +drop table part_abc; diff --git a/src/test/regress/sql/partition_prune.sql b/src/test/regress/sql/partition_prune.sql index 442428d937..af26ad2fb2 100644 --- a/src/test/regress/sql/partition_prune.sql +++ b/src/test/regress/sql/partition_prune.sql @@ -1339,3 +1339,21 @@ drop operator class part_test_int4_ops2 using hash; drop operator ===(int4, int4); drop function explain_analyze(text); + +-- Runtime pruning on UPDATE using WITH CHECK OPTIONS and RETURNING +create table part_abc (a int, b text, c bool) partition by list (a); +create table part_abc_1 (b text, a int, c bool); +create table part_abc_2 (a int, c bool, b text); +alter table part_abc attach partition part_abc_1 for values in (1); +alter table part_abc attach partition part_abc_2 for values in (2); +insert into part_abc values (1, 'b', true); +insert into part_abc values (2, 'c', true); +create view part_abc_view as select * from part_abc where b <> 'a' with check option; +prepare update_part_abc_view as update part_abc_view set b = $2 where a = $1 returning *; +explain (costs off) execute update_part_abc_view (1, 'd'); +execute update_part_abc_view (1, 'd'); +explain (costs off) execute update_part_abc_view (2, 'a'); +execute update_part_abc_view (2, 'a'); +deallocate update_part_abc_view; +drop view part_abc_view; +drop table part_abc; -- 2.43.0