git.postgresql.org Git - postgresql.git/commitdiff

git projects / postgresql.git / commitdiff

Allow parallel query for prepared statements with generic plans.

author Robert Haas <rhaas@postgresql.org>

2017年10月27日 20:22:39 +0000 (22:22 +0200)

committer Robert Haas <rhaas@postgresql.org>

2017年10月27日 20:22:39 +0000 (22:22 +0200)

This was always intended to work, but due to an oversight in
max_parallel_hazard_walker, it didn't. In testing, we missed the
fact that it was only working for custom plans, where the parameter
value has been substituted for the parameter itself early enough
that everything worked. In a generic plan, the Param node survives
and must be treated as parallel-safe. SerializeParamList provides
for the transmission of parameter values to workers.

Amit Kapila with help from Kuntal Ghosh. Some changes by me.

Discussion: http://postgr.es/m/CAA4eK1+_BuZrmVCeua5Eqnm4Co9DAXdM5HPAOE2J19ePbR912Q@mail.gmail.com

src/backend/optimizer/util/clauses.c patch | blob | blame | history

src/pl/plpgsql/src/pl_exec.c patch | blob | blame | history

src/test/regress/expected/select_parallel.out patch | blob | blame | history

src/test/regress/sql/select_parallel.sql patch | blob | blame | history

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c

index 5344f6167a65a4a0fe69f3bfb8f33a1dd2d43fba..652843a146f76ab736161b0511ecc1996506fbe4 100644 (file)

--- a/src/backend/optimizer/util/clauses.c

+++ b/src/backend/optimizer/util/clauses.c

@@ -1223,13 +1223,17 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)

* We can't pass Params to workers at the moment either, so they are also

- * parallel-restricted, unless they are PARAM_EXEC Params listed in

- * safe_param_ids, meaning they could be generated within the worker.

+ * parallel-restricted, unless they are PARAM_EXTERN Params or are

+ * PARAM_EXEC Params listed in safe_param_ids, meaning they could be

+ * generated within the worker.

else if (IsA(node, Param))

{

Param *param = (Param *) node;

+ if (param->paramkind == PARAM_EXTERN)

+ return false;

if (param->paramkind != PARAM_EXEC ||

!list_member_int(context->safe_param_ids, param->paramid))

{

diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c

index 97166972594997492bc5c2971450743ba3f67f6d..e605ec829e3c424f32a3a52e738646c9788c88bf 100644 (file)

--- a/src/pl/plpgsql/src/pl_exec.c

+++ b/src/pl/plpgsql/src/pl_exec.c

@@ -6588,8 +6588,8 @@ exec_save_simple_expr(PLpgSQL_expr *expr, CachedPlan *cplan)

* force_parallel_mode is on, the planner might've stuck a Gather node

* atop that. The simplest way to deal with this is to look through the

* Gather node. The Gather node's tlist would normally contain a Var

- * referencing the child node's output ... but setrefs.c might also have

- * copied a Const as-is.

+ * referencing the child node's output, but it could also be a Param, or

+ * it could be a Const that setrefs.c copied as-is.

plan = stmt->planTree;

for (;;)

@@ -6616,9 +6616,9 @@ exec_save_simple_expr(PLpgSQL_expr *expr, CachedPlan *cplan)

/* If setrefs.c copied up a Const, no need to look further */

if (IsA(tle_expr, Const))

break;

- /* Otherwise, it better be an outer Var */

- Assert(IsA(tle_expr, Var));

- Assert(((Var *) tle_expr)->varno == OUTER_VAR);

+ /* Otherwise, it had better be a Param or an outer Var */

+ Assert(IsA(tle_expr, Param) || (IsA(tle_expr, Var) &&

+ ((Var *) tle_expr)->varno == OUTER_VAR));

/* Descend to the child node */

plan = plan->lefttree;

}

diff --git a/src/test/regress/expected/select_parallel.out b/src/test/regress/expected/select_parallel.out

index 2ae600f1bbbd130903df860c71fa06947b2e82ec..3c63ad1de86976fd96d23264b304d438a3e736e0 100644 (file)

--- a/src/test/regress/expected/select_parallel.out

+++ b/src/test/regress/expected/select_parallel.out

@@ -101,6 +101,26 @@ explain (costs off)

-> Parallel Index Only Scan using tenk1_unique1 on tenk1

(5 rows)

+-- test prepared statement

+prepare tenk1_count(integer) As select count((unique1)) from tenk1 where hundred > 1ドル;

+explain (costs off) execute tenk1_count(1);

+ QUERY PLAN

+----------------------------------------------

+ Finalize Aggregate

+ -> Gather

+ Workers Planned: 4

+ -> Partial Aggregate

+ -> Parallel Seq Scan on tenk1

+ Filter: (hundred > 1)

+(6 rows)

+execute tenk1_count(1);

+ count

+-------

+ 9800

+(1 row)

+deallocate tenk1_count;

-- test parallel plans for queries containing un-correlated subplans.

alter table tenk2 set (parallel_workers = 0);

explain (costs off)

diff --git a/src/test/regress/sql/select_parallel.sql b/src/test/regress/sql/select_parallel.sql

index 89fe80a35c296d7946e95a5371d74169c0520080..720495c81173982a309729c4928197ef1346befd 100644 (file)

--- a/src/test/regress/sql/select_parallel.sql

+++ b/src/test/regress/sql/select_parallel.sql

@@ -39,6 +39,12 @@ explain (costs off)

select sum(parallel_restricted(unique1)) from tenk1

group by(parallel_restricted(unique1));