src/test/regress/expected/select_parallel.out

   1 --
   2 -- PARALLEL
   3 --
   4 create function sp_parallel_restricted(int) returns int as
   5   $$begin return $1; end$$ language plpgsql parallel restricted;
   6 begin;
   7 -- encourage use of parallel plans
   8 set parallel_setup_cost=0;
   9 set parallel_tuple_cost=0;
  10 set min_parallel_table_scan_size=0;
  11 set max_parallel_workers_per_gather=4;
  12 -- Parallel Append with partial-subplans
  13 explain (costs off)
  14   select round(avg(aa)), sum(aa) from a_star;
  15                           QUERY PLAN
  16 --------------------------------------------------------------
  17  Finalize Aggregate
  18    ->  Gather
  19          Workers Planned: 3
  20          ->  Partial Aggregate
  21                ->  Parallel Append
  22                      ->  Parallel Seq Scan on d_star a_star_4
  23                      ->  Parallel Seq Scan on f_star a_star_6
  24                      ->  Parallel Seq Scan on e_star a_star_5
  25                      ->  Parallel Seq Scan on b_star a_star_2
  26                      ->  Parallel Seq Scan on c_star a_star_3
  27                      ->  Parallel Seq Scan on a_star a_star_1
  28 (11 rows)
  29
  30 select round(avg(aa)), sum(aa) from a_star a1;
  31  round | sum
  32 -------+-----
  33     14 | 355
  34 (1 row)
  35
  36 -- Parallel Append with both partial and non-partial subplans
  37 alter table c_star set (parallel_workers = 0);
  38 alter table d_star set (parallel_workers = 0);
  39 explain (costs off)
  40   select round(avg(aa)), sum(aa) from a_star;
  41                           QUERY PLAN
  42 --------------------------------------------------------------
  43  Finalize Aggregate
  44    ->  Gather
  45          Workers Planned: 3
  46          ->  Partial Aggregate
  47                ->  Parallel Append
  48                      ->  Seq Scan on d_star a_star_4
  49                      ->  Seq Scan on c_star a_star_3
  50                      ->  Parallel Seq Scan on f_star a_star_6
  51                      ->  Parallel Seq Scan on e_star a_star_5
  52                      ->  Parallel Seq Scan on b_star a_star_2
  53                      ->  Parallel Seq Scan on a_star a_star_1
  54 (11 rows)
  55
  56 select round(avg(aa)), sum(aa) from a_star a2;
  57  round | sum
  58 -------+-----
  59     14 | 355
  60 (1 row)
  61
  62 -- Parallel Append with only non-partial subplans
  63 alter table a_star set (parallel_workers = 0);
  64 alter table b_star set (parallel_workers = 0);
  65 alter table e_star set (parallel_workers = 0);
  66 alter table f_star set (parallel_workers = 0);
  67 explain (costs off)
  68   select round(avg(aa)), sum(aa) from a_star;
  69                      QUERY PLAN
  70 -----------------------------------------------------
  71  Finalize Aggregate
  72    ->  Gather
  73          Workers Planned: 3
  74          ->  Partial Aggregate
  75                ->  Parallel Append
  76                      ->  Seq Scan on d_star a_star_4
  77                      ->  Seq Scan on f_star a_star_6
  78                      ->  Seq Scan on e_star a_star_5
  79                      ->  Seq Scan on b_star a_star_2
  80                      ->  Seq Scan on c_star a_star_3
  81                      ->  Seq Scan on a_star a_star_1
  82 (11 rows)
  83
  84 select round(avg(aa)), sum(aa) from a_star a3;
  85  round | sum
  86 -------+-----
  87     14 | 355
  88 (1 row)
  89
  90 -- Disable Parallel Append
  91 alter table a_star reset (parallel_workers);
  92 alter table b_star reset (parallel_workers);
  93 alter table c_star reset (parallel_workers);
  94 alter table d_star reset (parallel_workers);
  95 alter table e_star reset (parallel_workers);
  96 alter table f_star reset (parallel_workers);
  97 set enable_parallel_append to off;
  98 explain (costs off)
  99   select round(avg(aa)), sum(aa) from a_star;
 100                           QUERY PLAN
 101 --------------------------------------------------------------
 102  Finalize Aggregate
 103    ->  Gather
 104          Workers Planned: 1
 105          ->  Partial Aggregate
 106                ->  Append
 107                      ->  Parallel Seq Scan on a_star a_star_1
 108                      ->  Parallel Seq Scan on b_star a_star_2
 109                      ->  Parallel Seq Scan on c_star a_star_3
 110                      ->  Parallel Seq Scan on d_star a_star_4
 111                      ->  Parallel Seq Scan on e_star a_star_5
 112                      ->  Parallel Seq Scan on f_star a_star_6
 113 (11 rows)
 114
 115 select round(avg(aa)), sum(aa) from a_star a4;
 116  round | sum
 117 -------+-----
 118     14 | 355
 119 (1 row)
 120
 121 reset enable_parallel_append;
 122 -- Parallel Append that runs serially
 123 create function sp_test_func() returns setof text as
 124 $$ select 'foo'::varchar union all select 'bar'::varchar $$
 125 language sql stable;
 126 select sp_test_func() order by 1;
 127  sp_test_func
 128 --------------
 129  bar
 130  foo
 131 (2 rows)
 132
 133 -- Parallel Append is not to be used when the subpath depends on the outer param
 134 create table part_pa_test(a int, b int) partition by range(a);
 135 create table part_pa_test_p1 partition of part_pa_test for values from (minvalue) to (0);
 136 create table part_pa_test_p2 partition of part_pa_test for values from (0) to (maxvalue);
 137 explain (costs off)
 138         select (select max((select pa1.b from part_pa_test pa1 where pa1.a = pa2.a)))
 139         from part_pa_test pa2;
 140                           QUERY PLAN
 141 --------------------------------------------------------------
 142  Aggregate
 143    ->  Gather
 144          Workers Planned: 3
 145          ->  Parallel Append
 146                ->  Parallel Seq Scan on part_pa_test_p1 pa2_1
 147                ->  Parallel Seq Scan on part_pa_test_p2 pa2_2
 148    SubPlan 2
 149      ->  Result
 150    SubPlan 1
 151      ->  Append
 152            ->  Seq Scan on part_pa_test_p1 pa1_1
 153                  Filter: (a = pa2.a)
 154            ->  Seq Scan on part_pa_test_p2 pa1_2
 155                  Filter: (a = pa2.a)
 156 (14 rows)
 157
 158 drop table part_pa_test;
 159 -- test with leader participation disabled
 160 set parallel_leader_participation = off;
 161 explain (costs off)
 162   select count(*) from tenk1 where stringu1 = 'GRAAAA';
 163                        QUERY PLAN
 164 ---------------------------------------------------------
 165  Finalize Aggregate
 166    ->  Gather
 167          Workers Planned: 4
 168          ->  Partial Aggregate
 169                ->  Parallel Seq Scan on tenk1
 170                      Filter: (stringu1 = 'GRAAAA'::name)
 171 (6 rows)
 172
 173 select count(*) from tenk1 where stringu1 = 'GRAAAA';
 174  count
 175 -------
 176     15
 177 (1 row)
 178
 179 -- test with leader participation disabled, but no workers available (so
 180 -- the leader will have to run the plan despite the setting)
 181 set max_parallel_workers = 0;
 182 explain (costs off)
 183   select count(*) from tenk1 where stringu1 = 'GRAAAA';
 184                        QUERY PLAN
 185 ---------------------------------------------------------
 186  Finalize Aggregate
 187    ->  Gather
 188          Workers Planned: 4
 189          ->  Partial Aggregate
 190                ->  Parallel Seq Scan on tenk1
 191                      Filter: (stringu1 = 'GRAAAA'::name)
 192 (6 rows)
 193
 194 select count(*) from tenk1 where stringu1 = 'GRAAAA';
 195  count
 196 -------
 197     15
 198 (1 row)
 199
 200 reset max_parallel_workers;
 201 reset parallel_leader_participation;
 202 -- test that parallel_restricted function doesn't run in worker
 203 alter table tenk1 set (parallel_workers = 4);
 204 explain (verbose, costs off)
 205 select sp_parallel_restricted(unique1) from tenk1
 206   where stringu1 = 'GRAAAA' order by 1;
 207                        QUERY PLAN
 208 ---------------------------------------------------------
 209  Sort
 210    Output: (sp_parallel_restricted(unique1))
 211    Sort Key: (sp_parallel_restricted(tenk1.unique1))
 212    ->  Gather
 213          Output: sp_parallel_restricted(unique1)
 214          Workers Planned: 4
 215          ->  Parallel Seq Scan on public.tenk1
 216                Output: unique1
 217                Filter: (tenk1.stringu1 = 'GRAAAA'::name)
 218 (9 rows)
 219
 220 -- test parallel plan when group by expression is in target list.
 221 explain (costs off)
 222         select length(stringu1) from tenk1 group by length(stringu1);
 223                     QUERY PLAN
 224 ---------------------------------------------------
 225  Finalize HashAggregate
 226    Group Key: (length((stringu1)::text))
 227    ->  Gather
 228          Workers Planned: 4
 229          ->  Partial HashAggregate
 230                Group Key: length((stringu1)::text)
 231                ->  Parallel Seq Scan on tenk1
 232 (7 rows)
 233
 234 select length(stringu1) from tenk1 group by length(stringu1);
 235  length
 236 --------
 237       6
 238 (1 row)
 239
 240 explain (costs off)
 241         select stringu1, count(*) from tenk1 group by stringu1 order by stringu1;
 242                      QUERY PLAN
 243 ----------------------------------------------------
 244  Sort
 245    Sort Key: stringu1
 246    ->  Finalize HashAggregate
 247          Group Key: stringu1
 248          ->  Gather
 249                Workers Planned: 4
 250                ->  Partial HashAggregate
 251                      Group Key: stringu1
 252                      ->  Parallel Seq Scan on tenk1
 253 (9 rows)
 254
 255 -- test that parallel plan for aggregates is not selected when
 256 -- target list contains parallel restricted clause.
 257 explain (costs off)
 258         select  sum(sp_parallel_restricted(unique1)) from tenk1
 259         group by(sp_parallel_restricted(unique1));
 260                             QUERY PLAN
 261 -------------------------------------------------------------------
 262  HashAggregate
 263    Group Key: sp_parallel_restricted(unique1)
 264    ->  Gather
 265          Workers Planned: 4
 266          ->  Parallel Index Only Scan using tenk1_unique1 on tenk1
 267 (5 rows)
 268
 269 -- test prepared statement
 270 prepare tenk1_count(integer) As select  count((unique1)) from tenk1 where hundred > $1;
 271 explain (costs off) execute tenk1_count(1);
 272                   QUERY PLAN
 273 ----------------------------------------------
 274  Finalize Aggregate
 275    ->  Gather
 276          Workers Planned: 4
 277          ->  Partial Aggregate
 278                ->  Parallel Seq Scan on tenk1
 279                      Filter: (hundred > 1)
 280 (6 rows)
 281
 282 execute tenk1_count(1);
 283  count
 284 -------
 285   9800
 286 (1 row)
 287
 288 deallocate tenk1_count;
 289 -- test parallel plans for queries containing un-correlated subplans.
 290 alter table tenk2 set (parallel_workers = 0);
 291 explain (costs off)
 292         select count(*) from tenk1 where (two, four) not in
 293         (select hundred, thousand from tenk2 where thousand > 100);
 294                       QUERY PLAN
 295 ------------------------------------------------------
 296  Finalize Aggregate
 297    ->  Gather
 298          Workers Planned: 4
 299          ->  Partial Aggregate
 300                ->  Parallel Seq Scan on tenk1
 301                      Filter: (NOT (hashed SubPlan 1))
 302                      SubPlan 1
 303                        ->  Seq Scan on tenk2
 304                              Filter: (thousand > 100)
 305 (9 rows)
 306
 307 select count(*) from tenk1 where (two, four) not in
 308         (select hundred, thousand from tenk2 where thousand > 100);
 309  count
 310 -------
 311  10000
 312 (1 row)
 313
 314 -- this is not parallel-safe due to use of random() within SubLink's testexpr:
 315 explain (costs off)
 316         select * from tenk1 where (unique1 + random())::integer not in
 317         (select ten from tenk2);
 318              QUERY PLAN
 319 ------------------------------------
 320  Seq Scan on tenk1
 321    Filter: (NOT (hashed SubPlan 1))
 322    SubPlan 1
 323      ->  Seq Scan on tenk2
 324 (4 rows)
 325
 326 alter table tenk2 reset (parallel_workers);
 327 -- test parallel plan for a query containing initplan.
 328 set enable_indexscan = off;
 329 set enable_indexonlyscan = off;
 330 set enable_bitmapscan = off;
 331 alter table tenk2 set (parallel_workers = 2);
 332 explain (costs off)
 333         select count(*) from tenk1
 334         where tenk1.unique1 = (Select max(tenk2.unique1) from tenk2);
 335                       QUERY PLAN
 336 ------------------------------------------------------
 337  Aggregate
 338    InitPlan 1 (returns $2)
 339      ->  Finalize Aggregate
 340            ->  Gather
 341                  Workers Planned: 2
 342                  ->  Partial Aggregate
 343                        ->  Parallel Seq Scan on tenk2
 344    ->  Gather
 345          Workers Planned: 4
 346          Params Evaluated: $2
 347          ->  Parallel Seq Scan on tenk1
 348                Filter: (unique1 = $2)
 349 (12 rows)
 350
 351 select count(*) from tenk1
 352     where tenk1.unique1 = (Select max(tenk2.unique1) from tenk2);
 353  count
 354 -------
 355      1
 356 (1 row)
 357
 358 reset enable_indexscan;
 359 reset enable_indexonlyscan;
 360 reset enable_bitmapscan;
 361 alter table tenk2 reset (parallel_workers);
 362 -- test parallel index scans.
 363 set enable_seqscan to off;
 364 set enable_bitmapscan to off;
 365 explain (costs off)
 366         select  count((unique1)) from tenk1 where hundred > 1;
 367                              QUERY PLAN
 368 --------------------------------------------------------------------
 369  Finalize Aggregate
 370    ->  Gather
 371          Workers Planned: 4
 372          ->  Partial Aggregate
 373                ->  Parallel Index Scan using tenk1_hundred on tenk1
 374                      Index Cond: (hundred > 1)
 375 (6 rows)
 376
 377 select  count((unique1)) from tenk1 where hundred > 1;
 378  count
 379 -------
 380   9800
 381 (1 row)
 382
 383 -- test parallel index-only scans.
 384 explain (costs off)
 385         select  count(*) from tenk1 where thousand > 95;
 386                                    QUERY PLAN
 387 --------------------------------------------------------------------------------
 388  Finalize Aggregate
 389    ->  Gather
 390          Workers Planned: 4
 391          ->  Partial Aggregate
 392                ->  Parallel Index Only Scan using tenk1_thous_tenthous on tenk1
 393                      Index Cond: (thousand > 95)
 394 (6 rows)
 395
 396 select  count(*) from tenk1 where thousand > 95;
 397  count
 398 -------
 399   9040
 400 (1 row)
 401
 402 -- test rescan cases too
 403 set enable_material = false;
 404 explain (costs off)
 405 select * from
 406   (select count(unique1) from tenk1 where hundred > 10) ss
 407   right join (values (1),(2),(3)) v(x) on true;
 408                                 QUERY PLAN
 409 --------------------------------------------------------------------------
 410  Nested Loop Left Join
 411    ->  Values Scan on "*VALUES*"
 412    ->  Finalize Aggregate
 413          ->  Gather
 414                Workers Planned: 4
 415                ->  Partial Aggregate
 416                      ->  Parallel Index Scan using tenk1_hundred on tenk1
 417                            Index Cond: (hundred > 10)
 418 (8 rows)
 419
 420 select * from
 421   (select count(unique1) from tenk1 where hundred > 10) ss
 422   right join (values (1),(2),(3)) v(x) on true;
 423  count | x
 424 -------+---
 425   8900 | 1
 426   8900 | 2
 427   8900 | 3
 428 (3 rows)
 429
 430 explain (costs off)
 431 select * from
 432   (select count(*) from tenk1 where thousand > 99) ss
 433   right join (values (1),(2),(3)) v(x) on true;
 434                                       QUERY PLAN
 435 --------------------------------------------------------------------------------------
 436  Nested Loop Left Join
 437    ->  Values Scan on "*VALUES*"
 438    ->  Finalize Aggregate
 439          ->  Gather
 440                Workers Planned: 4
 441                ->  Partial Aggregate
 442                      ->  Parallel Index Only Scan using tenk1_thous_tenthous on tenk1
 443                            Index Cond: (thousand > 99)
 444 (8 rows)
 445
 446 select * from
 447   (select count(*) from tenk1 where thousand > 99) ss
 448   right join (values (1),(2),(3)) v(x) on true;
 449  count | x
 450 -------+---
 451   9000 | 1
 452   9000 | 2
 453   9000 | 3
 454 (3 rows)
 455
 456 -- test rescans for a Limit node with a parallel node beneath it.
 457 reset enable_seqscan;
 458 set enable_indexonlyscan to off;
 459 set enable_indexscan to off;
 460 alter table tenk1 set (parallel_workers = 0);
 461 alter table tenk2 set (parallel_workers = 1);
 462 explain (costs off)
 463 select count(*) from tenk1
 464   left join (select tenk2.unique1 from tenk2 order by 1 limit 1000) ss
 465   on tenk1.unique1 < ss.unique1 + 1
 466   where tenk1.unique1 < 2;
 467                          QUERY PLAN
 468 ------------------------------------------------------------
 469  Aggregate
 470    ->  Nested Loop Left Join
 471          Join Filter: (tenk1.unique1 < (tenk2.unique1 + 1))
 472          ->  Seq Scan on tenk1
 473                Filter: (unique1 < 2)
 474          ->  Limit
 475                ->  Gather Merge
 476                      Workers Planned: 1
 477                      ->  Sort
 478                            Sort Key: tenk2.unique1
 479                            ->  Parallel Seq Scan on tenk2
 480 (11 rows)
 481
 482 select count(*) from tenk1
 483   left join (select tenk2.unique1 from tenk2 order by 1 limit 1000) ss
 484   on tenk1.unique1 < ss.unique1 + 1
 485   where tenk1.unique1 < 2;
 486  count
 487 -------
 488   1999
 489 (1 row)
 490
 491 --reset the value of workers for each table as it was before this test.
 492 alter table tenk1 set (parallel_workers = 4);
 493 alter table tenk2 reset (parallel_workers);
 494 reset enable_material;
 495 reset enable_bitmapscan;
 496 reset enable_indexonlyscan;
 497 reset enable_indexscan;
 498 -- test parallel bitmap heap scan.
 499 set enable_seqscan to off;
 500 set enable_indexscan to off;
 501 set enable_hashjoin to off;
 502 set enable_mergejoin to off;
 503 set enable_material to off;
 504 -- test prefetching, if the platform allows it
 505 DO $$
 506 BEGIN
 507  SET effective_io_concurrency = 50;
 508 EXCEPTION WHEN invalid_parameter_value THEN
 509 END $$;
 510 set work_mem='64kB';  --set small work mem to force lossy pages
 511 explain (costs off)
 512         select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0;
 513                          QUERY PLAN
 514 ------------------------------------------------------------
 515  Aggregate
 516    ->  Nested Loop
 517          ->  Seq Scan on tenk2
 518                Filter: (thousand = 0)
 519          ->  Gather
 520                Workers Planned: 4
 521                ->  Parallel Bitmap Heap Scan on tenk1
 522                      Recheck Cond: (hundred > 1)
 523                      ->  Bitmap Index Scan on tenk1_hundred
 524                            Index Cond: (hundred > 1)
 525 (10 rows)
 526
 527 select count(*) from tenk1, tenk2 where tenk1.hundred > 1 and tenk2.thousand=0;
 528  count
 529 -------
 530  98000
 531 (1 row)
 532
 533 create table bmscantest (a int, t text);
 534 insert into bmscantest select r, 'fooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo' FROM generate_series(1,100000) r;
 535 create index i_bmtest ON bmscantest(a);
 536 select count(*) from bmscantest where a>1;
 537  count
 538 -------
 539  99999
 540 (1 row)
 541
 542 -- test accumulation of stats for parallel nodes
 543 reset enable_seqscan;
 544 alter table tenk2 set (parallel_workers = 0);
 545 explain (analyze, timing off, summary off, costs off)
 546    select count(*) from tenk1, tenk2 where tenk1.hundred > 1
 547         and tenk2.thousand=0;
 548                                 QUERY PLAN
 549 --------------------------------------------------------------------------
 550  Aggregate (actual rows=1 loops=1)
 551    ->  Nested Loop (actual rows=98000 loops=1)
 552          ->  Seq Scan on tenk2 (actual rows=10 loops=1)
 553                Filter: (thousand = 0)
 554                Rows Removed by Filter: 9990
 555          ->  Gather (actual rows=9800 loops=10)
 556                Workers Planned: 4
 557                Workers Launched: 4
 558                ->  Parallel Seq Scan on tenk1 (actual rows=1960 loops=50)
 559                      Filter: (hundred > 1)
 560                      Rows Removed by Filter: 40
 561 (11 rows)
 562
 563 alter table tenk2 reset (parallel_workers);
 564 reset work_mem;
 565 create function explain_parallel_sort_stats() returns setof text
 566 language plpgsql as
 567 $$
 568 declare ln text;
 569 begin
 570     for ln in
 571         explain (analyze, timing off, summary off, costs off)
 572           select * from
 573           (select ten from tenk1 where ten < 100 order by ten) ss
 574           right join (values (1),(2),(3)) v(x) on true
 575     loop
 576         ln := regexp_replace(ln, 'Memory: \S*',  'Memory: xxx');
 577         return next ln;
 578     end loop;
 579 end;
 580 $$;
 581 select * from explain_parallel_sort_stats();
 582                        explain_parallel_sort_stats
 583 --------------------------------------------------------------------------
 584  Nested Loop Left Join (actual rows=30000 loops=1)
 585    ->  Values Scan on "*VALUES*" (actual rows=3 loops=1)
 586    ->  Gather Merge (actual rows=10000 loops=3)
 587          Workers Planned: 4
 588          Workers Launched: 4
 589          ->  Sort (actual rows=2000 loops=15)
 590                Sort Key: tenk1.ten
 591                Sort Method: quicksort  Memory: xxx
 592                Worker 0:  Sort Method: quicksort  Memory: xxx
 593                Worker 1:  Sort Method: quicksort  Memory: xxx
 594                Worker 2:  Sort Method: quicksort  Memory: xxx
 595                Worker 3:  Sort Method: quicksort  Memory: xxx
 596                ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=15)
 597                      Filter: (ten < 100)
 598 (14 rows)
 599
 600 reset enable_indexscan;
 601 reset enable_hashjoin;
 602 reset enable_mergejoin;
 603 reset enable_material;
 604 reset effective_io_concurrency;
 605 drop table bmscantest;
 606 drop function explain_parallel_sort_stats();
 607 -- test parallel merge join path.
 608 set enable_hashjoin to off;
 609 set enable_nestloop to off;
 610 explain (costs off)
 611         select  count(*) from tenk1, tenk2 where tenk1.unique1 = tenk2.unique1;
 612                                   QUERY PLAN
 613 -------------------------------------------------------------------------------
 614  Finalize Aggregate
 615    ->  Gather
 616          Workers Planned: 4
 617          ->  Partial Aggregate
 618                ->  Merge Join
 619                      Merge Cond: (tenk1.unique1 = tenk2.unique1)
 620                      ->  Parallel Index Only Scan using tenk1_unique1 on tenk1
 621                      ->  Index Only Scan using tenk2_unique1 on tenk2
 622 (8 rows)
 623
 624 select  count(*) from tenk1, tenk2 where tenk1.unique1 = tenk2.unique1;
 625  count
 626 -------
 627  10000
 628 (1 row)
 629
 630 reset enable_hashjoin;
 631 reset enable_nestloop;
 632 -- test gather merge
 633 set enable_hashagg = false;
 634 explain (costs off)
 635    select count(*) from tenk1 group by twenty;
 636                      QUERY PLAN
 637 ----------------------------------------------------
 638  Finalize GroupAggregate
 639    Group Key: twenty
 640    ->  Gather Merge
 641          Workers Planned: 4
 642          ->  Partial GroupAggregate
 643                Group Key: twenty
 644                ->  Sort
 645                      Sort Key: twenty
 646                      ->  Parallel Seq Scan on tenk1
 647 (9 rows)
 648
 649 select count(*) from tenk1 group by twenty;
 650  count
 651 -------
 652    500
 653    500
 654    500
 655    500
 656    500
 657    500
 658    500
 659    500
 660    500
 661    500
 662    500
 663    500
 664    500
 665    500
 666    500
 667    500
 668    500
 669    500
 670    500
 671    500
 672 (20 rows)
 673
 674 --test expressions in targetlist are pushed down for gather merge
 675 create function sp_simple_func(var1 integer) returns integer
 676 as $$
 677 begin
 678         return var1 + 10;
 679 end;
 680 $$ language plpgsql PARALLEL SAFE;
 681 explain (costs off, verbose)
 682     select ten, sp_simple_func(ten) from tenk1 where ten < 100 order by ten;
 683                      QUERY PLAN
 684 -----------------------------------------------------
 685  Gather Merge
 686    Output: ten, (sp_simple_func(ten))
 687    Workers Planned: 4
 688    ->  Result
 689          Output: ten, sp_simple_func(ten)
 690          ->  Sort
 691                Output: ten
 692                Sort Key: tenk1.ten
 693                ->  Parallel Seq Scan on public.tenk1
 694                      Output: ten
 695                      Filter: (tenk1.ten < 100)
 696 (11 rows)
 697
 698 drop function sp_simple_func(integer);
 699 -- test handling of SRFs in targetlist (bug in 10.0)
 700 explain (costs off)
 701    select count(*), generate_series(1,2) from tenk1 group by twenty;
 702                         QUERY PLAN
 703 ----------------------------------------------------------
 704  ProjectSet
 705    ->  Finalize GroupAggregate
 706          Group Key: twenty
 707          ->  Gather Merge
 708                Workers Planned: 4
 709                ->  Partial GroupAggregate
 710                      Group Key: twenty
 711                      ->  Sort
 712                            Sort Key: twenty
 713                            ->  Parallel Seq Scan on tenk1
 714 (10 rows)
 715
 716 select count(*), generate_series(1,2) from tenk1 group by twenty;
 717  count | generate_series
 718 -------+-----------------
 719    500 |               1
 720    500 |               2
 721    500 |               1
 722    500 |               2
 723    500 |               1
 724    500 |               2
 725    500 |               1
 726    500 |               2
 727    500 |               1
 728    500 |               2
 729    500 |               1
 730    500 |               2
 731    500 |               1
 732    500 |               2
 733    500 |               1
 734    500 |               2
 735    500 |               1
 736    500 |               2
 737    500 |               1
 738    500 |               2
 739    500 |               1
 740    500 |               2
 741    500 |               1
 742    500 |               2
 743    500 |               1
 744    500 |               2
 745    500 |               1
 746    500 |               2
 747    500 |               1
 748    500 |               2
 749    500 |               1
 750    500 |               2
 751    500 |               1
 752    500 |               2
 753    500 |               1
 754    500 |               2
 755    500 |               1
 756    500 |               2
 757    500 |               1
 758    500 |               2
 759 (40 rows)
 760
 761 -- test gather merge with parallel leader participation disabled
 762 set parallel_leader_participation = off;
 763 explain (costs off)
 764    select count(*) from tenk1 group by twenty;
 765                      QUERY PLAN
 766 ----------------------------------------------------
 767  Finalize GroupAggregate
 768    Group Key: twenty
 769    ->  Gather Merge
 770          Workers Planned: 4
 771          ->  Partial GroupAggregate
 772                Group Key: twenty
 773                ->  Sort
 774                      Sort Key: twenty
 775                      ->  Parallel Seq Scan on tenk1
 776 (9 rows)
 777
 778 select count(*) from tenk1 group by twenty;
 779  count
 780 -------
 781    500
 782    500
 783    500
 784    500
 785    500
 786    500
 787    500
 788    500
 789    500
 790    500
 791    500
 792    500
 793    500
 794    500
 795    500
 796    500
 797    500
 798    500
 799    500
 800    500
 801 (20 rows)
 802
 803 reset parallel_leader_participation;
 804 --test rescan behavior of gather merge
 805 set enable_material = false;
 806 explain (costs off)
 807 select * from
 808   (select string4, count(unique2)
 809    from tenk1 group by string4 order by string4) ss
 810   right join (values (1),(2),(3)) v(x) on true;
 811                         QUERY PLAN
 812 ----------------------------------------------------------
 813  Nested Loop Left Join
 814    ->  Values Scan on "*VALUES*"
 815    ->  Finalize GroupAggregate
 816          Group Key: tenk1.string4
 817          ->  Gather Merge
 818                Workers Planned: 4
 819                ->  Partial GroupAggregate
 820                      Group Key: tenk1.string4
 821                      ->  Sort
 822                            Sort Key: tenk1.string4
 823                            ->  Parallel Seq Scan on tenk1
 824 (11 rows)
 825
 826 select * from
 827   (select string4, count(unique2)
 828    from tenk1 group by string4 order by string4) ss
 829   right join (values (1),(2),(3)) v(x) on true;
 830  string4 | count | x
 831 ---------+-------+---
 832  AAAAxx  |  2500 | 1
 833  HHHHxx  |  2500 | 1
 834  OOOOxx  |  2500 | 1
 835  VVVVxx  |  2500 | 1
 836  AAAAxx  |  2500 | 2
 837  HHHHxx  |  2500 | 2
 838  OOOOxx  |  2500 | 2
 839  VVVVxx  |  2500 | 2
 840  AAAAxx  |  2500 | 3
 841  HHHHxx  |  2500 | 3
 842  OOOOxx  |  2500 | 3
 843  VVVVxx  |  2500 | 3
 844 (12 rows)
 845
 846 reset enable_material;
 847 reset enable_hashagg;
 848 -- check parallelized int8 aggregate (bug #14897)
 849 explain (costs off)
 850 select avg(unique1::int8) from tenk1;
 851                                QUERY PLAN
 852 -------------------------------------------------------------------------
 853  Finalize Aggregate
 854    ->  Gather
 855          Workers Planned: 4
 856          ->  Partial Aggregate
 857                ->  Parallel Index Only Scan using tenk1_unique1 on tenk1
 858 (5 rows)
 859
 860 select avg(unique1::int8) from tenk1;
 861           avg
 862 -----------------------
 863  4999.5000000000000000
 864 (1 row)
 865
 866 -- gather merge test with a LIMIT
 867 explain (costs off)
 868   select fivethous from tenk1 order by fivethous limit 4;
 869                   QUERY PLAN
 870 ----------------------------------------------
 871  Limit
 872    ->  Gather Merge
 873          Workers Planned: 4
 874          ->  Sort
 875                Sort Key: fivethous
 876                ->  Parallel Seq Scan on tenk1
 877 (6 rows)
 878
 879 select fivethous from tenk1 order by fivethous limit 4;
 880  fivethous
 881 -----------
 882          0
 883          0
 884          1
 885          1
 886 (4 rows)
 887
 888 -- gather merge test with 0 worker
 889 set max_parallel_workers = 0;
 890 explain (costs off)
 891    select string4 from tenk1 order by string4 limit 5;
 892                   QUERY PLAN
 893 ----------------------------------------------
 894  Limit
 895    ->  Gather Merge
 896          Workers Planned: 4
 897          ->  Sort
 898                Sort Key: string4
 899                ->  Parallel Seq Scan on tenk1
 900 (6 rows)
 901
 902 select string4 from tenk1 order by string4 limit 5;
 903  string4
 904 ---------
 905  AAAAxx
 906  AAAAxx
 907  AAAAxx
 908  AAAAxx
 909  AAAAxx
 910 (5 rows)
 911
 912 -- gather merge test with 0 workers, with parallel leader
 913 -- participation disabled (the leader will have to run the plan
 914 -- despite the setting)
 915 set parallel_leader_participation = off;
 916 explain (costs off)
 917    select string4 from tenk1 order by string4 limit 5;
 918                   QUERY PLAN
 919 ----------------------------------------------
 920  Limit
 921    ->  Gather Merge
 922          Workers Planned: 4
 923          ->  Sort
 924                Sort Key: string4
 925                ->  Parallel Seq Scan on tenk1
 926 (6 rows)
 927
 928 select string4 from tenk1 order by string4 limit 5;
 929  string4
 930 ---------
 931  AAAAxx
 932  AAAAxx
 933  AAAAxx
 934  AAAAxx
 935  AAAAxx
 936 (5 rows)
 937
 938 reset parallel_leader_participation;
 939 reset max_parallel_workers;
 940 SAVEPOINT settings;
 941 SET LOCAL force_parallel_mode = 1;
 942 explain (costs off)
 943   select stringu1::int2 from tenk1 where unique1 = 1;
 944                   QUERY PLAN
 945 -----------------------------------------------
 946  Gather
 947    Workers Planned: 1
 948    Single Copy: true
 949    ->  Index Scan using tenk1_unique1 on tenk1
 950          Index Cond: (unique1 = 1)
 951 (5 rows)
 952
 953 ROLLBACK TO SAVEPOINT settings;
 954 -- exercise record typmod remapping between backends
 955 CREATE FUNCTION make_record(n int)
 956   RETURNS RECORD LANGUAGE plpgsql PARALLEL SAFE AS
 957 $$
 958 BEGIN
 959   RETURN CASE n
 960            WHEN 1 THEN ROW(1)
 961            WHEN 2 THEN ROW(1, 2)
 962            WHEN 3 THEN ROW(1, 2, 3)
 963            WHEN 4 THEN ROW(1, 2, 3, 4)
 964            ELSE ROW(1, 2, 3, 4, 5)
 965          END;
 966 END;
 967 $$;
 968 SAVEPOINT settings;
 969 SET LOCAL force_parallel_mode = 1;
 970 SELECT make_record(x) FROM (SELECT generate_series(1, 5) x) ss ORDER BY x;
 971  make_record
 972 -------------
 973  (1)
 974  (1,2)
 975  (1,2,3)
 976  (1,2,3,4)
 977  (1,2,3,4,5)
 978 (5 rows)
 979
 980 ROLLBACK TO SAVEPOINT settings;
 981 DROP function make_record(n int);
 982 -- test the sanity of parallel query after the active role is dropped.
 983 drop role if exists regress_parallel_worker;
 984 NOTICE:  role "regress_parallel_worker" does not exist, skipping
 985 create role regress_parallel_worker;
 986 set role regress_parallel_worker;
 987 reset session authorization;
 988 drop role regress_parallel_worker;
 989 set force_parallel_mode = 1;
 990 select count(*) from tenk1;
 991  count
 992 -------
 993  10000
 994 (1 row)
 995
 996 reset force_parallel_mode;
 997 reset role;
 998 -- Window function calculation can't be pushed to workers.
 999 explain (costs off, verbose)
1000   select count(*) from tenk1 a where (unique1, two) in
1001     (select unique1, row_number() over() from tenk1 b);
1002                                           QUERY PLAN
1003 ----------------------------------------------------------------------------------------------
1004  Aggregate
1005    Output: count(*)
1006    ->  Hash Semi Join
1007          Hash Cond: ((a.unique1 = b.unique1) AND (a.two = (row_number() OVER (?))))
1008          ->  Gather
1009                Output: a.unique1, a.two
1010                Workers Planned: 4
1011                ->  Parallel Seq Scan on public.tenk1 a
1012                      Output: a.unique1, a.two
1013          ->  Hash
1014                Output: b.unique1, (row_number() OVER (?))
1015                ->  WindowAgg
1016                      Output: b.unique1, row_number() OVER (?)
1017                      ->  Gather
1018                            Output: b.unique1
1019                            Workers Planned: 4
1020                            ->  Parallel Index Only Scan using tenk1_unique1 on public.tenk1 b
1021                                  Output: b.unique1
1022 (18 rows)
1023
1024 -- LIMIT/OFFSET within sub-selects can't be pushed to workers.
1025 explain (costs off)
1026   select * from tenk1 a where two in
1027     (select two from tenk1 b where stringu1 like '%AAAA' limit 3);
1028                           QUERY PLAN
1029 ---------------------------------------------------------------
1030  Hash Semi Join
1031    Hash Cond: (a.two = b.two)
1032    ->  Gather
1033          Workers Planned: 4
1034          ->  Parallel Seq Scan on tenk1 a
1035    ->  Hash
1036          ->  Limit
1037                ->  Gather
1038                      Workers Planned: 4
1039                      ->  Parallel Seq Scan on tenk1 b
1040                            Filter: (stringu1 ~~ '%AAAA'::text)
1041 (11 rows)
1042
1043 -- to increase the parallel query test coverage
1044 SAVEPOINT settings;
1045 SET LOCAL force_parallel_mode = 1;
1046 EXPLAIN (analyze, timing off, summary off, costs off) SELECT * FROM tenk1;
1047                          QUERY PLAN
1048 -------------------------------------------------------------
1049  Gather (actual rows=10000 loops=1)
1050    Workers Planned: 4
1051    Workers Launched: 4
1052    ->  Parallel Seq Scan on tenk1 (actual rows=2000 loops=5)
1053 (4 rows)
1054
1055 ROLLBACK TO SAVEPOINT settings;
1056 -- provoke error in worker
1057 -- (make the error message long enough to require multiple bufferloads)
1058 SAVEPOINT settings;
1059 SET LOCAL force_parallel_mode = 1;
1060 select (stringu1 || repeat('abcd', 5000))::int2 from tenk1 where unique1 = 1;
1061 ERROR:  invalid input syntax for type smallint: "BAAAAAabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"
1062 CONTEXT:  parallel worker
1063 ROLLBACK TO SAVEPOINT settings;
1064 -- test interaction with set-returning functions
1065 SAVEPOINT settings;
1066 -- multiple subqueries under a single Gather node
1067 -- must set parallel_setup_cost > 0 to discourage multiple Gather nodes
1068 SET LOCAL parallel_setup_cost = 10;
1069 EXPLAIN (COSTS OFF)
1070 SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1
1071 UNION ALL
1072 SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1;
1073                      QUERY PLAN
1074 ----------------------------------------------------
1075  Gather
1076    Workers Planned: 4
1077    ->  Parallel Append
1078          ->  Parallel Seq Scan on tenk1
1079                Filter: (fivethous = (tenthous + 1))
1080          ->  Parallel Seq Scan on tenk1 tenk1_1
1081                Filter: (fivethous = (tenthous + 1))
1082 (7 rows)
1083
1084 ROLLBACK TO SAVEPOINT settings;
1085 -- can't use multiple subqueries under a single Gather node due to initPlans
1086 EXPLAIN (COSTS OFF)
1087 SELECT unique1 FROM tenk1 WHERE fivethous =
1088         (SELECT unique1 FROM tenk1 WHERE fivethous = 1 LIMIT 1)
1089 UNION ALL
1090 SELECT unique1 FROM tenk1 WHERE fivethous =
1091         (SELECT unique2 FROM tenk1 WHERE fivethous = 1 LIMIT 1)
1092 ORDER BY 1;
1093                              QUERY PLAN
1094 --------------------------------------------------------------------
1095  Sort
1096    Sort Key: tenk1.unique1
1097    ->  Append
1098          ->  Gather
1099                Workers Planned: 4
1100                Params Evaluated: $1
1101                InitPlan 1 (returns $1)
1102                  ->  Limit
1103                        ->  Gather
1104                              Workers Planned: 4
1105                              ->  Parallel Seq Scan on tenk1 tenk1_2
1106                                    Filter: (fivethous = 1)
1107                ->  Parallel Seq Scan on tenk1
1108                      Filter: (fivethous = $1)
1109          ->  Gather
1110                Workers Planned: 4
1111                Params Evaluated: $3
1112                InitPlan 2 (returns $3)
1113                  ->  Limit
1114                        ->  Gather
1115                              Workers Planned: 4
1116                              ->  Parallel Seq Scan on tenk1 tenk1_3
1117                                    Filter: (fivethous = 1)
1118                ->  Parallel Seq Scan on tenk1 tenk1_1
1119                      Filter: (fivethous = $3)
1120 (25 rows)
1121
1122 -- test interaction with SRFs
1123 SELECT * FROM information_schema.foreign_data_wrapper_options
1124 ORDER BY 1, 2, 3;
1125  foreign_data_wrapper_catalog | foreign_data_wrapper_name | option_name | option_value
1126 ------------------------------+---------------------------+-------------+--------------
1127 (0 rows)
1128
1129 EXPLAIN (VERBOSE, COSTS OFF)
1130 SELECT generate_series(1, two), array(select generate_series(1, two))
1131   FROM tenk1 ORDER BY tenthous;
1132                               QUERY PLAN
1133 ----------------------------------------------------------------------
1134  ProjectSet
1135    Output: generate_series(1, tenk1.two), (SubPlan 1), tenk1.tenthous
1136    ->  Gather Merge
1137          Output: tenk1.two, tenk1.tenthous
1138          Workers Planned: 4
1139          ->  Result
1140                Output: tenk1.two, tenk1.tenthous
1141                ->  Sort
1142                      Output: tenk1.tenthous, tenk1.two
1143                      Sort Key: tenk1.tenthous
1144                      ->  Parallel Seq Scan on public.tenk1
1145                            Output: tenk1.tenthous, tenk1.two
1146    SubPlan 1
1147      ->  ProjectSet
1148            Output: generate_series(1, tenk1.two)
1149            ->  Result
1150 (16 rows)
1151
1152 -- test passing expanded-value representations to workers
1153 CREATE FUNCTION make_some_array(int,int) returns int[] as
1154 $$declare x int[];
1155   begin
1156     x[1] := $1;
1157     x[2] := $2;
1158     return x;
1159   end$$ language plpgsql parallel safe;
1160 CREATE TABLE fooarr(f1 text, f2 int[], f3 text);
1161 INSERT INTO fooarr VALUES('1', ARRAY[1,2], 'one');
1162 PREPARE pstmt(text, int[]) AS SELECT * FROM fooarr WHERE f1 = $1 AND f2 = $2;
1163 EXPLAIN (COSTS OFF) EXECUTE pstmt('1', make_some_array(1,2));
1164                             QUERY PLAN
1165 ------------------------------------------------------------------
1166  Gather
1167    Workers Planned: 3
1168    ->  Parallel Seq Scan on fooarr
1169          Filter: ((f1 = '1'::text) AND (f2 = '{1,2}'::integer[]))
1170 (4 rows)
1171
1172 EXECUTE pstmt('1', make_some_array(1,2));
1173  f1 |  f2   | f3
1174 ----+-------+-----
1175  1  | {1,2} | one
1176 (1 row)
1177
1178 DEALLOCATE pstmt;
1179 -- test interaction between subquery and partial_paths
1180 CREATE VIEW tenk1_vw_sec WITH (security_barrier) AS SELECT * FROM tenk1;
1181 EXPLAIN (COSTS OFF)
1182 SELECT 1 FROM tenk1_vw_sec
1183   WHERE (SELECT sum(f1) FROM int4_tbl WHERE f1 < unique1) < 100;
1184                             QUERY PLAN
1185 -------------------------------------------------------------------
1186  Subquery Scan on tenk1_vw_sec
1187    Filter: ((SubPlan 1) < 100)
1188    ->  Gather
1189          Workers Planned: 4
1190          ->  Parallel Index Only Scan using tenk1_unique1 on tenk1
1191    SubPlan 1
1192      ->  Aggregate
1193            ->  Seq Scan on int4_tbl
1194                  Filter: (f1 < tenk1_vw_sec.unique1)
1195 (9 rows)
1196
1197 rollback;