src/test/regress/expected/select_parallel.out

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