diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index b4b85fd681..e60b484f47 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -246,7 +246,6 @@ static bool group_by_has_partkey(RelOptInfo *input_rel, List *targetList, List *groupClause); static int common_prefix_cmp(const void *a, const void *b); -static bool query_has_modifying_cte(Query *parse); /***************************************************************************** * @@ -314,22 +313,6 @@ standard_planner(Query *parse, const char *query_string, int cursorOptions, glob->transientPlan = false; glob->dependsOnRole = false; - if (IsModifySupportedInParallelMode(parse->commandType) && - !parse->hasModifyingCTE) - { - /* - * FIXME - * There is a known bug in the query rewriter: re-written queries with - * a modifying CTE may not have the "hasModifyingCTE" flag set. When - * that bug is fixed, this temporary fix must be removed. - * - * Note that here we've made a fix for this problem only for a - * supported-in-parallel-mode table-modification statement (i.e. - * INSERT), but this bug exists for SELECT too. - */ - parse->hasModifyingCTE = query_has_modifying_cte(parse); - } - /* * Assess whether it's feasible to use parallel mode for this query. We * can't do this in a standalone backend, or if the command will try to @@ -7788,53 +7771,3 @@ group_by_has_partkey(RelOptInfo *input_rel, return true; } - -/* - * Determine if the specified query has a modifying-CTE. - * - * There is a known bug in the query rewriter: re-written queries with - * a modifying CTE may not have the "hasModifyingCTE" flag set. When - * that bug is fixed, this function should be removed. - * - */ -static bool -query_has_modifying_cte(Query *parsetree) -{ - int rt_index; - bool hasModifyingCTE = false; - - /* Recursively check subqueries */ - rt_index = 0; - while (rt_index < list_length(parsetree->rtable)) - { - RangeTblEntry *rte; - ++rt_index; - rte = rt_fetch(rt_index, parsetree->rtable); - if (rte->rtekind == RTE_SUBQUERY) - { - hasModifyingCTE = query_has_modifying_cte(rte->subquery); - if (hasModifyingCTE) - break; - } - } - - if (!hasModifyingCTE) - { - ListCell *lc; - - /* Check for INSERT/UPDATE/DELETE CTEs */ - foreach(lc, parsetree->cteList) - { - CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc); - Query *ctequery = castNode(Query, cte->ctequery); - - if (ctequery->commandType != CMD_SELECT) - { - hasModifyingCTE = true; - break; - } - } - } - - return hasModifyingCTE; -} diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index af8b6d4437..4a918068e8 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -716,6 +716,25 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context) return true; } + /* + * ModifyingCTE expressions are treated as parallel-unsafe. + * + * XXX Normally, the Query tree has hasModifyingCTE flag that indicates + * the statement is parallel-unsafe but in some cases where query with + * modifying CTE is re-written that flag is not set. + */ + else if (IsA(node, CommonTableExpr)) + { + CommonTableExpr *cte = (CommonTableExpr *) node; + Query *ctequery = castNode(Query, cte->ctequery); + + if (ctequery->commandType != CMD_SELECT) + { + context->max_hazard = PROPARALLEL_UNSAFE; + return true; + } + } + /* * As a notational convenience for callers, look through RestrictInfo. */ @@ -796,6 +815,8 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context) if (rte == context->target_rte) return target_rel_max_parallel_hazard(context); + else if (rte->rtekind == RTE_SUBQUERY) + return max_parallel_hazard_walker((Node *) rte->subquery, context); return false; }