expected/ut-J-9.2.out

   1 LOAD 'pg_hint_plan';
   2 SET pg_hint_plan.enable_hint TO on;
   3 SET pg_hint_plan.debug_print TO on;
   4 SET client_min_messages TO LOG;
   5 SET search_path TO public;
   6 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
   7              QUERY PLAN
   8 ------------------------------------
   9  Merge Join
  10    Merge Cond: (t1.c1 = t2.c1)
  11    ->  Index Scan using t1_i1 on t1
  12    ->  Sort
  13          Sort Key: t2.c1
  14          ->  Seq Scan on t2
  15 (6 rows)
  16
  17 ----
  18 ---- No. J-1-1 specified pattern of the object name
  19 ----
  20 -- No. J-1-1-1
  21 /*+HashJoin(t1 t2)*/
  22 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
  23 LOG:  pg_hint_plan:
  24 used hint:
  25 HashJoin(t1 t2)
  26 not used hint:
  27 duplication hint:
  28 error hint:
  29
  30           QUERY PLAN
  31 ------------------------------
  32  Hash Join
  33    Hash Cond: (t1.c1 = t2.c1)
  34    ->  Seq Scan on t1
  35    ->  Hash
  36          ->  Seq Scan on t2
  37 (5 rows)
  38
  39 -- No. J-1-1-2
  40 /*+HashJoin(t1 t2)*/
  41 EXPLAIN (COSTS false) SELECT * FROM s1.t1 t_1, s1.t2 t_2 WHERE t_1.c1 = t_2.c1;
  42 LOG:  pg_hint_plan:
  43 used hint:
  44 not used hint:
  45 HashJoin(t1 t2)
  46 duplication hint:
  47 error hint:
  48
  49                QUERY PLAN
  50 ----------------------------------------
  51  Merge Join
  52    Merge Cond: (t_1.c1 = t_2.c1)
  53    ->  Index Scan using t1_i1 on t1 t_1
  54    ->  Sort
  55          Sort Key: t_2.c1
  56          ->  Seq Scan on t2 t_2
  57 (6 rows)
  58
  59 -- No. J-1-1-3
  60 /*+HashJoin(t_1 t_2)*/
  61 EXPLAIN (COSTS false) SELECT * FROM s1.t1 t_1, s1.t2 t_2 WHERE t_1.c1 = t_2.c1;
  62 LOG:  pg_hint_plan:
  63 used hint:
  64 HashJoin(t_1 t_2)
  65 not used hint:
  66 duplication hint:
  67 error hint:
  68
  69            QUERY PLAN
  70 --------------------------------
  71  Hash Join
  72    Hash Cond: (t_1.c1 = t_2.c1)
  73    ->  Seq Scan on t1 t_1
  74    ->  Hash
  75          ->  Seq Scan on t2 t_2
  76 (5 rows)
  77
  78 ----
  79 ---- No. J-1-2 specified schema name in the hint option
  80 ----
  81 -- No. J-1-2-1
  82 /*+HashJoin(t1 t2)*/
  83 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
  84 LOG:  pg_hint_plan:
  85 used hint:
  86 HashJoin(t1 t2)
  87 not used hint:
  88 duplication hint:
  89 error hint:
  90
  91           QUERY PLAN
  92 ------------------------------
  93  Hash Join
  94    Hash Cond: (t1.c1 = t2.c1)
  95    ->  Seq Scan on t1
  96    ->  Hash
  97          ->  Seq Scan on t2
  98 (5 rows)
  99
 100 -- No. J-1-2-2
 101 /*+HashJoin(s1.t1 s1.t2)*/
 102 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 103 LOG:  pg_hint_plan:
 104 used hint:
 105 not used hint:
 106 HashJoin(s1.t1 s1.t2)
 107 duplication hint:
 108 error hint:
 109
 110              QUERY PLAN
 111 ------------------------------------
 112  Merge Join
 113    Merge Cond: (t1.c1 = t2.c1)
 114    ->  Index Scan using t1_i1 on t1
 115    ->  Sort
 116          Sort Key: t2.c1
 117          ->  Seq Scan on t2
 118 (6 rows)
 119
 120 ----
 121 ---- No. J-1-3 table doesn't exist in the hint option
 122 ----
 123 -- No. J-1-3-1
 124 /*+HashJoin(t1 t2)*/
 125 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 126 LOG:  pg_hint_plan:
 127 used hint:
 128 HashJoin(t1 t2)
 129 not used hint:
 130 duplication hint:
 131 error hint:
 132
 133           QUERY PLAN
 134 ------------------------------
 135  Hash Join
 136    Hash Cond: (t1.c1 = t2.c1)
 137    ->  Seq Scan on t1
 138    ->  Hash
 139          ->  Seq Scan on t2
 140 (5 rows)
 141
 142 -- No. J-1-3-2
 143 /*+HashJoin(t3 t4)*/
 144 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 145 LOG:  pg_hint_plan:
 146 used hint:
 147 not used hint:
 148 HashJoin(t3 t4)
 149 duplication hint:
 150 error hint:
 151
 152              QUERY PLAN
 153 ------------------------------------
 154  Merge Join
 155    Merge Cond: (t1.c1 = t2.c1)
 156    ->  Index Scan using t1_i1 on t1
 157    ->  Sort
 158          Sort Key: t2.c1
 159          ->  Seq Scan on t2
 160 (6 rows)
 161
 162 ----
 163 ---- No. J-1-4 conflict table name
 164 ----
 165 -- No. J-1-4-1
 166 /*+HashJoin(t1 t2)*/
 167 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 168 LOG:  pg_hint_plan:
 169 used hint:
 170 HashJoin(t1 t2)
 171 not used hint:
 172 duplication hint:
 173 error hint:
 174
 175           QUERY PLAN
 176 ------------------------------
 177  Hash Join
 178    Hash Cond: (t1.c1 = t2.c1)
 179    ->  Seq Scan on t1
 180    ->  Hash
 181          ->  Seq Scan on t2
 182 (5 rows)
 183
 184 -- No. J-1-4-2
 185 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s2.t1 WHERE s1.t1.c1 = s2.t1.c1;
 186              QUERY PLAN
 187 -------------------------------------
 188  Merge Join
 189    Merge Cond: (s1.t1.c1 = s2.t1.c1)
 190    ->  Index Scan using t1_i1 on t1
 191    ->  Sort
 192          Sort Key: s2.t1.c1
 193          ->  Seq Scan on t1
 194 (6 rows)
 195
 196 /*+HashJoin(t1 t1)*/
 197 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s2.t1 WHERE s1.t1.c1 = s2.t1.c1;
 198 INFO:  hint syntax error at or near "HashJoin(t1 t1)"
 199 DETAIL:  Relation name "t1" is ambiguous.
 200 LOG:  pg_hint_plan:
 201 used hint:
 202 not used hint:
 203 duplication hint:
 204 error hint:
 205 HashJoin(t1 t1)
 206
 207              QUERY PLAN
 208 -------------------------------------
 209  Merge Join
 210    Merge Cond: (s1.t1.c1 = s2.t1.c1)
 211    ->  Index Scan using t1_i1 on t1
 212    ->  Sort
 213          Sort Key: s2.t1.c1
 214          ->  Seq Scan on t1
 215 (6 rows)
 216
 217 /*+HashJoin(s1.t1 s2.t1)*/
 218 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s2.t1 WHERE s1.t1.c1 = s2.t1.c1;
 219 LOG:  pg_hint_plan:
 220 used hint:
 221 not used hint:
 222 HashJoin(s1.t1 s2.t1)
 223 duplication hint:
 224 error hint:
 225
 226              QUERY PLAN
 227 -------------------------------------
 228  Merge Join
 229    Merge Cond: (s1.t1.c1 = s2.t1.c1)
 230    ->  Index Scan using t1_i1 on t1
 231    ->  Sort
 232          Sort Key: s2.t1.c1
 233          ->  Seq Scan on t1
 234 (6 rows)
 235
 236 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s2.t1 s2t1 WHERE s1.t1.c1 = s2t1.c1;
 237              QUERY PLAN
 238 ------------------------------------
 239  Merge Join
 240    Merge Cond: (t1.c1 = s2t1.c1)
 241    ->  Index Scan using t1_i1 on t1
 242    ->  Sort
 243          Sort Key: s2t1.c1
 244          ->  Seq Scan on t1 s2t1
 245 (6 rows)
 246
 247 /*+HashJoin(t1 s2t1)*/
 248 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s2.t1 s2t1 WHERE s1.t1.c1 = s2t1.c1;
 249 LOG:  pg_hint_plan:
 250 used hint:
 251 HashJoin(s2t1 t1)
 252 not used hint:
 253 duplication hint:
 254 error hint:
 255
 256            QUERY PLAN
 257 ---------------------------------
 258  Hash Join
 259    Hash Cond: (t1.c1 = s2t1.c1)
 260    ->  Seq Scan on t1
 261    ->  Hash
 262          ->  Seq Scan on t1 s2t1
 263 (5 rows)
 264
 265 -- No. J-1-4-3
 266 EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 267                       QUERY PLAN
 268 -------------------------------------------------------
 269  Merge Join
 270    Merge Cond: (s1.t1.c1 = s1.t2.c1)
 271    InitPlan 1 (returns $0)
 272      ->  Aggregate
 273            ->  Merge Join
 274                  Merge Cond: (s1.t1.c1 = s1.t2.c1)
 275                  ->  Index Only Scan using t1_i1 on t1
 276                  ->  Sort
 277                        Sort Key: s1.t2.c1
 278                        ->  Seq Scan on t2
 279    ->  Index Scan using t1_i1 on t1
 280    ->  Sort
 281          Sort Key: s1.t2.c1
 282          ->  Seq Scan on t2
 283 (14 rows)
 284
 285 /*+HashJoin(t1 t2)*/
 286 EXPLAIN (COSTS false) SELECT *, (SELECT max(t1.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 287 LOG:  pg_hint_plan:
 288 used hint:
 289 HashJoin(t1 t2)
 290 not used hint:
 291 duplication hint:
 292 error hint:
 293
 294                     QUERY PLAN
 295 --------------------------------------------------
 296  Hash Join
 297    Hash Cond: (s1.t1.c1 = s1.t2.c1)
 298    InitPlan 1 (returns $0)
 299      ->  Aggregate
 300            ->  Hash Join
 301                  Hash Cond: (s1.t1.c1 = s1.t2.c1)
 302                  ->  Seq Scan on t1
 303                  ->  Hash
 304                        ->  Seq Scan on t2
 305    ->  Seq Scan on t1
 306    ->  Hash
 307          ->  Seq Scan on t2
 308 (12 rows)
 309
 310 /*+NestLoop(st1 st2)HashJoin(t1 t2)*/
 311 EXPLAIN (COSTS false) SELECT *, (SELECT max(st1.c1) FROM s1.t1 st1, s1.t2 st2 WHERE st1.c1 = st2.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 312 LOG:  pg_hint_plan:
 313 used hint:
 314 NestLoop(st1 st2)
 315 HashJoin(t1 t2)
 316 not used hint:
 317 duplication hint:
 318 error hint:
 319
 320                         QUERY PLAN
 321 -----------------------------------------------------------
 322  Hash Join
 323    Hash Cond: (t1.c1 = t2.c1)
 324    InitPlan 1 (returns $1)
 325      ->  Aggregate
 326            ->  Nested Loop
 327                  ->  Seq Scan on t2 st2
 328                  ->  Index Only Scan using t1_i1 on t1 st1
 329                        Index Cond: (c1 = st2.c1)
 330    ->  Seq Scan on t1
 331    ->  Hash
 332          ->  Seq Scan on t2
 333 (11 rows)
 334
 335 ----
 336 ---- No. J-1-5 conflict table name
 337 ----
 338 -- No. J-1-5-1
 339 /*+HashJoin(t1 t2)*/
 340 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 341 LOG:  pg_hint_plan:
 342 used hint:
 343 HashJoin(t1 t2)
 344 not used hint:
 345 duplication hint:
 346 error hint:
 347
 348           QUERY PLAN
 349 ------------------------------
 350  Hash Join
 351    Hash Cond: (t1.c1 = t2.c1)
 352    ->  Seq Scan on t1
 353    ->  Hash
 354          ->  Seq Scan on t2
 355 (5 rows)
 356
 357 -- No. J-1-5-2
 358 /*+HashJoin(t1 t1)*/
 359 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 360 INFO:  hint syntax error at or near "HashJoin(t1 t1)"
 361 DETAIL:  Relation name "t1" is duplicated.
 362 LOG:  pg_hint_plan:
 363 used hint:
 364 not used hint:
 365 duplication hint:
 366 error hint:
 367 HashJoin(t1 t1)
 368
 369              QUERY PLAN
 370 ------------------------------------
 371  Merge Join
 372    Merge Cond: (t1.c1 = t2.c1)
 373    ->  Index Scan using t1_i1 on t1
 374    ->  Sort
 375          Sort Key: t2.c1
 376          ->  Seq Scan on t2
 377 (6 rows)
 378
 379 -- No. J-1-5-3
 380 /*+HashJoin(t1 t1)HashJoin(t2 t2)*/
 381 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 382 INFO:  hint syntax error at or near "HashJoin(t1 t1)HashJoin(t2 t2)"
 383 DETAIL:  Relation name "t1" is duplicated.
 384 INFO:  hint syntax error at or near "HashJoin(t2 t2)"
 385 DETAIL:  Relation name "t2" is duplicated.
 386 LOG:  pg_hint_plan:
 387 used hint:
 388 not used hint:
 389 duplication hint:
 390 error hint:
 391 HashJoin(t1 t1)
 392 HashJoin(t2 t2)
 393
 394              QUERY PLAN
 395 ------------------------------------
 396  Merge Join
 397    Merge Cond: (t1.c1 = t2.c1)
 398    ->  Index Scan using t1_i1 on t1
 399    ->  Sort
 400          Sort Key: t2.c1
 401          ->  Seq Scan on t2
 402 (6 rows)
 403
 404 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
 405                 QUERY PLAN
 406 ------------------------------------------
 407  Merge Join
 408    Merge Cond: (t1.c1 = t2.c1)
 409    ->  Merge Join
 410          Merge Cond: (t1.c1 = t3.c1)
 411          ->  Index Scan using t1_i1 on t1
 412          ->  Index Scan using t3_i1 on t3
 413    ->  Sort
 414          Sort Key: t2.c1
 415          ->  Seq Scan on t2
 416 (9 rows)
 417
 418 /*+HashJoin(t1 t2 t1 t2)*/
 419 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
 420 INFO:  hint syntax error at or near "HashJoin(t1 t2 t1 t2)"
 421 DETAIL:  Relation name "t1" is duplicated.
 422 LOG:  pg_hint_plan:
 423 used hint:
 424 not used hint:
 425 duplication hint:
 426 error hint:
 427 HashJoin(t1 t1 t2 t2)
 428
 429                    QUERY PLAN
 430 ------------------------------------------------
 431  Merge Join
 432    Merge Cond: (t1.c1 = t2.c1)
 433    ->  Merge Join
 434          Merge Cond: (t1.c1 = t4.c1)
 435          ->  Merge Join
 436                Merge Cond: (t1.c1 = t3.c1)
 437                ->  Index Scan using t1_i1 on t1
 438                ->  Index Scan using t3_i1 on t3
 439          ->  Index Scan using t4_i1 on t4
 440    ->  Sort
 441          Sort Key: t2.c1
 442          ->  Seq Scan on t2
 443 (12 rows)
 444
 445 ----
 446 ---- No. J-1-6 object type for the hint
 447 ----
 448 -- No. J-1-6-1
 449 /*+HashJoin(t1 t2)*/
 450 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
 451 LOG:  pg_hint_plan:
 452 used hint:
 453 HashJoin(t1 t2)
 454 not used hint:
 455 duplication hint:
 456 error hint:
 457
 458           QUERY PLAN
 459 ------------------------------
 460  Hash Join
 461    Hash Cond: (t1.c1 = t2.c1)
 462    ->  Seq Scan on t1
 463    ->  Hash
 464          ->  Seq Scan on t2
 465 (5 rows)
 466
 467 -- No. J-1-6-2
 468 EXPLAIN (COSTS false) SELECT * FROM s1.p1 t1, s1.p1 t2 WHERE t1.c1 = t2.c1;
 469               QUERY PLAN
 470 ---------------------------------------
 471  Hash Join
 472    Hash Cond: (t1.c1 = t2.c1)
 473    ->  Append
 474          ->  Seq Scan on p1 t1
 475          ->  Seq Scan on p1c1 t1
 476          ->  Seq Scan on p1c2 t1
 477          ->  Seq Scan on p1c3 t1
 478    ->  Hash
 479          ->  Append
 480                ->  Seq Scan on p1 t2
 481                ->  Seq Scan on p1c1 t2
 482                ->  Seq Scan on p1c2 t2
 483                ->  Seq Scan on p1c3 t2
 484 (13 rows)
 485
 486 /*+NestLoop(t1 t2)*/
 487 EXPLAIN (COSTS false) SELECT * FROM s1.p1 t1, s1.p1 t2 WHERE t1.c1 = t2.c1;
 488 LOG:  pg_hint_plan:
 489 used hint:
 490 NestLoop(t1 t2)
 491 not used hint:
 492 duplication hint:
 493 error hint:
 494
 495                    QUERY PLAN
 496 ------------------------------------------------
 497  Nested Loop
 498    ->  Append
 499          ->  Seq Scan on p1 t1
 500          ->  Seq Scan on p1c1 t1
 501          ->  Seq Scan on p1c2 t1
 502          ->  Seq Scan on p1c3 t1
 503    ->  Append
 504          ->  Seq Scan on p1 t2
 505                Filter: (t1.c1 = c1)
 506          ->  Index Scan using p1c1_i on p1c1 t2
 507                Index Cond: (c1 = t1.c1)
 508          ->  Index Scan using p1c2_i on p1c2 t2
 509                Index Cond: (c1 = t1.c1)
 510          ->  Index Scan using p1c3_i on p1c3 t2
 511                Index Cond: (c1 = t1.c1)
 512 (15 rows)
 513
 514 -- No. J-1-6-3
 515 EXPLAIN (COSTS false) SELECT * FROM s1.ul1 t1, s1.ul1 t2 WHERE t1.c1 = t2.c1;
 516            QUERY PLAN
 517 --------------------------------
 518  Hash Join
 519    Hash Cond: (t1.c1 = t2.c1)
 520    ->  Seq Scan on ul1 t1
 521    ->  Hash
 522          ->  Seq Scan on ul1 t2
 523 (5 rows)
 524
 525 /*+NestLoop(t1 t2)*/
 526 EXPLAIN (COSTS false) SELECT * FROM s1.ul1 t1, s1.ul1 t2 WHERE t1.c1 = t2.c1;
 527 LOG:  pg_hint_plan:
 528 used hint:
 529 NestLoop(t1 t2)
 530 not used hint:
 531 duplication hint:
 532 error hint:
 533
 534                 QUERY PLAN
 535 -------------------------------------------
 536  Nested Loop
 537    ->  Seq Scan on ul1 t1
 538    ->  Index Scan using ul1_pkey on ul1 t2
 539          Index Cond: (c1 = t1.c1)
 540 (4 rows)
 541
 542 -- No. J-1-6-4
 543 CREATE TEMP TABLE tm1 (LIKE s1.t1 INCLUDING ALL);
 544 NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "tm1_pkey" for table "tm1"
 545 EXPLAIN (COSTS false) SELECT * FROM tm1 t1, tm1 t2 WHERE t1.c1 = t2.c1;
 546            QUERY PLAN
 547 --------------------------------
 548  Hash Join
 549    Hash Cond: (t1.c1 = t2.c1)
 550    ->  Seq Scan on tm1 t1
 551    ->  Hash
 552          ->  Seq Scan on tm1 t2
 553 (5 rows)
 554
 555 /*+NestLoop(t1 t2)*/
 556 EXPLAIN (COSTS false) SELECT * FROM tm1 t1, tm1 t2 WHERE t1.c1 = t2.c1;
 557 LOG:  pg_hint_plan:
 558 used hint:
 559 NestLoop(t1 t2)
 560 not used hint:
 561 duplication hint:
 562 error hint:
 563
 564                 QUERY PLAN
 565 -------------------------------------------
 566  Nested Loop
 567    ->  Seq Scan on tm1 t1
 568    ->  Index Scan using tm1_pkey on tm1 t2
 569          Index Cond: (c1 = t1.c1)
 570 (4 rows)
 571
 572 -- No. J-1-6-5
 573 EXPLAIN (COSTS false) SELECT * FROM pg_catalog.pg_class t1, pg_catalog.pg_class t2 WHERE t1.oid = t2.oid;
 574              QUERY PLAN
 575 -------------------------------------
 576  Hash Join
 577    Hash Cond: (t1.oid = t2.oid)
 578    ->  Seq Scan on pg_class t1
 579    ->  Hash
 580          ->  Seq Scan on pg_class t2
 581 (5 rows)
 582
 583 /*+NestLoop(t1 t2)*/
 584 EXPLAIN (COSTS false) SELECT * FROM pg_catalog.pg_class t1, pg_catalog.pg_class t2 WHERE t1.oid = t2.oid;
 585 LOG:  pg_hint_plan:
 586 used hint:
 587 NestLoop(t1 t2)
 588 not used hint:
 589 duplication hint:
 590 error hint:
 591
 592                         QUERY PLAN
 593 ----------------------------------------------------------
 594  Nested Loop
 595    ->  Seq Scan on pg_class t1
 596    ->  Index Scan using pg_class_oid_index on pg_class t2
 597          Index Cond: (oid = t1.oid)
 598 (4 rows)
 599
 600 -- No. J-1-6-6
 601 -- refer ut-fdw.sql
 602 -- No. J-1-6-7
 603 EXPLAIN (COSTS false) SELECT * FROM s1.f1() t1, s1.f1() t2 WHERE t1.c1 = t2.c1;
 604            QUERY PLAN
 605 --------------------------------
 606  Nested Loop
 607    Join Filter: (t1.c1 = t2.c1)
 608    ->  Function Scan on f1 t1
 609    ->  Function Scan on f1 t2
 610 (4 rows)
 611
 612 /*+HashJoin(t1 t2)*/
 613 EXPLAIN (COSTS false) SELECT * FROM s1.f1() t1, s1.f1() t2 WHERE t1.c1 = t2.c1;
 614 LOG:  pg_hint_plan:
 615 used hint:
 616 HashJoin(t1 t2)
 617 not used hint:
 618 duplication hint:
 619 error hint:
 620
 621              QUERY PLAN
 622 ------------------------------------
 623  Hash Join
 624    Hash Cond: (t1.c1 = t2.c1)
 625    ->  Function Scan on f1 t1
 626    ->  Hash
 627          ->  Function Scan on f1 t2
 628 (5 rows)
 629
 630 -- No. J-1-6-8
 631 EXPLAIN (COSTS false) SELECT * FROM (VALUES(1,1,1,'1'), (2,2,2,'2'), (3,3,3,'3')) AS t1 (c1, c2, c3, c4),  s1.t2 WHERE t1.c1 = t2.c1;
 632                 QUERY PLAN
 633 -------------------------------------------
 634  Hash Join
 635    Hash Cond: (t2.c1 = "*VALUES*".column1)
 636    ->  Seq Scan on t2
 637    ->  Hash
 638          ->  Values Scan on "*VALUES*"
 639 (5 rows)
 640
 641 /*+NestLoop(t1 t2)*/
 642 EXPLAIN (COSTS false) SELECT * FROM (VALUES(1,1,1,'1'), (2,2,2,'2'), (3,3,3,'3')) AS t1 (c1, c2, c3, c4),  s1.t2 WHERE t1.c1 = t2.c1;
 643 LOG:  pg_hint_plan:
 644 used hint:
 645 not used hint:
 646 NestLoop(t1 t2)
 647 duplication hint:
 648 error hint:
 649
 650                 QUERY PLAN
 651 -------------------------------------------
 652  Hash Join
 653    Hash Cond: (t2.c1 = "*VALUES*".column1)
 654    ->  Seq Scan on t2
 655    ->  Hash
 656          ->  Values Scan on "*VALUES*"
 657 (5 rows)
 658
 659 /*+NestLoop(*VALUES* t2)*/
 660 EXPLAIN (COSTS false) SELECT * FROM (VALUES(1,1,1,'1'), (2,2,2,'2'), (3,3,3,'3')) AS t1 (c1, c2, c3, c4),  s1.t2 WHERE t1.c1 = t2.c1;
 661 LOG:  pg_hint_plan:
 662 used hint:
 663 NestLoop(*VALUES* t2)
 664 not used hint:
 665 duplication hint:
 666 error hint:
 667
 668                  QUERY PLAN
 669 ---------------------------------------------
 670  Nested Loop
 671    Join Filter: ("*VALUES*".column1 = t2.c1)
 672    ->  Seq Scan on t2
 673    ->  Materialize
 674          ->  Values Scan on "*VALUES*"
 675 (5 rows)
 676
 677 -- No. J-1-6-9
 678 EXPLAIN (COSTS false) WITH c1(c1) AS (SELECT max(t1.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1) SELECT * FROM s1.t1, c1 WHERE t1.c1 = c1.c1;
 679                       QUERY PLAN
 680 -------------------------------------------------------
 681  Nested Loop
 682    CTE c1
 683      ->  Aggregate
 684            ->  Merge Join
 685                  Merge Cond: (s1.t1.c1 = t2.c1)
 686                  ->  Index Only Scan using t1_i1 on t1
 687                  ->  Sort
 688                        Sort Key: t2.c1
 689                        ->  Seq Scan on t2
 690    ->  CTE Scan on c1
 691    ->  Index Scan using t1_i1 on t1
 692          Index Cond: (c1 = c1.c1)
 693 (12 rows)
 694
 695 /*+NestLoop(t1 t2)HashJoin(t1 c1)*/
 696 EXPLAIN (COSTS false) WITH c1(c1) AS (SELECT max(t1.c1) FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1) SELECT * FROM s1.t1, c1 WHERE t1.c1 = c1.c1;
 697 LOG:  pg_hint_plan:
 698 used hint:
 699 HashJoin(c1 t1)
 700 NestLoop(t1 t2)
 701 not used hint:
 702 duplication hint:
 703 error hint:
 704
 705                       QUERY PLAN
 706 -------------------------------------------------------
 707  Hash Join
 708    Hash Cond: (s1.t1.c1 = c1.c1)
 709    CTE c1
 710      ->  Aggregate
 711            ->  Nested Loop
 712                  ->  Seq Scan on t2
 713                  ->  Index Only Scan using t1_i1 on t1
 714                        Index Cond: (c1 = t2.c1)
 715    ->  Seq Scan on t1
 716    ->  Hash
 717          ->  CTE Scan on c1
 718 (11 rows)
 719
 720 -- No. J-1-6-10
 721 EXPLAIN (COSTS false) SELECT * FROM s1.v1 t1, s1.v1 t2 WHERE t1.c1 = t2.c1;
 722             QUERY PLAN
 723 ----------------------------------
 724  Hash Join
 725    Hash Cond: (v1t1.c1 = v1t1.c1)
 726    ->  Seq Scan on t1 v1t1
 727    ->  Hash
 728          ->  Seq Scan on t1 v1t1
 729 (5 rows)
 730
 731 /*+NestLoop(t1 t2)*/
 732 EXPLAIN (COSTS false) SELECT * FROM s1.v1 t1, s1.v1 t2 WHERE t1.c1 = t2.c1;
 733 LOG:  pg_hint_plan:
 734 used hint:
 735 not used hint:
 736 NestLoop(t1 t2)
 737 duplication hint:
 738 error hint:
 739
 740             QUERY PLAN
 741 ----------------------------------
 742  Hash Join
 743    Hash Cond: (v1t1.c1 = v1t1.c1)
 744    ->  Seq Scan on t1 v1t1
 745    ->  Hash
 746          ->  Seq Scan on t1 v1t1
 747 (5 rows)
 748
 749 /*+NestLoop(v1t1 v1t1_)*/
 750 EXPLAIN (COSTS false) SELECT * FROM s1.v1 t1, s1.v1_ t2 WHERE t1.c1 = t2.c1;
 751 LOG:  pg_hint_plan:
 752 used hint:
 753 NestLoop(v1t1 v1t1_)
 754 not used hint:
 755 duplication hint:
 756 error hint:
 757
 758                 QUERY PLAN
 759 ------------------------------------------
 760  Nested Loop
 761    ->  Seq Scan on t1 v1t1
 762    ->  Index Scan using t1_i1 on t1 v1t1_
 763          Index Cond: (c1 = v1t1.c1)
 764 (4 rows)
 765
 766 -- No. J-1-6-11
 767 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.c1 = (SELECT max(st1.c1) FROM s1.t1 st1, s1.t2 st2 WHERE st1.c1 = st2.c1);
 768                         QUERY PLAN
 769 -----------------------------------------------------------
 770  Nested Loop
 771    InitPlan 1 (returns $0)
 772      ->  Aggregate
 773            ->  Merge Join
 774                  Merge Cond: (st1.c1 = st2.c1)
 775                  ->  Index Only Scan using t1_i1 on t1 st1
 776                  ->  Sort
 777                        Sort Key: st2.c1
 778                        ->  Seq Scan on t2 st2
 779    ->  Index Scan using t1_i1 on t1
 780          Index Cond: (c1 = $0)
 781    ->  Seq Scan on t2
 782          Filter: (c1 = $0)
 783 (13 rows)
 784
 785 /*+MergeJoin(t1 t2)NestLoop(st1 st2)*/
 786 EXPLAIN (COSTS true) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.c1 = (SELECT max(st1.c1) FROM s1.t1 st1, s1.t2 st2 WHERE st1.c1 = st2.c1);
 787 LOG:  pg_hint_plan:
 788 used hint:
 789 NestLoop(st1 st2)
 790 MergeJoin(t1 t2)
 791 not used hint:
 792 duplication hint:
 793 error hint:
 794
 795                                          QUERY PLAN
 796 ---------------------------------------------------------------------------------------------
 797  Nested Loop  (cost=10000000074.46..10000000084.99 rows=1 width=29)
 798    InitPlan 1 (returns $1)
 799      ->  Aggregate  (cost=74.45..74.46 rows=1 width=4)
 800            ->  Nested Loop  (cost=0.00..74.20 rows=100 width=4)
 801                  ->  Seq Scan on t2 st2  (cost=0.00..2.00 rows=100 width=4)
 802                  ->  Index Only Scan using t1_i1 on t1 st1  (cost=0.00..0.71 rows=1 width=4)
 803                        Index Cond: (c1 = st2.c1)
 804    ->  Index Scan using t1_i1 on t1  (cost=0.00..8.27 rows=1 width=15)
 805          Index Cond: (c1 = $1)
 806    ->  Seq Scan on t2  (cost=0.00..2.25 rows=1 width=14)
 807          Filter: (c1 = $1)
 808 (11 rows)
 809
 810 EXPLAIN (COSTS false) SELECT * FROM s1.t1, (SELECT t2.c1 FROM s1.t2) st2 WHERE t1.c1 = st2.c1;
 811              QUERY PLAN
 812 ------------------------------------
 813  Merge Join
 814    Merge Cond: (t1.c1 = t2.c1)
 815    ->  Index Scan using t1_i1 on t1
 816    ->  Sort
 817          Sort Key: t2.c1
 818          ->  Seq Scan on t2
 819 (6 rows)
 820
 821 /*+HashJoin(t1 st2)*/
 822 EXPLAIN (COSTS false) SELECT * FROM s1.t1, (SELECT t2.c1 FROM s1.t2) st2 WHERE t1.c1 = st2.c1;
 823 LOG:  pg_hint_plan:
 824 used hint:
 825 not used hint:
 826 HashJoin(st2 t1)
 827 duplication hint:
 828 error hint:
 829
 830              QUERY PLAN
 831 ------------------------------------
 832  Merge Join
 833    Merge Cond: (t1.c1 = t2.c1)
 834    ->  Index Scan using t1_i1 on t1
 835    ->  Sort
 836          Sort Key: t2.c1
 837          ->  Seq Scan on t2
 838 (6 rows)
 839
 840 /*+HashJoin(t1 t2)*/
 841 EXPLAIN (COSTS false) SELECT * FROM s1.t1, (SELECT t2.c1 FROM s1.t2) st2 WHERE t1.c1 = st2.c1;
 842 LOG:  pg_hint_plan:
 843 used hint:
 844 HashJoin(t1 t2)
 845 not used hint:
 846 duplication hint:
 847 error hint:
 848
 849           QUERY PLAN
 850 ------------------------------
 851  Hash Join
 852    Hash Cond: (t1.c1 = t2.c1)
 853    ->  Seq Scan on t1
 854    ->  Hash
 855          ->  Seq Scan on t2
 856 (5 rows)
 857
 858 ----
 859 ---- No. J-2-1 some complexity query blocks
 860 ----
 861 -- No. J-2-1-1
 862 EXPLAIN (COSTS false)
 863 SELECT max(bmt1.c1), (
 864 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
 865 ), (
 866 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
 867 )
 868                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 869 ;
 870                             QUERY PLAN
 871 -------------------------------------------------------------------
 872  Aggregate
 873    InitPlan 1 (returns $0)
 874      ->  Aggregate
 875            ->  Nested Loop
 876                  Join Filter: (b1t1.c1 = b1t4.c1)
 877                  ->  Nested Loop
 878                        Join Filter: (b1t1.c1 = b1t3.c1)
 879                        ->  Nested Loop
 880                              Join Filter: (b1t1.c1 = b1t2.c1)
 881                              ->  Tid Scan on t1 b1t1
 882                                    TID Cond: (ctid = '(1,1)'::tid)
 883                              ->  Seq Scan on t2 b1t2
 884                                    Filter: (ctid = '(1,1)'::tid)
 885                        ->  Tid Scan on t3 b1t3
 886                              TID Cond: (ctid = '(1,1)'::tid)
 887                  ->  Tid Scan on t4 b1t4
 888                        TID Cond: (ctid = '(1,1)'::tid)
 889    InitPlan 2 (returns $1)
 890      ->  Aggregate
 891            ->  Nested Loop
 892                  Join Filter: (b2t1.c1 = b2t4.c1)
 893                  ->  Nested Loop
 894                        Join Filter: (b2t1.c1 = b2t3.c1)
 895                        ->  Nested Loop
 896                              Join Filter: (b2t1.c1 = b2t2.c1)
 897                              ->  Tid Scan on t1 b2t1
 898                                    TID Cond: (ctid = '(1,1)'::tid)
 899                              ->  Seq Scan on t2 b2t2
 900                                    Filter: (ctid = '(1,1)'::tid)
 901                        ->  Tid Scan on t3 b2t3
 902                              TID Cond: (ctid = '(1,1)'::tid)
 903                  ->  Tid Scan on t4 b2t4
 904                        TID Cond: (ctid = '(1,1)'::tid)
 905    ->  Nested Loop
 906          Join Filter: (bmt1.c1 = bmt4.c1)
 907          ->  Nested Loop
 908                Join Filter: (bmt1.c1 = bmt3.c1)
 909                ->  Nested Loop
 910                      Join Filter: (bmt1.c1 = bmt2.c1)
 911                      ->  Tid Scan on t1 bmt1
 912                            TID Cond: (ctid = '(1,1)'::tid)
 913                      ->  Seq Scan on t2 bmt2
 914                            Filter: (ctid = '(1,1)'::tid)
 915                ->  Tid Scan on t3 bmt3
 916                      TID Cond: (ctid = '(1,1)'::tid)
 917          ->  Tid Scan on t4 bmt4
 918                TID Cond: (ctid = '(1,1)'::tid)
 919 (47 rows)
 920
 921 /*+
 922 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
 923 MergeJoin(bmt1 bmt2)HashJoin(bmt1 bmt2 bmt3)NestLoop(bmt1 bmt2 bmt3 bmt4)
 924 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
 925 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
 926 */
 927 EXPLAIN (COSTS false)
 928 SELECT max(bmt1.c1), (
 929 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
 930 ), (
 931 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
 932 )
 933                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
 934 ;
 935 LOG:  pg_hint_plan:
 936 used hint:
 937 MergeJoin(b1t2 b1t3)
 938 MergeJoin(b2t3 b2t4)
 939 MergeJoin(bmt1 bmt2)
 940 HashJoin(b1t2 b1t3 b1t4)
 941 HashJoin(b2t1 b2t3 b2t4)
 942 HashJoin(bmt1 bmt2 bmt3)
 943 NestLoop(b1t1 b1t2 b1t3 b1t4)
 944 NestLoop(b2t1 b2t2 b2t3 b2t4)
 945 NestLoop(bmt1 bmt2 bmt3 bmt4)
 946 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
 947 not used hint:
 948 duplication hint:
 949 error hint:
 950
 951                                   QUERY PLAN
 952 -------------------------------------------------------------------------------
 953  Aggregate
 954    InitPlan 1 (returns $0)
 955      ->  Aggregate
 956            ->  Nested Loop
 957                  Join Filter: (b1t2.c1 = b1t1.c1)
 958                  ->  Hash Join
 959                        Hash Cond: (b1t4.c1 = b1t2.c1)
 960                        ->  Tid Scan on t4 b1t4
 961                              TID Cond: (ctid = '(1,1)'::tid)
 962                        ->  Hash
 963                              ->  Merge Join
 964                                    Merge Cond: (b1t2.c1 = b1t3.c1)
 965                                    ->  Sort
 966                                          Sort Key: b1t2.c1
 967                                          ->  Seq Scan on t2 b1t2
 968                                                Filter: (ctid = '(1,1)'::tid)
 969                                    ->  Sort
 970                                          Sort Key: b1t3.c1
 971                                          ->  Tid Scan on t3 b1t3
 972                                                TID Cond: (ctid = '(1,1)'::tid)
 973                  ->  Tid Scan on t1 b1t1
 974                        TID Cond: (ctid = '(1,1)'::tid)
 975    InitPlan 2 (returns $1)
 976      ->  Aggregate
 977            ->  Nested Loop
 978                  Join Filter: (b2t1.c1 = b2t2.c1)
 979                  ->  Hash Join
 980                        Hash Cond: (b2t1.c1 = b2t3.c1)
 981                        ->  Tid Scan on t1 b2t1
 982                              TID Cond: (ctid = '(1,1)'::tid)
 983                        ->  Hash
 984                              ->  Merge Join
 985                                    Merge Cond: (b2t3.c1 = b2t4.c1)
 986                                    ->  Sort
 987                                          Sort Key: b2t3.c1
 988                                          ->  Tid Scan on t3 b2t3
 989                                                TID Cond: (ctid = '(1,1)'::tid)
 990                                    ->  Sort
 991                                          Sort Key: b2t4.c1
 992                                          ->  Tid Scan on t4 b2t4
 993                                                TID Cond: (ctid = '(1,1)'::tid)
 994                  ->  Seq Scan on t2 b2t2
 995                        Filter: (ctid = '(1,1)'::tid)
 996    ->  Nested Loop
 997          Join Filter: (bmt1.c1 = bmt4.c1)
 998          ->  Hash Join
 999                Hash Cond: (bmt3.c1 = bmt1.c1)
1000                ->  Tid Scan on t3 bmt3
1001                      TID Cond: (ctid = '(1,1)'::tid)
1002                ->  Hash
1003                      ->  Merge Join
1004                            Merge Cond: (bmt1.c1 = bmt2.c1)
1005                            ->  Sort
1006                                  Sort Key: bmt1.c1
1007                                  ->  Tid Scan on t1 bmt1
1008                                        TID Cond: (ctid = '(1,1)'::tid)
1009                            ->  Sort
1010                                  Sort Key: bmt2.c1
1011                                  ->  Seq Scan on t2 bmt2
1012                                        Filter: (ctid = '(1,1)'::tid)
1013          ->  Tid Scan on t4 bmt4
1014                TID Cond: (ctid = '(1,1)'::tid)
1015 (62 rows)
1016
1017 -- No. J-2-1-2
1018 EXPLAIN (COSTS false)
1019 SELECT max(bmt1.c1), (
1020 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1021 ), (
1022 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1023 ), (
1024 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1025 )
1026                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1027 ;
1028                             QUERY PLAN
1029 -------------------------------------------------------------------
1030  Aggregate
1031    InitPlan 1 (returns $0)
1032      ->  Aggregate
1033            ->  Nested Loop
1034                  Join Filter: (b1t1.c1 = b1t4.c1)
1035                  ->  Nested Loop
1036                        Join Filter: (b1t1.c1 = b1t3.c1)
1037                        ->  Nested Loop
1038                              Join Filter: (b1t1.c1 = b1t2.c1)
1039                              ->  Tid Scan on t1 b1t1
1040                                    TID Cond: (ctid = '(1,1)'::tid)
1041                              ->  Seq Scan on t2 b1t2
1042                                    Filter: (ctid = '(1,1)'::tid)
1043                        ->  Tid Scan on t3 b1t3
1044                              TID Cond: (ctid = '(1,1)'::tid)
1045                  ->  Tid Scan on t4 b1t4
1046                        TID Cond: (ctid = '(1,1)'::tid)
1047    InitPlan 2 (returns $1)
1048      ->  Aggregate
1049            ->  Nested Loop
1050                  Join Filter: (b2t1.c1 = b2t4.c1)
1051                  ->  Nested Loop
1052                        Join Filter: (b2t1.c1 = b2t3.c1)
1053                        ->  Nested Loop
1054                              Join Filter: (b2t1.c1 = b2t2.c1)
1055                              ->  Tid Scan on t1 b2t1
1056                                    TID Cond: (ctid = '(1,1)'::tid)
1057                              ->  Seq Scan on t2 b2t2
1058                                    Filter: (ctid = '(1,1)'::tid)
1059                        ->  Tid Scan on t3 b2t3
1060                              TID Cond: (ctid = '(1,1)'::tid)
1061                  ->  Tid Scan on t4 b2t4
1062                        TID Cond: (ctid = '(1,1)'::tid)
1063    InitPlan 3 (returns $2)
1064      ->  Aggregate
1065            ->  Nested Loop
1066                  Join Filter: (b3t1.c1 = b3t4.c1)
1067                  ->  Nested Loop
1068                        Join Filter: (b3t1.c1 = b3t3.c1)
1069                        ->  Nested Loop
1070                              Join Filter: (b3t1.c1 = b3t2.c1)
1071                              ->  Tid Scan on t1 b3t1
1072                                    TID Cond: (ctid = '(1,1)'::tid)
1073                              ->  Seq Scan on t2 b3t2
1074                                    Filter: (ctid = '(1,1)'::tid)
1075                        ->  Tid Scan on t3 b3t3
1076                              TID Cond: (ctid = '(1,1)'::tid)
1077                  ->  Tid Scan on t4 b3t4
1078                        TID Cond: (ctid = '(1,1)'::tid)
1079    ->  Nested Loop
1080          Join Filter: (bmt1.c1 = bmt4.c1)
1081          ->  Nested Loop
1082                Join Filter: (bmt1.c1 = bmt3.c1)
1083                ->  Nested Loop
1084                      Join Filter: (bmt1.c1 = bmt2.c1)
1085                      ->  Tid Scan on t1 bmt1
1086                            TID Cond: (ctid = '(1,1)'::tid)
1087                      ->  Seq Scan on t2 bmt2
1088                            Filter: (ctid = '(1,1)'::tid)
1089                ->  Tid Scan on t3 bmt3
1090                      TID Cond: (ctid = '(1,1)'::tid)
1091          ->  Tid Scan on t4 bmt4
1092                TID Cond: (ctid = '(1,1)'::tid)
1093 (63 rows)
1094
1095 /*+
1096 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
1097 MergeJoin(bmt1 bmt2)HashJoin(bmt1 bmt2 bmt3)NestLoop(bmt1 bmt2 bmt3 bmt4)
1098 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
1099 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
1100 MergeJoin(b3t4 b3t1)HashJoin(b3t4 b3t1 b3t2)NestLoop(b3t1 b3t2 b3t3 b3t4)
1101 */
1102 EXPLAIN (COSTS false)
1103 SELECT max(bmt1.c1), (
1104 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1105 ), (
1106 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1107 ), (
1108 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1109 )
1110                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1111 ;
1112 LOG:  pg_hint_plan:
1113 used hint:
1114 MergeJoin(b1t2 b1t3)
1115 MergeJoin(b2t3 b2t4)
1116 MergeJoin(b3t1 b3t4)
1117 MergeJoin(bmt1 bmt2)
1118 HashJoin(b1t2 b1t3 b1t4)
1119 HashJoin(b2t1 b2t3 b2t4)
1120 HashJoin(b3t1 b3t2 b3t4)
1121 HashJoin(bmt1 bmt2 bmt3)
1122 NestLoop(b1t1 b1t2 b1t3 b1t4)
1123 NestLoop(b2t1 b2t2 b2t3 b2t4)
1124 NestLoop(b3t1 b3t2 b3t3 b3t4)
1125 NestLoop(bmt1 bmt2 bmt3 bmt4)
1126 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
1127 not used hint:
1128 duplication hint:
1129 error hint:
1130
1131                                   QUERY PLAN
1132 -------------------------------------------------------------------------------
1133  Aggregate
1134    InitPlan 1 (returns $0)
1135      ->  Aggregate
1136            ->  Nested Loop
1137                  Join Filter: (b1t2.c1 = b1t1.c1)
1138                  ->  Hash Join
1139                        Hash Cond: (b1t4.c1 = b1t2.c1)
1140                        ->  Tid Scan on t4 b1t4
1141                              TID Cond: (ctid = '(1,1)'::tid)
1142                        ->  Hash
1143                              ->  Merge Join
1144                                    Merge Cond: (b1t2.c1 = b1t3.c1)
1145                                    ->  Sort
1146                                          Sort Key: b1t2.c1
1147                                          ->  Seq Scan on t2 b1t2
1148                                                Filter: (ctid = '(1,1)'::tid)
1149                                    ->  Sort
1150                                          Sort Key: b1t3.c1
1151                                          ->  Tid Scan on t3 b1t3
1152                                                TID Cond: (ctid = '(1,1)'::tid)
1153                  ->  Tid Scan on t1 b1t1
1154                        TID Cond: (ctid = '(1,1)'::tid)
1155    InitPlan 2 (returns $1)
1156      ->  Aggregate
1157            ->  Nested Loop
1158                  Join Filter: (b2t1.c1 = b2t2.c1)
1159                  ->  Hash Join
1160                        Hash Cond: (b2t1.c1 = b2t3.c1)
1161                        ->  Tid Scan on t1 b2t1
1162                              TID Cond: (ctid = '(1,1)'::tid)
1163                        ->  Hash
1164                              ->  Merge Join
1165                                    Merge Cond: (b2t3.c1 = b2t4.c1)
1166                                    ->  Sort
1167                                          Sort Key: b2t3.c1
1168                                          ->  Tid Scan on t3 b2t3
1169                                                TID Cond: (ctid = '(1,1)'::tid)
1170                                    ->  Sort
1171                                          Sort Key: b2t4.c1
1172                                          ->  Tid Scan on t4 b2t4
1173                                                TID Cond: (ctid = '(1,1)'::tid)
1174                  ->  Seq Scan on t2 b2t2
1175                        Filter: (ctid = '(1,1)'::tid)
1176    InitPlan 3 (returns $2)
1177      ->  Aggregate
1178            ->  Nested Loop
1179                  Join Filter: (b3t1.c1 = b3t3.c1)
1180                  ->  Hash Join
1181                        Hash Cond: (b3t2.c1 = b3t1.c1)
1182                        ->  Seq Scan on t2 b3t2
1183                              Filter: (ctid = '(1,1)'::tid)
1184                        ->  Hash
1185                              ->  Merge Join
1186                                    Merge Cond: (b3t1.c1 = b3t4.c1)
1187                                    ->  Sort
1188                                          Sort Key: b3t1.c1
1189                                          ->  Tid Scan on t1 b3t1
1190                                                TID Cond: (ctid = '(1,1)'::tid)
1191                                    ->  Sort
1192                                          Sort Key: b3t4.c1
1193                                          ->  Tid Scan on t4 b3t4
1194                                                TID Cond: (ctid = '(1,1)'::tid)
1195                  ->  Tid Scan on t3 b3t3
1196                        TID Cond: (ctid = '(1,1)'::tid)
1197    ->  Nested Loop
1198          Join Filter: (bmt1.c1 = bmt4.c1)
1199          ->  Hash Join
1200                Hash Cond: (bmt3.c1 = bmt1.c1)
1201                ->  Tid Scan on t3 bmt3
1202                      TID Cond: (ctid = '(1,1)'::tid)
1203                ->  Hash
1204                      ->  Merge Join
1205                            Merge Cond: (bmt1.c1 = bmt2.c1)
1206                            ->  Sort
1207                                  Sort Key: bmt1.c1
1208                                  ->  Tid Scan on t1 bmt1
1209                                        TID Cond: (ctid = '(1,1)'::tid)
1210                            ->  Sort
1211                                  Sort Key: bmt2.c1
1212                                  ->  Seq Scan on t2 bmt2
1213                                        Filter: (ctid = '(1,1)'::tid)
1214          ->  Tid Scan on t4 bmt4
1215                TID Cond: (ctid = '(1,1)'::tid)
1216 (83 rows)
1217
1218 -- No. J-2-1-3
1219 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
1220                         QUERY PLAN
1221 -----------------------------------------------------------
1222  Aggregate
1223    ->  Nested Loop
1224          Join Filter: (bmt1.c1 = bmt4.c1)
1225          ->  Nested Loop
1226                Join Filter: (bmt1.c1 = bmt3.c1)
1227                ->  Nested Loop
1228                      Join Filter: (bmt1.c1 = bmt2.c1)
1229                      ->  Tid Scan on t1 bmt1
1230                            TID Cond: (ctid = '(1,1)'::tid)
1231                      ->  Seq Scan on t2 bmt2
1232                            Filter: (ctid = '(1,1)'::tid)
1233                ->  Tid Scan on t3 bmt3
1234                      TID Cond: (ctid = '(1,1)'::tid)
1235          ->  Tid Scan on t4 bmt4
1236                TID Cond: (ctid = '(1,1)'::tid)
1237 (15 rows)
1238
1239 /*+
1240 Leading(bmt4 bmt3 bmt2 bmt1)
1241 MergeJoin(bmt4 bmt3)HashJoin(bmt4 bmt3 bmt2)NestLoop(bmt1 bmt2 bmt3 bmt4)
1242 */
1243 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
1244 LOG:  pg_hint_plan:
1245 used hint:
1246 MergeJoin(bmt3 bmt4)
1247 HashJoin(bmt2 bmt3 bmt4)
1248 NestLoop(bmt1 bmt2 bmt3 bmt4)
1249 Leading(bmt4 bmt3 bmt2 bmt1)
1250 not used hint:
1251 duplication hint:
1252 error hint:
1253
1254                               QUERY PLAN
1255 -----------------------------------------------------------------------
1256  Aggregate
1257    ->  Nested Loop
1258          Join Filter: (bmt2.c1 = bmt1.c1)
1259          ->  Hash Join
1260                Hash Cond: (bmt2.c1 = bmt3.c1)
1261                ->  Seq Scan on t2 bmt2
1262                      Filter: (ctid = '(1,1)'::tid)
1263                ->  Hash
1264                      ->  Merge Join
1265                            Merge Cond: (bmt3.c1 = bmt4.c1)
1266                            ->  Sort
1267                                  Sort Key: bmt3.c1
1268                                  ->  Tid Scan on t3 bmt3
1269                                        TID Cond: (ctid = '(1,1)'::tid)
1270                            ->  Sort
1271                                  Sort Key: bmt4.c1
1272                                  ->  Tid Scan on t4 bmt4
1273                                        TID Cond: (ctid = '(1,1)'::tid)
1274          ->  Tid Scan on t1 bmt1
1275                TID Cond: (ctid = '(1,1)'::tid)
1276 (20 rows)
1277
1278 -- No. J-2-1-4
1279 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, (SELECT ctid, * FROM s1.t2 bmt2) sbmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = sbmt2.c1 AND sbmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
1280                         QUERY PLAN
1281 -----------------------------------------------------------
1282  Aggregate
1283    ->  Nested Loop
1284          Join Filter: (bmt1.c1 = bmt4.c1)
1285          ->  Nested Loop
1286                Join Filter: (bmt1.c1 = bmt3.c1)
1287                ->  Nested Loop
1288                      Join Filter: (bmt1.c1 = bmt2.c1)
1289                      ->  Tid Scan on t1 bmt1
1290                            TID Cond: (ctid = '(1,1)'::tid)
1291                      ->  Seq Scan on t2 bmt2
1292                            Filter: (ctid = '(1,1)'::tid)
1293                ->  Tid Scan on t3 bmt3
1294                      TID Cond: (ctid = '(1,1)'::tid)
1295          ->  Tid Scan on t4 bmt4
1296                TID Cond: (ctid = '(1,1)'::tid)
1297 (15 rows)
1298
1299 /*+
1300 Leading(bmt4 bmt3 bmt2 bmt1)
1301 MergeJoin(bmt4 bmt3)HashJoin(bmt4 bmt3 bmt2)NestLoop(bmt1 bmt2 bmt3 bmt4)
1302 */
1303 EXPLAIN (COSTS false) SELECT max(bmt1.c1) FROM s1.t1 bmt1, (SELECT ctid, * FROM s1.t2 bmt2) sbmt2, (SELECT ctid, * FROM s1.t3 bmt3) sbmt3, (SELECT ctid, * FROM s1.t4 bmt4) sbmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = sbmt2.c1 AND sbmt2.ctid = '(1,1)' AND bmt1.c1 = sbmt3.c1 AND sbmt3.ctid = '(1,1)' AND bmt1.c1 = sbmt4.c1 AND sbmt4.ctid = '(1,1)';
1304 LOG:  pg_hint_plan:
1305 used hint:
1306 MergeJoin(bmt3 bmt4)
1307 HashJoin(bmt2 bmt3 bmt4)
1308 NestLoop(bmt1 bmt2 bmt3 bmt4)
1309 Leading(bmt4 bmt3 bmt2 bmt1)
1310 not used hint:
1311 duplication hint:
1312 error hint:
1313
1314                               QUERY PLAN
1315 -----------------------------------------------------------------------
1316  Aggregate
1317    ->  Nested Loop
1318          Join Filter: (bmt2.c1 = bmt1.c1)
1319          ->  Hash Join
1320                Hash Cond: (bmt2.c1 = bmt3.c1)
1321                ->  Seq Scan on t2 bmt2
1322                      Filter: (ctid = '(1,1)'::tid)
1323                ->  Hash
1324                      ->  Merge Join
1325                            Merge Cond: (bmt3.c1 = bmt4.c1)
1326                            ->  Sort
1327                                  Sort Key: bmt3.c1
1328                                  ->  Tid Scan on t3 bmt3
1329                                        TID Cond: (ctid = '(1,1)'::tid)
1330                            ->  Sort
1331                                  Sort Key: bmt4.c1
1332                                  ->  Tid Scan on t4 bmt4
1333                                        TID Cond: (ctid = '(1,1)'::tid)
1334          ->  Tid Scan on t1 bmt1
1335                TID Cond: (ctid = '(1,1)'::tid)
1336 (20 rows)
1337
1338 -- No. J-2-1-5
1339 EXPLAIN (COSTS false)
1340 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1341   AND bmt1.c1 <> (
1342 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1343 ) AND bmt1.c1 <> (
1344 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1345 )
1346 ;
1347                             QUERY PLAN
1348 -------------------------------------------------------------------
1349  Aggregate
1350    InitPlan 1 (returns $0)
1351      ->  Aggregate
1352            ->  Nested Loop
1353                  Join Filter: (b1t1.c1 = b1t4.c1)
1354                  ->  Nested Loop
1355                        Join Filter: (b1t1.c1 = b1t3.c1)
1356                        ->  Nested Loop
1357                              Join Filter: (b1t1.c1 = b1t2.c1)
1358                              ->  Tid Scan on t1 b1t1
1359                                    TID Cond: (ctid = '(1,1)'::tid)
1360                              ->  Seq Scan on t2 b1t2
1361                                    Filter: (ctid = '(1,1)'::tid)
1362                        ->  Tid Scan on t3 b1t3
1363                              TID Cond: (ctid = '(1,1)'::tid)
1364                  ->  Tid Scan on t4 b1t4
1365                        TID Cond: (ctid = '(1,1)'::tid)
1366    InitPlan 2 (returns $1)
1367      ->  Aggregate
1368            ->  Nested Loop
1369                  Join Filter: (b2t1.c1 = b2t4.c1)
1370                  ->  Nested Loop
1371                        Join Filter: (b2t1.c1 = b2t3.c1)
1372                        ->  Nested Loop
1373                              Join Filter: (b2t1.c1 = b2t2.c1)
1374                              ->  Tid Scan on t1 b2t1
1375                                    TID Cond: (ctid = '(1,1)'::tid)
1376                              ->  Seq Scan on t2 b2t2
1377                                    Filter: (ctid = '(1,1)'::tid)
1378                        ->  Tid Scan on t3 b2t3
1379                              TID Cond: (ctid = '(1,1)'::tid)
1380                  ->  Tid Scan on t4 b2t4
1381                        TID Cond: (ctid = '(1,1)'::tid)
1382    ->  Nested Loop
1383          Join Filter: (bmt1.c1 = bmt4.c1)
1384          ->  Nested Loop
1385                Join Filter: (bmt1.c1 = bmt3.c1)
1386                ->  Nested Loop
1387                      Join Filter: (bmt1.c1 = bmt2.c1)
1388                      ->  Tid Scan on t1 bmt1
1389                            TID Cond: (ctid = '(1,1)'::tid)
1390                            Filter: ((c1 <> $0) AND (c1 <> $1))
1391                      ->  Seq Scan on t2 bmt2
1392                            Filter: (ctid = '(1,1)'::tid)
1393                ->  Tid Scan on t3 bmt3
1394                      TID Cond: (ctid = '(1,1)'::tid)
1395          ->  Tid Scan on t4 bmt4
1396                TID Cond: (ctid = '(1,1)'::tid)
1397 (48 rows)
1398
1399 /*+
1400 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
1401 MergeJoin(bmt1 bmt2)HashJoin(bmt1 bmt2 bmt3)NestLoop(bmt1 bmt2 bmt3 bmt4)
1402 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
1403 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
1404 */
1405 EXPLAIN (COSTS false)
1406 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1407   AND bmt1.c1 <> (
1408 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1409 ) AND bmt1.c1 <> (
1410 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1411 )
1412 ;
1413 LOG:  pg_hint_plan:
1414 used hint:
1415 MergeJoin(b1t2 b1t3)
1416 MergeJoin(b2t3 b2t4)
1417 MergeJoin(bmt1 bmt2)
1418 HashJoin(b1t2 b1t3 b1t4)
1419 HashJoin(b2t1 b2t3 b2t4)
1420 HashJoin(bmt1 bmt2 bmt3)
1421 NestLoop(b1t1 b1t2 b1t3 b1t4)
1422 NestLoop(b2t1 b2t2 b2t3 b2t4)
1423 NestLoop(bmt1 bmt2 bmt3 bmt4)
1424 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
1425 not used hint:
1426 duplication hint:
1427 error hint:
1428
1429                                   QUERY PLAN
1430 -------------------------------------------------------------------------------
1431  Aggregate
1432    InitPlan 1 (returns $0)
1433      ->  Aggregate
1434            ->  Nested Loop
1435                  Join Filter: (b1t2.c1 = b1t1.c1)
1436                  ->  Hash Join
1437                        Hash Cond: (b1t4.c1 = b1t2.c1)
1438                        ->  Tid Scan on t4 b1t4
1439                              TID Cond: (ctid = '(1,1)'::tid)
1440                        ->  Hash
1441                              ->  Merge Join
1442                                    Merge Cond: (b1t2.c1 = b1t3.c1)
1443                                    ->  Sort
1444                                          Sort Key: b1t2.c1
1445                                          ->  Seq Scan on t2 b1t2
1446                                                Filter: (ctid = '(1,1)'::tid)
1447                                    ->  Sort
1448                                          Sort Key: b1t3.c1
1449                                          ->  Tid Scan on t3 b1t3
1450                                                TID Cond: (ctid = '(1,1)'::tid)
1451                  ->  Tid Scan on t1 b1t1
1452                        TID Cond: (ctid = '(1,1)'::tid)
1453    InitPlan 2 (returns $1)
1454      ->  Aggregate
1455            ->  Nested Loop
1456                  Join Filter: (b2t1.c1 = b2t2.c1)
1457                  ->  Hash Join
1458                        Hash Cond: (b2t1.c1 = b2t3.c1)
1459                        ->  Tid Scan on t1 b2t1
1460                              TID Cond: (ctid = '(1,1)'::tid)
1461                        ->  Hash
1462                              ->  Merge Join
1463                                    Merge Cond: (b2t3.c1 = b2t4.c1)
1464                                    ->  Sort
1465                                          Sort Key: b2t3.c1
1466                                          ->  Tid Scan on t3 b2t3
1467                                                TID Cond: (ctid = '(1,1)'::tid)
1468                                    ->  Sort
1469                                          Sort Key: b2t4.c1
1470                                          ->  Tid Scan on t4 b2t4
1471                                                TID Cond: (ctid = '(1,1)'::tid)
1472                  ->  Seq Scan on t2 b2t2
1473                        Filter: (ctid = '(1,1)'::tid)
1474    ->  Nested Loop
1475          Join Filter: (bmt1.c1 = bmt4.c1)
1476          ->  Hash Join
1477                Hash Cond: (bmt3.c1 = bmt1.c1)
1478                ->  Tid Scan on t3 bmt3
1479                      TID Cond: (ctid = '(1,1)'::tid)
1480                ->  Hash
1481                      ->  Merge Join
1482                            Merge Cond: (bmt1.c1 = bmt2.c1)
1483                            ->  Sort
1484                                  Sort Key: bmt1.c1
1485                                  ->  Tid Scan on t1 bmt1
1486                                        TID Cond: (ctid = '(1,1)'::tid)
1487                                        Filter: ((c1 <> $0) AND (c1 <> $1))
1488                            ->  Sort
1489                                  Sort Key: bmt2.c1
1490                                  ->  Seq Scan on t2 bmt2
1491                                        Filter: (ctid = '(1,1)'::tid)
1492          ->  Tid Scan on t4 bmt4
1493                TID Cond: (ctid = '(1,1)'::tid)
1494 (63 rows)
1495
1496 -- No. J-2-1-6
1497 EXPLAIN (COSTS false)
1498 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1499   AND bmt1.c1 <> (
1500 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1501 ) AND bmt1.c1 <> (
1502 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1503 ) AND bmt1.c1 <> (
1504 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1505 )
1506 ;
1507                                   QUERY PLAN
1508 ------------------------------------------------------------------------------
1509  Aggregate
1510    InitPlan 1 (returns $0)
1511      ->  Aggregate
1512            ->  Nested Loop
1513                  Join Filter: (b1t1.c1 = b1t4.c1)
1514                  ->  Nested Loop
1515                        Join Filter: (b1t1.c1 = b1t3.c1)
1516                        ->  Nested Loop
1517                              Join Filter: (b1t1.c1 = b1t2.c1)
1518                              ->  Tid Scan on t1 b1t1
1519                                    TID Cond: (ctid = '(1,1)'::tid)
1520                              ->  Seq Scan on t2 b1t2
1521                                    Filter: (ctid = '(1,1)'::tid)
1522                        ->  Tid Scan on t3 b1t3
1523                              TID Cond: (ctid = '(1,1)'::tid)
1524                  ->  Tid Scan on t4 b1t4
1525                        TID Cond: (ctid = '(1,1)'::tid)
1526    InitPlan 2 (returns $1)
1527      ->  Aggregate
1528            ->  Nested Loop
1529                  Join Filter: (b2t1.c1 = b2t4.c1)
1530                  ->  Nested Loop
1531                        Join Filter: (b2t1.c1 = b2t3.c1)
1532                        ->  Nested Loop
1533                              Join Filter: (b2t1.c1 = b2t2.c1)
1534                              ->  Tid Scan on t1 b2t1
1535                                    TID Cond: (ctid = '(1,1)'::tid)
1536                              ->  Seq Scan on t2 b2t2
1537                                    Filter: (ctid = '(1,1)'::tid)
1538                        ->  Tid Scan on t3 b2t3
1539                              TID Cond: (ctid = '(1,1)'::tid)
1540                  ->  Tid Scan on t4 b2t4
1541                        TID Cond: (ctid = '(1,1)'::tid)
1542    InitPlan 3 (returns $2)
1543      ->  Aggregate
1544            ->  Nested Loop
1545                  Join Filter: (b3t1.c1 = b3t4.c1)
1546                  ->  Nested Loop
1547                        Join Filter: (b3t1.c1 = b3t3.c1)
1548                        ->  Nested Loop
1549                              Join Filter: (b3t1.c1 = b3t2.c1)
1550                              ->  Tid Scan on t1 b3t1
1551                                    TID Cond: (ctid = '(1,1)'::tid)
1552                              ->  Seq Scan on t2 b3t2
1553                                    Filter: (ctid = '(1,1)'::tid)
1554                        ->  Tid Scan on t3 b3t3
1555                              TID Cond: (ctid = '(1,1)'::tid)
1556                  ->  Tid Scan on t4 b3t4
1557                        TID Cond: (ctid = '(1,1)'::tid)
1558    ->  Nested Loop
1559          Join Filter: (bmt1.c1 = bmt4.c1)
1560          ->  Nested Loop
1561                Join Filter: (bmt1.c1 = bmt3.c1)
1562                ->  Nested Loop
1563                      Join Filter: (bmt1.c1 = bmt2.c1)
1564                      ->  Tid Scan on t1 bmt1
1565                            TID Cond: (ctid = '(1,1)'::tid)
1566                            Filter: ((c1 <> $0) AND (c1 <> $1) AND (c1 <> $2))
1567                      ->  Seq Scan on t2 bmt2
1568                            Filter: (ctid = '(1,1)'::tid)
1569                ->  Tid Scan on t3 bmt3
1570                      TID Cond: (ctid = '(1,1)'::tid)
1571          ->  Tid Scan on t4 bmt4
1572                TID Cond: (ctid = '(1,1)'::tid)
1573 (64 rows)
1574
1575 /*+
1576 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
1577 MergeJoin(bmt1 bmt2)HashJoin(bmt1 bmt2 bmt3)NestLoop(bmt1 bmt2 bmt3 bmt4)
1578 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
1579 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
1580 MergeJoin(b3t4 b3t1)HashJoin(b3t4 b3t1 b3t2)NestLoop(b3t1 b3t2 b3t3 b3t4)
1581 */
1582 EXPLAIN (COSTS false)
1583 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1584   AND bmt1.c1 <> (
1585 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1586 ) AND bmt1.c1 <> (
1587 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1588 ) AND bmt1.c1 <> (
1589 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1590 )
1591 ;
1592 LOG:  pg_hint_plan:
1593 used hint:
1594 MergeJoin(b1t2 b1t3)
1595 MergeJoin(b2t3 b2t4)
1596 MergeJoin(b3t1 b3t4)
1597 MergeJoin(bmt1 bmt2)
1598 HashJoin(b1t2 b1t3 b1t4)
1599 HashJoin(b2t1 b2t3 b2t4)
1600 HashJoin(b3t1 b3t2 b3t4)
1601 HashJoin(bmt1 bmt2 bmt3)
1602 NestLoop(b1t1 b1t2 b1t3 b1t4)
1603 NestLoop(b2t1 b2t2 b2t3 b2t4)
1604 NestLoop(b3t1 b3t2 b3t3 b3t4)
1605 NestLoop(bmt1 bmt2 bmt3 bmt4)
1606 Leading(bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
1607 not used hint:
1608 duplication hint:
1609 error hint:
1610
1611                                         QUERY PLAN
1612 ------------------------------------------------------------------------------------------
1613  Aggregate
1614    InitPlan 1 (returns $0)
1615      ->  Aggregate
1616            ->  Nested Loop
1617                  Join Filter: (b1t2.c1 = b1t1.c1)
1618                  ->  Hash Join
1619                        Hash Cond: (b1t4.c1 = b1t2.c1)
1620                        ->  Tid Scan on t4 b1t4
1621                              TID Cond: (ctid = '(1,1)'::tid)
1622                        ->  Hash
1623                              ->  Merge Join
1624                                    Merge Cond: (b1t2.c1 = b1t3.c1)
1625                                    ->  Sort
1626                                          Sort Key: b1t2.c1
1627                                          ->  Seq Scan on t2 b1t2
1628                                                Filter: (ctid = '(1,1)'::tid)
1629                                    ->  Sort
1630                                          Sort Key: b1t3.c1
1631                                          ->  Tid Scan on t3 b1t3
1632                                                TID Cond: (ctid = '(1,1)'::tid)
1633                  ->  Tid Scan on t1 b1t1
1634                        TID Cond: (ctid = '(1,1)'::tid)
1635    InitPlan 2 (returns $1)
1636      ->  Aggregate
1637            ->  Nested Loop
1638                  Join Filter: (b2t1.c1 = b2t2.c1)
1639                  ->  Hash Join
1640                        Hash Cond: (b2t1.c1 = b2t3.c1)
1641                        ->  Tid Scan on t1 b2t1
1642                              TID Cond: (ctid = '(1,1)'::tid)
1643                        ->  Hash
1644                              ->  Merge Join
1645                                    Merge Cond: (b2t3.c1 = b2t4.c1)
1646                                    ->  Sort
1647                                          Sort Key: b2t3.c1
1648                                          ->  Tid Scan on t3 b2t3
1649                                                TID Cond: (ctid = '(1,1)'::tid)
1650                                    ->  Sort
1651                                          Sort Key: b2t4.c1
1652                                          ->  Tid Scan on t4 b2t4
1653                                                TID Cond: (ctid = '(1,1)'::tid)
1654                  ->  Seq Scan on t2 b2t2
1655                        Filter: (ctid = '(1,1)'::tid)
1656    InitPlan 3 (returns $2)
1657      ->  Aggregate
1658            ->  Nested Loop
1659                  Join Filter: (b3t1.c1 = b3t3.c1)
1660                  ->  Hash Join
1661                        Hash Cond: (b3t2.c1 = b3t1.c1)
1662                        ->  Seq Scan on t2 b3t2
1663                              Filter: (ctid = '(1,1)'::tid)
1664                        ->  Hash
1665                              ->  Merge Join
1666                                    Merge Cond: (b3t1.c1 = b3t4.c1)
1667                                    ->  Sort
1668                                          Sort Key: b3t1.c1
1669                                          ->  Tid Scan on t1 b3t1
1670                                                TID Cond: (ctid = '(1,1)'::tid)
1671                                    ->  Sort
1672                                          Sort Key: b3t4.c1
1673                                          ->  Tid Scan on t4 b3t4
1674                                                TID Cond: (ctid = '(1,1)'::tid)
1675                  ->  Tid Scan on t3 b3t3
1676                        TID Cond: (ctid = '(1,1)'::tid)
1677    ->  Nested Loop
1678          Join Filter: (bmt1.c1 = bmt4.c1)
1679          ->  Hash Join
1680                Hash Cond: (bmt3.c1 = bmt1.c1)
1681                ->  Tid Scan on t3 bmt3
1682                      TID Cond: (ctid = '(1,1)'::tid)
1683                ->  Hash
1684                      ->  Merge Join
1685                            Merge Cond: (bmt1.c1 = bmt2.c1)
1686                            ->  Sort
1687                                  Sort Key: bmt1.c1
1688                                  ->  Tid Scan on t1 bmt1
1689                                        TID Cond: (ctid = '(1,1)'::tid)
1690                                        Filter: ((c1 <> $0) AND (c1 <> $1) AND (c1 <> $2))
1691                            ->  Sort
1692                                  Sort Key: bmt2.c1
1693                                  ->  Seq Scan on t2 bmt2
1694                                        Filter: (ctid = '(1,1)'::tid)
1695          ->  Tid Scan on t4 bmt4
1696                TID Cond: (ctid = '(1,1)'::tid)
1697 (84 rows)
1698
1699 -- No. J-2-1-7
1700 EXPLAIN (COSTS false)
1701 WITH c1 (c1) AS (
1702 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1703 )
1704 , c2 (c1) AS (
1705 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1706 )
1707 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4
1708 , c1, c2
1709                                                                         WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1710 AND bmt1.c1 = c1.c1
1711 AND bmt1.c1 = c2.c1
1712 ;
1713                               QUERY PLAN
1714 -----------------------------------------------------------------------
1715  Aggregate
1716    CTE c1
1717      ->  Aggregate
1718            ->  Nested Loop
1719                  Join Filter: (b1t1.c1 = b1t4.c1)
1720                  ->  Nested Loop
1721                        Join Filter: (b1t1.c1 = b1t3.c1)
1722                        ->  Nested Loop
1723                              Join Filter: (b1t1.c1 = b1t2.c1)
1724                              ->  Tid Scan on t1 b1t1
1725                                    TID Cond: (ctid = '(1,1)'::tid)
1726                              ->  Seq Scan on t2 b1t2
1727                                    Filter: (ctid = '(1,1)'::tid)
1728                        ->  Tid Scan on t3 b1t3
1729                              TID Cond: (ctid = '(1,1)'::tid)
1730                  ->  Tid Scan on t4 b1t4
1731                        TID Cond: (ctid = '(1,1)'::tid)
1732    CTE c2
1733      ->  Aggregate
1734            ->  Nested Loop
1735                  Join Filter: (b2t1.c1 = b2t4.c1)
1736                  ->  Nested Loop
1737                        Join Filter: (b2t1.c1 = b2t3.c1)
1738                        ->  Nested Loop
1739                              Join Filter: (b2t1.c1 = b2t2.c1)
1740                              ->  Tid Scan on t1 b2t1
1741                                    TID Cond: (ctid = '(1,1)'::tid)
1742                              ->  Seq Scan on t2 b2t2
1743                                    Filter: (ctid = '(1,1)'::tid)
1744                        ->  Tid Scan on t3 b2t3
1745                              TID Cond: (ctid = '(1,1)'::tid)
1746                  ->  Tid Scan on t4 b2t4
1747                        TID Cond: (ctid = '(1,1)'::tid)
1748    ->  Nested Loop
1749          Join Filter: (bmt1.c1 = c2.c1)
1750          ->  Nested Loop
1751                Join Filter: (bmt1.c1 = c1.c1)
1752                ->  Nested Loop
1753                      Join Filter: (bmt1.c1 = bmt4.c1)
1754                      ->  Nested Loop
1755                            Join Filter: (bmt1.c1 = bmt3.c1)
1756                            ->  Nested Loop
1757                                  Join Filter: (bmt1.c1 = bmt2.c1)
1758                                  ->  Tid Scan on t1 bmt1
1759                                        TID Cond: (ctid = '(1,1)'::tid)
1760                                  ->  Seq Scan on t2 bmt2
1761                                        Filter: (ctid = '(1,1)'::tid)
1762                            ->  Tid Scan on t3 bmt3
1763                                  TID Cond: (ctid = '(1,1)'::tid)
1764                      ->  Tid Scan on t4 bmt4
1765                            TID Cond: (ctid = '(1,1)'::tid)
1766                ->  CTE Scan on c1
1767          ->  CTE Scan on c2
1768 (53 rows)
1769
1770 /*+
1771 Leading(c2 c1 bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
1772 MergeJoin(c2 c1)HashJoin(c2 c1 bmt1)NestLoop(c2 c1 bmt1 bmt2)MergeJoin(c2 c1 bmt1 bmt2 bmt3)HashJoin(c2 c1 bmt1 bmt2 bmt3 bmt4)
1773 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
1774 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
1775 */
1776 EXPLAIN (COSTS false)
1777 WITH c1 (c1) AS (
1778 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1779 )
1780 , c2 (c1) AS (
1781 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1782 )
1783 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4
1784 , c1, c2
1785                                                                         WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1786 AND bmt1.c1 = c1.c1
1787 AND bmt1.c1 = c2.c1
1788 ;
1789 LOG:  pg_hint_plan:
1790 used hint:
1791 MergeJoin(b1t2 b1t3)
1792 MergeJoin(b2t3 b2t4)
1793 MergeJoin(c1 c2)
1794 HashJoin(b1t2 b1t3 b1t4)
1795 HashJoin(b2t1 b2t3 b2t4)
1796 HashJoin(bmt1 c1 c2)
1797 NestLoop(b1t1 b1t2 b1t3 b1t4)
1798 NestLoop(b2t1 b2t2 b2t3 b2t4)
1799 NestLoop(bmt1 bmt2 c1 c2)
1800 MergeJoin(bmt1 bmt2 bmt3 c1 c2)
1801 HashJoin(bmt1 bmt2 bmt3 bmt4 c1 c2)
1802 Leading(c2 c1 bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2)
1803 not used hint:
1804 duplication hint:
1805 error hint:
1806
1807                                   QUERY PLAN
1808 -------------------------------------------------------------------------------
1809  Aggregate
1810    CTE c1
1811      ->  Aggregate
1812            ->  Nested Loop
1813                  Join Filter: (b1t2.c1 = b1t1.c1)
1814                  ->  Hash Join
1815                        Hash Cond: (b1t4.c1 = b1t2.c1)
1816                        ->  Tid Scan on t4 b1t4
1817                              TID Cond: (ctid = '(1,1)'::tid)
1818                        ->  Hash
1819                              ->  Merge Join
1820                                    Merge Cond: (b1t2.c1 = b1t3.c1)
1821                                    ->  Sort
1822                                          Sort Key: b1t2.c1
1823                                          ->  Seq Scan on t2 b1t2
1824                                                Filter: (ctid = '(1,1)'::tid)
1825                                    ->  Sort
1826                                          Sort Key: b1t3.c1
1827                                          ->  Tid Scan on t3 b1t3
1828                                                TID Cond: (ctid = '(1,1)'::tid)
1829                  ->  Tid Scan on t1 b1t1
1830                        TID Cond: (ctid = '(1,1)'::tid)
1831    CTE c2
1832      ->  Aggregate
1833            ->  Nested Loop
1834                  Join Filter: (b2t1.c1 = b2t2.c1)
1835                  ->  Hash Join
1836                        Hash Cond: (b2t1.c1 = b2t3.c1)
1837                        ->  Tid Scan on t1 b2t1
1838                              TID Cond: (ctid = '(1,1)'::tid)
1839                        ->  Hash
1840                              ->  Merge Join
1841                                    Merge Cond: (b2t3.c1 = b2t4.c1)
1842                                    ->  Sort
1843                                          Sort Key: b2t3.c1
1844                                          ->  Tid Scan on t3 b2t3
1845                                                TID Cond: (ctid = '(1,1)'::tid)
1846                                    ->  Sort
1847                                          Sort Key: b2t4.c1
1848                                          ->  Tid Scan on t4 b2t4
1849                                                TID Cond: (ctid = '(1,1)'::tid)
1850                  ->  Seq Scan on t2 b2t2
1851                        Filter: (ctid = '(1,1)'::tid)
1852    ->  Hash Join
1853          Hash Cond: (bmt4.c1 = bmt1.c1)
1854          ->  Tid Scan on t4 bmt4
1855                TID Cond: (ctid = '(1,1)'::tid)
1856          ->  Hash
1857                ->  Merge Join
1858                      Merge Cond: (bmt1.c1 = bmt3.c1)
1859                      ->  Sort
1860                            Sort Key: bmt1.c1
1861                            ->  Nested Loop
1862                                  Join Filter: (bmt1.c1 = bmt2.c1)
1863                                  ->  Hash Join
1864                                        Hash Cond: (bmt1.c1 = c1.c1)
1865                                        ->  Tid Scan on t1 bmt1
1866                                              TID Cond: (ctid = '(1,1)'::tid)
1867                                        ->  Hash
1868                                              ->  Merge Join
1869                                                    Merge Cond: (c1.c1 = c2.c1)
1870                                                    ->  Sort
1871                                                          Sort Key: c1.c1
1872                                                          ->  CTE Scan on c1
1873                                                    ->  Sort
1874                                                          Sort Key: c2.c1
1875                                                          ->  CTE Scan on c2
1876                                  ->  Seq Scan on t2 bmt2
1877                                        Filter: (ctid = '(1,1)'::tid)
1878                      ->  Sort
1879                            Sort Key: bmt3.c1
1880                            ->  Tid Scan on t3 bmt3
1881                                  TID Cond: (ctid = '(1,1)'::tid)
1882 (73 rows)
1883
1884 -- No. J-2-1-8
1885 EXPLAIN (COSTS false)
1886 WITH c1 (c1) AS (
1887 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1888 )
1889 , c2 (c1) AS (
1890 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1891 )
1892 , c3 (c1) AS (
1893 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1894 )
1895 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4
1896 , c1, c2, c3
1897                                                                         WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1898 AND bmt1.c1 = c1.c1
1899 AND bmt1.c1 = c2.c1
1900 AND bmt1.c1 = c3.c1
1901 ;
1902                                  QUERY PLAN
1903 -----------------------------------------------------------------------------
1904  Aggregate
1905    CTE c1
1906      ->  Aggregate
1907            ->  Nested Loop
1908                  Join Filter: (b1t1.c1 = b1t4.c1)
1909                  ->  Nested Loop
1910                        Join Filter: (b1t1.c1 = b1t3.c1)
1911                        ->  Nested Loop
1912                              Join Filter: (b1t1.c1 = b1t2.c1)
1913                              ->  Tid Scan on t1 b1t1
1914                                    TID Cond: (ctid = '(1,1)'::tid)
1915                              ->  Seq Scan on t2 b1t2
1916                                    Filter: (ctid = '(1,1)'::tid)
1917                        ->  Tid Scan on t3 b1t3
1918                              TID Cond: (ctid = '(1,1)'::tid)
1919                  ->  Tid Scan on t4 b1t4
1920                        TID Cond: (ctid = '(1,1)'::tid)
1921    CTE c2
1922      ->  Aggregate
1923            ->  Nested Loop
1924                  Join Filter: (b2t1.c1 = b2t4.c1)
1925                  ->  Nested Loop
1926                        Join Filter: (b2t1.c1 = b2t3.c1)
1927                        ->  Nested Loop
1928                              Join Filter: (b2t1.c1 = b2t2.c1)
1929                              ->  Tid Scan on t1 b2t1
1930                                    TID Cond: (ctid = '(1,1)'::tid)
1931                              ->  Seq Scan on t2 b2t2
1932                                    Filter: (ctid = '(1,1)'::tid)
1933                        ->  Tid Scan on t3 b2t3
1934                              TID Cond: (ctid = '(1,1)'::tid)
1935                  ->  Tid Scan on t4 b2t4
1936                        TID Cond: (ctid = '(1,1)'::tid)
1937    CTE c3
1938      ->  Aggregate
1939            ->  Nested Loop
1940                  Join Filter: (b3t1.c1 = b3t4.c1)
1941                  ->  Nested Loop
1942                        Join Filter: (b3t1.c1 = b3t3.c1)
1943                        ->  Nested Loop
1944                              Join Filter: (b3t1.c1 = b3t2.c1)
1945                              ->  Tid Scan on t1 b3t1
1946                                    TID Cond: (ctid = '(1,1)'::tid)
1947                              ->  Seq Scan on t2 b3t2
1948                                    Filter: (ctid = '(1,1)'::tid)
1949                        ->  Tid Scan on t3 b3t3
1950                              TID Cond: (ctid = '(1,1)'::tid)
1951                  ->  Tid Scan on t4 b3t4
1952                        TID Cond: (ctid = '(1,1)'::tid)
1953    ->  Nested Loop
1954          Join Filter: (bmt1.c1 = c3.c1)
1955          ->  Nested Loop
1956                Join Filter: (bmt1.c1 = c2.c1)
1957                ->  Nested Loop
1958                      Join Filter: (bmt1.c1 = c1.c1)
1959                      ->  Nested Loop
1960                            Join Filter: (bmt1.c1 = bmt4.c1)
1961                            ->  Nested Loop
1962                                  Join Filter: (bmt1.c1 = bmt3.c1)
1963                                  ->  Nested Loop
1964                                        Join Filter: (bmt1.c1 = bmt2.c1)
1965                                        ->  Tid Scan on t1 bmt1
1966                                              TID Cond: (ctid = '(1,1)'::tid)
1967                                        ->  Seq Scan on t2 bmt2
1968                                              Filter: (ctid = '(1,1)'::tid)
1969                                  ->  Tid Scan on t3 bmt3
1970                                        TID Cond: (ctid = '(1,1)'::tid)
1971                            ->  Tid Scan on t4 bmt4
1972                                  TID Cond: (ctid = '(1,1)'::tid)
1973                      ->  CTE Scan on c1
1974                ->  CTE Scan on c2
1975          ->  CTE Scan on c3
1976 (72 rows)
1977
1978 /*+
1979 Leading(c3 c2 c1 bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
1980 MergeJoin(c3 c2)HashJoin(c3 c2 c1)NestLoop(c3 c2 c1 bmt1)MergeJoin(c3 c2 c1 bmt1 bmt2)HashJoin(c3 c2 c1 bmt1 bmt2 bmt3)NestLoop(c3 c2 c1 bmt1 bmt2 bmt3 bmt4)
1981 MergeJoin(b1t2 b1t3)HashJoin(b1t2 b1t3 b1t4)NestLoop(b1t2 b1t3 b1t4 b1t1)
1982 MergeJoin(b2t3 b2t4)HashJoin(b2t3 b2t4 b2t1)NestLoop(b2t3 b2t4 b2t1 b2t2)
1983 MergeJoin(b3t4 b3t1)HashJoin(b3t4 b3t1 b3t2)NestLoop(b3t1 b3t2 b3t3 b3t4)
1984 */
1985 EXPLAIN (COSTS false)
1986 WITH c1 (c1) AS (
1987 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
1988 )
1989 , c2 (c1) AS (
1990 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
1991 )
1992 , c3 (c1) AS (
1993 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
1994 )
1995 SELECT max(bmt1.c1) FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4
1996 , c1, c2, c3
1997                                                                         WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)'
1998 AND bmt1.c1 = c1.c1
1999 AND bmt1.c1 = c2.c1
2000 AND bmt1.c1 = c3.c1
2001 ;
2002 LOG:  pg_hint_plan:
2003 used hint:
2004 MergeJoin(b1t2 b1t3)
2005 MergeJoin(b2t3 b2t4)
2006 MergeJoin(b3t1 b3t4)
2007 MergeJoin(c2 c3)
2008 HashJoin(b1t2 b1t3 b1t4)
2009 HashJoin(b2t1 b2t3 b2t4)
2010 HashJoin(b3t1 b3t2 b3t4)
2011 HashJoin(c1 c2 c3)
2012 NestLoop(b1t1 b1t2 b1t3 b1t4)
2013 NestLoop(b2t1 b2t2 b2t3 b2t4)
2014 NestLoop(b3t1 b3t2 b3t3 b3t4)
2015 NestLoop(bmt1 c1 c2 c3)
2016 MergeJoin(bmt1 bmt2 c1 c2 c3)
2017 HashJoin(bmt1 bmt2 bmt3 c1 c2 c3)
2018 NestLoop(bmt1 bmt2 bmt3 bmt4 c1 c2 c3)
2019 Leading(c3 c2 c1 bmt1 bmt2 bmt3 bmt4 b1t2 b1t3 b1t4 b1t1 b2t3 b2t4 b2t1 b2t2 b3t4 b3t1 b3t2 b3t3)
2020 not used hint:
2021 duplication hint:
2022 error hint:
2023
2024                                   QUERY PLAN
2025 -------------------------------------------------------------------------------
2026  Aggregate
2027    CTE c1
2028      ->  Aggregate
2029            ->  Nested Loop
2030                  Join Filter: (b1t2.c1 = b1t1.c1)
2031                  ->  Hash Join
2032                        Hash Cond: (b1t4.c1 = b1t2.c1)
2033                        ->  Tid Scan on t4 b1t4
2034                              TID Cond: (ctid = '(1,1)'::tid)
2035                        ->  Hash
2036                              ->  Merge Join
2037                                    Merge Cond: (b1t2.c1 = b1t3.c1)
2038                                    ->  Sort
2039                                          Sort Key: b1t2.c1
2040                                          ->  Seq Scan on t2 b1t2
2041                                                Filter: (ctid = '(1,1)'::tid)
2042                                    ->  Sort
2043                                          Sort Key: b1t3.c1
2044                                          ->  Tid Scan on t3 b1t3
2045                                                TID Cond: (ctid = '(1,1)'::tid)
2046                  ->  Tid Scan on t1 b1t1
2047                        TID Cond: (ctid = '(1,1)'::tid)
2048    CTE c2
2049      ->  Aggregate
2050            ->  Nested Loop
2051                  Join Filter: (b2t1.c1 = b2t2.c1)
2052                  ->  Hash Join
2053                        Hash Cond: (b2t1.c1 = b2t3.c1)
2054                        ->  Tid Scan on t1 b2t1
2055                              TID Cond: (ctid = '(1,1)'::tid)
2056                        ->  Hash
2057                              ->  Merge Join
2058                                    Merge Cond: (b2t3.c1 = b2t4.c1)
2059                                    ->  Sort
2060                                          Sort Key: b2t3.c1
2061                                          ->  Tid Scan on t3 b2t3
2062                                                TID Cond: (ctid = '(1,1)'::tid)
2063                                    ->  Sort
2064                                          Sort Key: b2t4.c1
2065                                          ->  Tid Scan on t4 b2t4
2066                                                TID Cond: (ctid = '(1,1)'::tid)
2067                  ->  Seq Scan on t2 b2t2
2068                        Filter: (ctid = '(1,1)'::tid)
2069    CTE c3
2070      ->  Aggregate
2071            ->  Nested Loop
2072                  Join Filter: (b3t1.c1 = b3t3.c1)
2073                  ->  Hash Join
2074                        Hash Cond: (b3t2.c1 = b3t1.c1)
2075                        ->  Seq Scan on t2 b3t2
2076                              Filter: (ctid = '(1,1)'::tid)
2077                        ->  Hash
2078                              ->  Merge Join
2079                                    Merge Cond: (b3t1.c1 = b3t4.c1)
2080                                    ->  Sort
2081                                          Sort Key: b3t1.c1
2082                                          ->  Tid Scan on t1 b3t1
2083                                                TID Cond: (ctid = '(1,1)'::tid)
2084                                    ->  Sort
2085                                          Sort Key: b3t4.c1
2086                                          ->  Tid Scan on t4 b3t4
2087                                                TID Cond: (ctid = '(1,1)'::tid)
2088                  ->  Tid Scan on t3 b3t3
2089                        TID Cond: (ctid = '(1,1)'::tid)
2090    ->  Nested Loop
2091          Join Filter: (bmt1.c1 = bmt4.c1)
2092          ->  Hash Join
2093                Hash Cond: (bmt3.c1 = bmt1.c1)
2094                ->  Tid Scan on t3 bmt3
2095                      TID Cond: (ctid = '(1,1)'::tid)
2096                ->  Hash
2097                      ->  Merge Join
2098                            Merge Cond: (bmt1.c1 = bmt2.c1)
2099                            ->  Sort
2100                                  Sort Key: bmt1.c1
2101                                  ->  Nested Loop
2102                                        Join Filter: (c1.c1 = bmt1.c1)
2103                                        ->  Hash Join
2104                                              Hash Cond: (c2.c1 = c1.c1)
2105                                              ->  Merge Join
2106                                                    Merge Cond: (c2.c1 = c3.c1)
2107                                                    ->  Sort
2108                                                          Sort Key: c2.c1
2109                                                          ->  CTE Scan on c2
2110                                                    ->  Sort
2111                                                          Sort Key: c3.c1
2112                                                          ->  CTE Scan on c3
2113                                              ->  Hash
2114                                                    ->  CTE Scan on c1
2115                                        ->  Tid Scan on t1 bmt1
2116                                              TID Cond: (ctid = '(1,1)'::tid)
2117                            ->  Sort
2118                                  Sort Key: bmt2.c1
2119                                  ->  Seq Scan on t2 bmt2
2120                                        Filter: (ctid = '(1,1)'::tid)
2121          ->  Tid Scan on t4 bmt4
2122                TID Cond: (ctid = '(1,1)'::tid)
2123 (97 rows)
2124
2125 ----
2126 ---- No. J-2-2 the number of the tables per quiry block
2127 ----
2128 -- No. J-2-2-1
2129 EXPLAIN (COSTS false)
2130 WITH c1 (c1) AS (
2131 SELECT max(b1t1.c1) FROM s1.t1 b1t1 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = 1
2132 )
2133 SELECT max(bmt1.c1), (
2134 SELECT max(b2t1.c1) FROM s1.t1 b2t1 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = 1
2135 )
2136                     FROM s1.t1 bmt1, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = 1
2137 AND bmt1.c1 = c1.c1
2138 AND bmt1.c1 <> (
2139 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = 1
2140 )
2141 ;
2142                            QUERY PLAN
2143 -----------------------------------------------------------------
2144  Aggregate
2145    CTE c1
2146      ->  Result
2147            InitPlan 1 (returns $0)
2148              ->  Limit
2149                    ->  Tid Scan on t1 b1t1
2150                          TID Cond: (ctid = '(1,1)'::tid)
2151                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2152    InitPlan 4 (returns $3)
2153      ->  Result
2154            InitPlan 3 (returns $2)
2155              ->  Limit
2156                    ->  Tid Scan on t1 b2t1
2157                          TID Cond: (ctid = '(1,1)'::tid)
2158                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2159    InitPlan 6 (returns $5)
2160      ->  Result
2161            InitPlan 5 (returns $4)
2162              ->  Limit
2163                    ->  Tid Scan on t1 b3t1
2164                          TID Cond: (ctid = '(1,1)'::tid)
2165                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2166    ->  Nested Loop
2167          ->  Tid Scan on t1 bmt1
2168                TID Cond: (ctid = '(1,1)'::tid)
2169                Filter: ((c1 <> $5) AND (c1 = 1))
2170          ->  CTE Scan on c1
2171                Filter: (c1 = 1)
2172 (28 rows)
2173
2174 /*+
2175 Leading(c1 bmt1 b1t1 b2t1 b3t1)
2176 HashJoin(bmt1 c1)
2177 HashJoin(b1t1 c1)
2178 HashJoin(b2t1 c1)
2179 HashJoin(b3t1 c1)
2180 */
2181 EXPLAIN (COSTS false)
2182 WITH c1 (c1) AS (
2183 SELECT max(b1t1.c1) FROM s1.t1 b1t1 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = 1
2184 )
2185 SELECT max(bmt1.c1), (
2186 SELECT max(b2t1.c1) FROM s1.t1 b2t1 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = 1
2187 )
2188                     FROM s1.t1 bmt1, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = 1
2189 AND bmt1.c1 = c1.c1
2190 AND bmt1.c1 <> (
2191 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = 1
2192 )
2193 ;
2194 LOG:  pg_hint_plan:
2195 used hint:
2196 HashJoin(bmt1 c1)
2197 Leading(c1 bmt1 b1t1 b2t1 b3t1)
2198 not used hint:
2199 HashJoin(b1t1 c1)
2200 HashJoin(b2t1 c1)
2201 HashJoin(b3t1 c1)
2202 duplication hint:
2203 error hint:
2204
2205                            QUERY PLAN
2206 -----------------------------------------------------------------
2207  Aggregate
2208    CTE c1
2209      ->  Result
2210            InitPlan 1 (returns $0)
2211              ->  Limit
2212                    ->  Tid Scan on t1 b1t1
2213                          TID Cond: (ctid = '(1,1)'::tid)
2214                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2215    InitPlan 4 (returns $3)
2216      ->  Result
2217            InitPlan 3 (returns $2)
2218              ->  Limit
2219                    ->  Tid Scan on t1 b2t1
2220                          TID Cond: (ctid = '(1,1)'::tid)
2221                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2222    InitPlan 6 (returns $5)
2223      ->  Result
2224            InitPlan 5 (returns $4)
2225              ->  Limit
2226                    ->  Tid Scan on t1 b3t1
2227                          TID Cond: (ctid = '(1,1)'::tid)
2228                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2229    ->  Nested Loop
2230          ->  Tid Scan on t1 bmt1
2231                TID Cond: (ctid = '(1,1)'::tid)
2232                Filter: ((c1 <> $5) AND (c1 = 1))
2233          ->  CTE Scan on c1
2234                Filter: (c1 = 1)
2235 (28 rows)
2236
2237 -- No. J-2-2-2
2238 EXPLAIN (COSTS false)
2239 WITH c1 (c1) AS (
2240 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)'
2241 )
2242 SELECT max(bmt1.c1), (
2243 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)'
2244 )
2245                     FROM s1.t1 bmt1, s1.t2 bmt2, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)'
2246 AND bmt1.c1 = c1.c1
2247 AND bmt1.c1 <> (
2248 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)'
2249 )
2250 ;
2251                       QUERY PLAN
2252 -------------------------------------------------------
2253  Aggregate
2254    CTE c1
2255      ->  Aggregate
2256            ->  Nested Loop
2257                  Join Filter: (b1t1.c1 = b1t2.c1)
2258                  ->  Tid Scan on t1 b1t1
2259                        TID Cond: (ctid = '(1,1)'::tid)
2260                  ->  Seq Scan on t2 b1t2
2261                        Filter: (ctid = '(1,1)'::tid)
2262    InitPlan 2 (returns $1)
2263      ->  Aggregate
2264            ->  Nested Loop
2265                  Join Filter: (b2t1.c1 = b2t2.c1)
2266                  ->  Tid Scan on t1 b2t1
2267                        TID Cond: (ctid = '(1,1)'::tid)
2268                  ->  Seq Scan on t2 b2t2
2269                        Filter: (ctid = '(1,1)'::tid)
2270    InitPlan 3 (returns $2)
2271      ->  Aggregate
2272            ->  Nested Loop
2273                  Join Filter: (b3t1.c1 = b3t2.c1)
2274                  ->  Tid Scan on t1 b3t1
2275                        TID Cond: (ctid = '(1,1)'::tid)
2276                  ->  Seq Scan on t2 b3t2
2277                        Filter: (ctid = '(1,1)'::tid)
2278    ->  Nested Loop
2279          Join Filter: (bmt1.c1 = c1.c1)
2280          ->  Nested Loop
2281                Join Filter: (bmt1.c1 = bmt2.c1)
2282                ->  Tid Scan on t1 bmt1
2283                      TID Cond: (ctid = '(1,1)'::tid)
2284                      Filter: (c1 <> $2)
2285                ->  Seq Scan on t2 bmt2
2286                      Filter: (ctid = '(1,1)'::tid)
2287          ->  CTE Scan on c1
2288 (35 rows)
2289
2290 /*+
2291 Leading(c1 bmt2 b1t2 b2t2 b3t2 bmt1 b1t1 b2t1 b3t1)
2292 MergeJoin(c1 bmt2)
2293 HashJoin(c1 bmt1 bmt2)
2294 MergeJoin(b1t1 b1t2)
2295 MergeJoin(b2t1 b2t2)
2296 MergeJoin(b3t1 b3t2)
2297 */
2298 EXPLAIN (COSTS false)
2299 WITH c1 (c1) AS (
2300 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)'
2301 )
2302 SELECT max(bmt1.c1), (
2303 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)'
2304 )
2305                     FROM s1.t1 bmt1, s1.t2 bmt2, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)'
2306 AND bmt1.c1 = c1.c1
2307 AND bmt1.c1 <> (
2308 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)'
2309 )
2310 ;
2311 LOG:  pg_hint_plan:
2312 used hint:
2313 MergeJoin(b1t1 b1t2)
2314 MergeJoin(b2t1 b2t2)
2315 MergeJoin(b3t1 b3t2)
2316 MergeJoin(bmt2 c1)
2317 HashJoin(bmt1 bmt2 c1)
2318 Leading(c1 bmt2 b1t2 b2t2 b3t2 bmt1 b1t1 b2t1 b3t1)
2319 not used hint:
2320 duplication hint:
2321 error hint:
2322
2323                           QUERY PLAN
2324 ---------------------------------------------------------------
2325  Aggregate
2326    CTE c1
2327      ->  Aggregate
2328            ->  Merge Join
2329                  Merge Cond: (b1t1.c1 = b1t2.c1)
2330                  ->  Sort
2331                        Sort Key: b1t1.c1
2332                        ->  Tid Scan on t1 b1t1
2333                              TID Cond: (ctid = '(1,1)'::tid)
2334                  ->  Sort
2335                        Sort Key: b1t2.c1
2336                        ->  Seq Scan on t2 b1t2
2337                              Filter: (ctid = '(1,1)'::tid)
2338    InitPlan 2 (returns $1)
2339      ->  Aggregate
2340            ->  Merge Join
2341                  Merge Cond: (b2t1.c1 = b2t2.c1)
2342                  ->  Sort
2343                        Sort Key: b2t1.c1
2344                        ->  Tid Scan on t1 b2t1
2345                              TID Cond: (ctid = '(1,1)'::tid)
2346                  ->  Sort
2347                        Sort Key: b2t2.c1
2348                        ->  Seq Scan on t2 b2t2
2349                              Filter: (ctid = '(1,1)'::tid)
2350    InitPlan 3 (returns $2)
2351      ->  Aggregate
2352            ->  Merge Join
2353                  Merge Cond: (b3t1.c1 = b3t2.c1)
2354                  ->  Sort
2355                        Sort Key: b3t1.c1
2356                        ->  Tid Scan on t1 b3t1
2357                              TID Cond: (ctid = '(1,1)'::tid)
2358                  ->  Sort
2359                        Sort Key: b3t2.c1
2360                        ->  Seq Scan on t2 b3t2
2361                              Filter: (ctid = '(1,1)'::tid)
2362    ->  Hash Join
2363          Hash Cond: (bmt1.c1 = bmt2.c1)
2364          ->  Tid Scan on t1 bmt1
2365                TID Cond: (ctid = '(1,1)'::tid)
2366                Filter: (c1 <> $2)
2367          ->  Hash
2368                ->  Merge Join
2369                      Merge Cond: (bmt2.c1 = c1.c1)
2370                      ->  Sort
2371                            Sort Key: bmt2.c1
2372                            ->  Seq Scan on t2 bmt2
2373                                  Filter: (ctid = '(1,1)'::tid)
2374                      ->  Sort
2375                            Sort Key: c1.c1
2376                            ->  CTE Scan on c1
2377 (52 rows)
2378
2379 -- No. J-2-2-3
2380 EXPLAIN (COSTS false)
2381 WITH c1 (c1) AS (
2382 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
2383 )
2384 SELECT max(bmt1.c1), (
2385 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
2386 )
2387                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)' AND bmt1.c1 = c1.c1
2388 AND bmt1.c1 <> (
2389 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
2390 )
2391 ;
2392                             QUERY PLAN
2393 -------------------------------------------------------------------
2394  Aggregate
2395    CTE c1
2396      ->  Aggregate
2397            ->  Nested Loop
2398                  Join Filter: (b1t1.c1 = b1t4.c1)
2399                  ->  Nested Loop
2400                        Join Filter: (b1t1.c1 = b1t3.c1)
2401                        ->  Nested Loop
2402                              Join Filter: (b1t1.c1 = b1t2.c1)
2403                              ->  Tid Scan on t1 b1t1
2404                                    TID Cond: (ctid = '(1,1)'::tid)
2405                              ->  Seq Scan on t2 b1t2
2406                                    Filter: (ctid = '(1,1)'::tid)
2407                        ->  Tid Scan on t3 b1t3
2408                              TID Cond: (ctid = '(1,1)'::tid)
2409                  ->  Tid Scan on t4 b1t4
2410                        TID Cond: (ctid = '(1,1)'::tid)
2411    InitPlan 2 (returns $1)
2412      ->  Aggregate
2413            ->  Nested Loop
2414                  Join Filter: (b2t1.c1 = b2t4.c1)
2415                  ->  Nested Loop
2416                        Join Filter: (b2t1.c1 = b2t3.c1)
2417                        ->  Nested Loop
2418                              Join Filter: (b2t1.c1 = b2t2.c1)
2419                              ->  Tid Scan on t1 b2t1
2420                                    TID Cond: (ctid = '(1,1)'::tid)
2421                              ->  Seq Scan on t2 b2t2
2422                                    Filter: (ctid = '(1,1)'::tid)
2423                        ->  Tid Scan on t3 b2t3
2424                              TID Cond: (ctid = '(1,1)'::tid)
2425                  ->  Tid Scan on t4 b2t4
2426                        TID Cond: (ctid = '(1,1)'::tid)
2427    InitPlan 3 (returns $2)
2428      ->  Aggregate
2429            ->  Nested Loop
2430                  Join Filter: (b3t1.c1 = b3t4.c1)
2431                  ->  Nested Loop
2432                        Join Filter: (b3t1.c1 = b3t3.c1)
2433                        ->  Nested Loop
2434                              Join Filter: (b3t1.c1 = b3t2.c1)
2435                              ->  Tid Scan on t1 b3t1
2436                                    TID Cond: (ctid = '(1,1)'::tid)
2437                              ->  Seq Scan on t2 b3t2
2438                                    Filter: (ctid = '(1,1)'::tid)
2439                        ->  Tid Scan on t3 b3t3
2440                              TID Cond: (ctid = '(1,1)'::tid)
2441                  ->  Tid Scan on t4 b3t4
2442                        TID Cond: (ctid = '(1,1)'::tid)
2443    ->  Nested Loop
2444          Join Filter: (bmt1.c1 = c1.c1)
2445          ->  Nested Loop
2446                Join Filter: (bmt1.c1 = bmt4.c1)
2447                ->  Nested Loop
2448                      Join Filter: (bmt1.c1 = bmt3.c1)
2449                      ->  Nested Loop
2450                            Join Filter: (bmt1.c1 = bmt2.c1)
2451                            ->  Tid Scan on t1 bmt1
2452                                  TID Cond: (ctid = '(1,1)'::tid)
2453                                  Filter: (c1 <> $2)
2454                            ->  Seq Scan on t2 bmt2
2455                                  Filter: (ctid = '(1,1)'::tid)
2456                      ->  Tid Scan on t3 bmt3
2457                            TID Cond: (ctid = '(1,1)'::tid)
2458                ->  Tid Scan on t4 bmt4
2459                      TID Cond: (ctid = '(1,1)'::tid)
2460          ->  CTE Scan on c1
2461 (67 rows)
2462
2463 /*+
2464 Leading(c1 bmt4 b1t4 b2t4 b3t4 bmt3 b1t3 b2t3 b3t3 bmt2 b1t2 b2t2 b3t2 bmt1 b1t1 b2t1 b3t1)
2465 MergeJoin(c1 bmt4)
2466 HashJoin(c1 bmt4 bmt3)
2467 NestLoop(c1 bmt4 bmt3 bmt2)
2468 MergeJoin(c1 bmt4 bmt3 bmt2 bmt1)
2469 HashJoin(b1t4 b1t3)
2470 NestLoop(b1t4 b1t3 b1t2)
2471 MergeJoin(b1t4 b1t3 b1t2 b1t1)
2472 HashJoin(b2t4 b2t3)
2473 NestLoop(b2t4 b2t3 b2t2)
2474 MergeJoin(b2t4 b2t3 b2t2 b2t1)
2475 HashJoin(b3t4 b3t3)
2476 NestLoop(b3t4 b3t3 b3t2)
2477 MergeJoin(b3t4 b3t3 b3t2 b3t1)
2478 */
2479 EXPLAIN (COSTS false)
2480 WITH c1 (c1) AS (
2481 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
2482 )
2483 SELECT max(bmt1.c1), (
2484 SELECT max(b2t1.c1) FROM s1.t1 b2t1, s1.t2 b2t2, s1.t3 b2t3, s1.t4 b2t4 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = b2t2.c1 AND b2t2.ctid = '(1,1)' AND b2t1.c1 = b2t3.c1 AND b2t3.ctid = '(1,1)' AND b2t1.c1 = b2t4.c1 AND b2t4.ctid = '(1,1)'
2485 )
2486                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)' AND bmt1.c1 = c1.c1
2487 AND bmt1.c1 <> (
2488 SELECT max(b3t1.c1) FROM s1.t1 b3t1, s1.t2 b3t2, s1.t3 b3t3, s1.t4 b3t4 WHERE b3t1.ctid = '(1,1)' AND b3t1.c1 = b3t2.c1 AND b3t2.ctid = '(1,1)' AND b3t1.c1 = b3t3.c1 AND b3t3.ctid = '(1,1)' AND b3t1.c1 = b3t4.c1 AND b3t4.ctid = '(1,1)'
2489 )
2490 ;
2491 LOG:  pg_hint_plan:
2492 used hint:
2493 HashJoin(b1t3 b1t4)
2494 HashJoin(b2t3 b2t4)
2495 HashJoin(b3t3 b3t4)
2496 MergeJoin(bmt4 c1)
2497 NestLoop(b1t2 b1t3 b1t4)
2498 NestLoop(b2t2 b2t3 b2t4)
2499 NestLoop(b3t2 b3t3 b3t4)
2500 HashJoin(bmt3 bmt4 c1)
2501 MergeJoin(b1t1 b1t2 b1t3 b1t4)
2502 MergeJoin(b2t1 b2t2 b2t3 b2t4)
2503 MergeJoin(b3t1 b3t2 b3t3 b3t4)
2504 NestLoop(bmt2 bmt3 bmt4 c1)
2505 MergeJoin(bmt1 bmt2 bmt3 bmt4 c1)
2506 Leading(c1 bmt4 b1t4 b2t4 b3t4 bmt3 b1t3 b2t3 b3t3 bmt2 b1t2 b2t2 b3t2 bmt1 b1t1 b2t1 b3t1)
2507 not used hint:
2508 duplication hint:
2509 error hint:
2510
2511                                     QUERY PLAN
2512 -----------------------------------------------------------------------------------
2513  Aggregate
2514    CTE c1
2515      ->  Aggregate
2516            ->  Merge Join
2517                  Merge Cond: (b1t2.c1 = b1t1.c1)
2518                  ->  Sort
2519                        Sort Key: b1t2.c1
2520                        ->  Nested Loop
2521                              Join Filter: (b1t3.c1 = b1t2.c1)
2522                              ->  Hash Join
2523                                    Hash Cond: (b1t3.c1 = b1t4.c1)
2524                                    ->  Tid Scan on t3 b1t3
2525                                          TID Cond: (ctid = '(1,1)'::tid)
2526                                    ->  Hash
2527                                          ->  Tid Scan on t4 b1t4
2528                                                TID Cond: (ctid = '(1,1)'::tid)
2529                              ->  Seq Scan on t2 b1t2
2530                                    Filter: (ctid = '(1,1)'::tid)
2531                  ->  Sort
2532                        Sort Key: b1t1.c1
2533                        ->  Tid Scan on t1 b1t1
2534                              TID Cond: (ctid = '(1,1)'::tid)
2535    InitPlan 2 (returns $1)
2536      ->  Aggregate
2537            ->  Merge Join
2538                  Merge Cond: (b2t2.c1 = b2t1.c1)
2539                  ->  Sort
2540                        Sort Key: b2t2.c1
2541                        ->  Nested Loop
2542                              Join Filter: (b2t3.c1 = b2t2.c1)
2543                              ->  Hash Join
2544                                    Hash Cond: (b2t3.c1 = b2t4.c1)
2545                                    ->  Tid Scan on t3 b2t3
2546                                          TID Cond: (ctid = '(1,1)'::tid)
2547                                    ->  Hash
2548                                          ->  Tid Scan on t4 b2t4
2549                                                TID Cond: (ctid = '(1,1)'::tid)
2550                              ->  Seq Scan on t2 b2t2
2551                                    Filter: (ctid = '(1,1)'::tid)
2552                  ->  Sort
2553                        Sort Key: b2t1.c1
2554                        ->  Tid Scan on t1 b2t1
2555                              TID Cond: (ctid = '(1,1)'::tid)
2556    InitPlan 3 (returns $2)
2557      ->  Aggregate
2558            ->  Merge Join
2559                  Merge Cond: (b3t2.c1 = b3t1.c1)
2560                  ->  Sort
2561                        Sort Key: b3t2.c1
2562                        ->  Nested Loop
2563                              Join Filter: (b3t3.c1 = b3t2.c1)
2564                              ->  Hash Join
2565                                    Hash Cond: (b3t3.c1 = b3t4.c1)
2566                                    ->  Tid Scan on t3 b3t3
2567                                          TID Cond: (ctid = '(1,1)'::tid)
2568                                    ->  Hash
2569                                          ->  Tid Scan on t4 b3t4
2570                                                TID Cond: (ctid = '(1,1)'::tid)
2571                              ->  Seq Scan on t2 b3t2
2572                                    Filter: (ctid = '(1,1)'::tid)
2573                  ->  Sort
2574                        Sort Key: b3t1.c1
2575                        ->  Tid Scan on t1 b3t1
2576                              TID Cond: (ctid = '(1,1)'::tid)
2577    ->  Merge Join
2578          Merge Cond: (bmt2.c1 = bmt1.c1)
2579          ->  Sort
2580                Sort Key: bmt2.c1
2581                ->  Nested Loop
2582                      Join Filter: (bmt3.c1 = bmt2.c1)
2583                      ->  Hash Join
2584                            Hash Cond: (bmt3.c1 = bmt4.c1)
2585                            ->  Tid Scan on t3 bmt3
2586                                  TID Cond: (ctid = '(1,1)'::tid)
2587                            ->  Hash
2588                                  ->  Merge Join
2589                                        Merge Cond: (bmt4.c1 = c1.c1)
2590                                        ->  Sort
2591                                              Sort Key: bmt4.c1
2592                                              ->  Tid Scan on t4 bmt4
2593                                                    TID Cond: (ctid = '(1,1)'::tid)
2594                                        ->  Sort
2595                                              Sort Key: c1.c1
2596                                              ->  CTE Scan on c1
2597                      ->  Seq Scan on t2 bmt2
2598                            Filter: (ctid = '(1,1)'::tid)
2599          ->  Sort
2600                Sort Key: bmt1.c1
2601                ->  Tid Scan on t1 bmt1
2602                      TID Cond: (ctid = '(1,1)'::tid)
2603                      Filter: (c1 <> $2)
2604 (91 rows)
2605
2606 -- No. J-2-2-4
2607 EXPLAIN (COSTS false)
2608 WITH c1 (c1) AS (
2609 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
2610 )
2611 SELECT max(bmt1.c1), (
2612 SELECT max(b2t1.c1) FROM s1.t1 b2t1 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = 1
2613 )
2614                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)' AND bmt1.c1 = c1.c1
2615 AND bmt1.c1 <> (
2616 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
2617 )
2618 ;
2619                             QUERY PLAN
2620 -------------------------------------------------------------------
2621  Aggregate
2622    CTE c1
2623      ->  Aggregate
2624            ->  Nested Loop
2625                  Join Filter: (b1t1.c1 = b1t4.c1)
2626                  ->  Nested Loop
2627                        Join Filter: (b1t1.c1 = b1t3.c1)
2628                        ->  Nested Loop
2629                              Join Filter: (b1t1.c1 = b1t2.c1)
2630                              ->  Tid Scan on t1 b1t1
2631                                    TID Cond: (ctid = '(1,1)'::tid)
2632                              ->  Seq Scan on t2 b1t2
2633                                    Filter: (ctid = '(1,1)'::tid)
2634                        ->  Tid Scan on t3 b1t3
2635                              TID Cond: (ctid = '(1,1)'::tid)
2636                  ->  Tid Scan on t4 b1t4
2637                        TID Cond: (ctid = '(1,1)'::tid)
2638    InitPlan 3 (returns $2)
2639      ->  Result
2640            InitPlan 2 (returns $1)
2641              ->  Limit
2642                    ->  Tid Scan on t1 b2t1
2643                          TID Cond: (ctid = '(1,1)'::tid)
2644                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2645    InitPlan 4 (returns $3)
2646      ->  Aggregate
2647            ->  Tid Scan on t1 b3t1
2648                  TID Cond: (ctid = '(1,1)'::tid)
2649    ->  Nested Loop
2650          Join Filter: (bmt1.c1 = c1.c1)
2651          ->  Nested Loop
2652                Join Filter: (bmt1.c1 = bmt4.c1)
2653                ->  Nested Loop
2654                      Join Filter: (bmt1.c1 = bmt3.c1)
2655                      ->  Nested Loop
2656                            Join Filter: (bmt1.c1 = bmt2.c1)
2657                            ->  Tid Scan on t1 bmt1
2658                                  TID Cond: (ctid = '(1,1)'::tid)
2659                                  Filter: (c1 <> $3)
2660                            ->  Seq Scan on t2 bmt2
2661                                  Filter: (ctid = '(1,1)'::tid)
2662                      ->  Tid Scan on t3 bmt3
2663                            TID Cond: (ctid = '(1,1)'::tid)
2664                ->  Tid Scan on t4 bmt4
2665                      TID Cond: (ctid = '(1,1)'::tid)
2666          ->  CTE Scan on c1
2667 (46 rows)
2668
2669 /*+
2670 Leading(c1 bmt4 b1t4 bmt3 b1t3 bmt2 b1t2 bmt1 b1t1 b2t1 b3t1)
2671 MergeJoin(c1 bmt4)
2672 HashJoin(c1 bmt4 bmt3)
2673 NestLoop(c1 bmt4 bmt3 bmt2)
2674 MergeJoin(c1 bmt4 bmt3 bmt2 bmt1)
2675 MergeJoin(b1t4 b1t3)
2676 HashJoin(b1t4 b1t3 b1t2)
2677 NestLoop(b1t4 b1t3 b1t2 b1t1)
2678 */
2679 EXPLAIN (COSTS false)
2680 WITH c1 (c1) AS (
2681 SELECT max(b1t1.c1) FROM s1.t1 b1t1, s1.t2 b1t2, s1.t3 b1t3, s1.t4 b1t4 WHERE b1t1.ctid = '(1,1)' AND b1t1.c1 = b1t2.c1 AND b1t2.ctid = '(1,1)' AND b1t1.c1 = b1t3.c1 AND b1t3.ctid = '(1,1)' AND b1t1.c1 = b1t4.c1 AND b1t4.ctid = '(1,1)'
2682 )
2683 SELECT max(bmt1.c1), (
2684 SELECT max(b2t1.c1) FROM s1.t1 b2t1 WHERE b2t1.ctid = '(1,1)' AND b2t1.c1 = 1
2685 )
2686                     FROM s1.t1 bmt1, s1.t2 bmt2, s1.t3 bmt3, s1.t4 bmt4, c1 WHERE bmt1.ctid = '(1,1)' AND bmt1.c1 = bmt2.c1 AND bmt2.ctid = '(1,1)' AND bmt1.c1 = bmt3.c1 AND bmt3.ctid = '(1,1)' AND bmt1.c1 = bmt4.c1 AND bmt4.ctid = '(1,1)' AND bmt1.c1 = c1.c1
2687 AND bmt1.c1 <> (
2688 SELECT max(b3t1.c1) FROM s1.t1 b3t1 WHERE b3t1.ctid = '(1,1)'
2689 )
2690 ;
2691 LOG:  pg_hint_plan:
2692 used hint:
2693 MergeJoin(b1t3 b1t4)
2694 MergeJoin(bmt4 c1)
2695 HashJoin(b1t2 b1t3 b1t4)
2696 HashJoin(bmt3 bmt4 c1)
2697 NestLoop(b1t1 b1t2 b1t3 b1t4)
2698 NestLoop(bmt2 bmt3 bmt4 c1)
2699 MergeJoin(bmt1 bmt2 bmt3 bmt4 c1)
2700 Leading(c1 bmt4 b1t4 bmt3 b1t3 bmt2 b1t2 bmt1 b1t1 b2t1 b3t1)
2701 not used hint:
2702 duplication hint:
2703 error hint:
2704
2705                                     QUERY PLAN
2706 -----------------------------------------------------------------------------------
2707  Aggregate
2708    CTE c1
2709      ->  Aggregate
2710            ->  Nested Loop
2711                  Join Filter: (b1t2.c1 = b1t1.c1)
2712                  ->  Hash Join
2713                        Hash Cond: (b1t2.c1 = b1t3.c1)
2714                        ->  Seq Scan on t2 b1t2
2715                              Filter: (ctid = '(1,1)'::tid)
2716                        ->  Hash
2717                              ->  Merge Join
2718                                    Merge Cond: (b1t3.c1 = b1t4.c1)
2719                                    ->  Sort
2720                                          Sort Key: b1t3.c1
2721                                          ->  Tid Scan on t3 b1t3
2722                                                TID Cond: (ctid = '(1,1)'::tid)
2723                                    ->  Sort
2724                                          Sort Key: b1t4.c1
2725                                          ->  Tid Scan on t4 b1t4
2726                                                TID Cond: (ctid = '(1,1)'::tid)
2727                  ->  Tid Scan on t1 b1t1
2728                        TID Cond: (ctid = '(1,1)'::tid)
2729    InitPlan 3 (returns $2)
2730      ->  Result
2731            InitPlan 2 (returns $1)
2732              ->  Limit
2733                    ->  Tid Scan on t1 b2t1
2734                          TID Cond: (ctid = '(1,1)'::tid)
2735                          Filter: ((c1 IS NOT NULL) AND (c1 = 1))
2736    InitPlan 4 (returns $3)
2737      ->  Aggregate
2738            ->  Tid Scan on t1 b3t1
2739                  TID Cond: (ctid = '(1,1)'::tid)
2740    ->  Merge Join
2741          Merge Cond: (bmt2.c1 = bmt1.c1)
2742          ->  Sort
2743                Sort Key: bmt2.c1
2744                ->  Nested Loop
2745                      Join Filter: (bmt3.c1 = bmt2.c1)
2746                      ->  Hash Join
2747                            Hash Cond: (bmt3.c1 = bmt4.c1)
2748                            ->  Tid Scan on t3 bmt3
2749                                  TID Cond: (ctid = '(1,1)'::tid)
2750                            ->  Hash
2751                                  ->  Merge Join
2752                                        Merge Cond: (bmt4.c1 = c1.c1)
2753                                        ->  Sort
2754                                              Sort Key: bmt4.c1
2755                                              ->  Tid Scan on t4 bmt4
2756                                                    TID Cond: (ctid = '(1,1)'::tid)
2757                                        ->  Sort
2758                                              Sort Key: c1.c1
2759                                              ->  CTE Scan on c1
2760                      ->  Seq Scan on t2 bmt2
2761                            Filter: (ctid = '(1,1)'::tid)
2762          ->  Sort
2763                Sort Key: bmt1.c1
2764                ->  Tid Scan on t1 bmt1
2765                      TID Cond: (ctid = '(1,1)'::tid)
2766                      Filter: (c1 <> $3)
2767 (60 rows)
2768
2769 ----
2770 ---- No. J-2-3 RULE or VIEW
2771 ----
2772 -- No. J-2-3-1
2773 EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2774                            QUERY PLAN
2775 -----------------------------------------------------------------
2776  Aggregate
2777    ->  Nested Loop
2778          Join Filter: (t1.c1 = t4.c1)
2779          ->  Nested Loop
2780                Join Filter: (t1.c1 = t3.c1)
2781                ->  Nested Loop
2782                      Join Filter: (t1.c1 = t2.c1)
2783                      ->  Nested Loop
2784                            ->  Tid Scan on r1
2785                                  TID Cond: (ctid = '(1,1)'::tid)
2786                                  Filter: (c1 = 1)
2787                            ->  Tid Scan on t1
2788                                  TID Cond: (ctid = '(1,1)'::tid)
2789                      ->  Seq Scan on t2
2790                            Filter: (ctid = '(1,1)'::tid)
2791                ->  Tid Scan on t3
2792                      TID Cond: (ctid = '(1,1)'::tid)
2793          ->  Tid Scan on t4
2794                TID Cond: (ctid = '(1,1)'::tid)
2795 (19 rows)
2796
2797 /*+
2798 Leading(t4 t3 t2 t1 r1)
2799 MergeJoin(t4 t3 t2 t1 r1)
2800 HashJoin(t4 t3 t2 t1)
2801 NestLoop(t4 t3 t2)
2802 MergeJoin(t4 t3)
2803 */
2804 EXPLAIN (COSTS false) UPDATE s1.r1 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2805 LOG:  pg_hint_plan:
2806 used hint:
2807 MergeJoin(t3 t4)
2808 NestLoop(t2 t3 t4)
2809 HashJoin(t1 t2 t3 t4)
2810 MergeJoin(r1 t1 t2 t3 t4)
2811 Leading(t4 t3 t2 t1 r1)
2812 not used hint:
2813 duplication hint:
2814 error hint:
2815
2816                                  QUERY PLAN
2817 -----------------------------------------------------------------------------
2818  Aggregate
2819    ->  Nested Loop
2820          ->  Hash Join
2821                Hash Cond: (t1.c1 = t2.c1)
2822                ->  Tid Scan on t1
2823                      TID Cond: (ctid = '(1,1)'::tid)
2824                ->  Hash
2825                      ->  Nested Loop
2826                            Join Filter: (t3.c1 = t2.c1)
2827                            ->  Merge Join
2828                                  Merge Cond: (t3.c1 = t4.c1)
2829                                  ->  Sort
2830                                        Sort Key: t3.c1
2831                                        ->  Tid Scan on t3
2832                                              TID Cond: (ctid = '(1,1)'::tid)
2833                                  ->  Sort
2834                                        Sort Key: t4.c1
2835                                        ->  Tid Scan on t4
2836                                              TID Cond: (ctid = '(1,1)'::tid)
2837                            ->  Seq Scan on t2
2838                                  Filter: (ctid = '(1,1)'::tid)
2839          ->  Tid Scan on r1
2840                TID Cond: (ctid = '(1,1)'::tid)
2841                Filter: (c1 = 1)
2842 (24 rows)
2843
2844 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2845                            QUERY PLAN
2846 -----------------------------------------------------------------
2847  Aggregate
2848    ->  Nested Loop
2849          Join Filter: (b1t1.c1 = b1t4.c1)
2850          ->  Nested Loop
2851                Join Filter: (b1t1.c1 = b1t3.c1)
2852                ->  Nested Loop
2853                      Join Filter: (b1t1.c1 = b1t2.c1)
2854                      ->  Nested Loop
2855                            ->  Tid Scan on r1_
2856                                  TID Cond: (ctid = '(1,1)'::tid)
2857                                  Filter: (c1 = 1)
2858                            ->  Tid Scan on t1 b1t1
2859                                  TID Cond: (ctid = '(1,1)'::tid)
2860                      ->  Seq Scan on t2 b1t2
2861                            Filter: (ctid = '(1,1)'::tid)
2862                ->  Tid Scan on t3 b1t3
2863                      TID Cond: (ctid = '(1,1)'::tid)
2864          ->  Tid Scan on t4 b1t4
2865                TID Cond: (ctid = '(1,1)'::tid)
2866 (19 rows)
2867
2868 /*+
2869 Leading(b1t4 b1t3 b1t2 b1t1 r1_)
2870 MergeJoin(b1t4 b1t3 b1t2 b1t1 r1_)
2871 HashJoin(b1t4 b1t3 b1t2 b1t1)
2872 NestLoop(b1t4 b1t3 b1t2)
2873 MergeJoin(b1t4 b1t3)
2874 */
2875 EXPLAIN (COSTS false) UPDATE s1.r1_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2876 LOG:  pg_hint_plan:
2877 used hint:
2878 MergeJoin(b1t3 b1t4)
2879 NestLoop(b1t2 b1t3 b1t4)
2880 HashJoin(b1t1 b1t2 b1t3 b1t4)
2881 MergeJoin(b1t1 b1t2 b1t3 b1t4 r1_)
2882 Leading(b1t4 b1t3 b1t2 b1t1 r1_)
2883 not used hint:
2884 duplication hint:
2885 error hint:
2886
2887                                  QUERY PLAN
2888 -----------------------------------------------------------------------------
2889  Aggregate
2890    ->  Nested Loop
2891          ->  Hash Join
2892                Hash Cond: (b1t1.c1 = b1t2.c1)
2893                ->  Tid Scan on t1 b1t1
2894                      TID Cond: (ctid = '(1,1)'::tid)
2895                ->  Hash
2896                      ->  Nested Loop
2897                            Join Filter: (b1t3.c1 = b1t2.c1)
2898                            ->  Merge Join
2899                                  Merge Cond: (b1t3.c1 = b1t4.c1)
2900                                  ->  Sort
2901                                        Sort Key: b1t3.c1
2902                                        ->  Tid Scan on t3 b1t3
2903                                              TID Cond: (ctid = '(1,1)'::tid)
2904                                  ->  Sort
2905                                        Sort Key: b1t4.c1
2906                                        ->  Tid Scan on t4 b1t4
2907                                              TID Cond: (ctid = '(1,1)'::tid)
2908                            ->  Seq Scan on t2 b1t2
2909                                  Filter: (ctid = '(1,1)'::tid)
2910          ->  Tid Scan on r1_
2911                TID Cond: (ctid = '(1,1)'::tid)
2912                Filter: (c1 = 1)
2913 (24 rows)
2914
2915 -- No. J-2-3-2
2916 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2917                            QUERY PLAN
2918 -----------------------------------------------------------------
2919  Aggregate
2920    ->  Nested Loop
2921          Join Filter: (t1.c1 = t4.c1)
2922          ->  Nested Loop
2923                Join Filter: (t1.c1 = t3.c1)
2924                ->  Nested Loop
2925                      Join Filter: (t1.c1 = t2.c1)
2926                      ->  Nested Loop
2927                            ->  Tid Scan on r2
2928                                  TID Cond: (ctid = '(1,1)'::tid)
2929                                  Filter: (c1 = 1)
2930                            ->  Tid Scan on t1
2931                                  TID Cond: (ctid = '(1,1)'::tid)
2932                      ->  Seq Scan on t2
2933                            Filter: (ctid = '(1,1)'::tid)
2934                ->  Tid Scan on t3
2935                      TID Cond: (ctid = '(1,1)'::tid)
2936          ->  Tid Scan on t4
2937                TID Cond: (ctid = '(1,1)'::tid)
2938
2939  Aggregate
2940    ->  Nested Loop
2941          Join Filter: (t1.c1 = t4.c1)
2942          ->  Nested Loop
2943                Join Filter: (t1.c1 = t3.c1)
2944                ->  Nested Loop
2945                      Join Filter: (t1.c1 = t2.c1)
2946                      ->  Nested Loop
2947                            ->  Tid Scan on r2
2948                                  TID Cond: (ctid = '(1,1)'::tid)
2949                                  Filter: (c1 = 1)
2950                            ->  Tid Scan on t1
2951                                  TID Cond: (ctid = '(1,1)'::tid)
2952                      ->  Seq Scan on t2
2953                            Filter: (ctid = '(1,1)'::tid)
2954                ->  Tid Scan on t3
2955                      TID Cond: (ctid = '(1,1)'::tid)
2956          ->  Tid Scan on t4
2957                TID Cond: (ctid = '(1,1)'::tid)
2958 (39 rows)
2959
2960 /*+
2961 Leading(t4 t3 t2 t1 r2)
2962 MergeJoin(t4 t3 t2 t1 r2)
2963 HashJoin(t4 t3 t2 t1)
2964 NestLoop(t4 t3 t2)
2965 MergeJoin(t4 t3)
2966 */
2967 EXPLAIN (COSTS false) UPDATE s1.r2 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
2968 LOG:  pg_hint_plan:
2969 used hint:
2970 MergeJoin(t3 t4)
2971 NestLoop(t2 t3 t4)
2972 HashJoin(t1 t2 t3 t4)
2973 MergeJoin(r2 t1 t2 t3 t4)
2974 Leading(t4 t3 t2 t1 r2)
2975 not used hint:
2976 duplication hint:
2977 error hint:
2978
2979 LOG:  pg_hint_plan:
2980 used hint:
2981 MergeJoin(t3 t4)
2982 NestLoop(t2 t3 t4)
2983 HashJoin(t1 t2 t3 t4)
2984 MergeJoin(r2 t1 t2 t3 t4)
2985 Leading(t4 t3 t2 t1 r2)
2986 not used hint:
2987 duplication hint:
2988 error hint:
2989
2990                                  QUERY PLAN
2991 -----------------------------------------------------------------------------
2992  Aggregate
2993    ->  Nested Loop
2994          ->  Hash Join
2995                Hash Cond: (t1.c1 = t2.c1)
2996                ->  Tid Scan on t1
2997                      TID Cond: (ctid = '(1,1)'::tid)
2998                ->  Hash
2999                      ->  Nested Loop
3000                            Join Filter: (t3.c1 = t2.c1)
3001                            ->  Merge Join
3002                                  Merge Cond: (t3.c1 = t4.c1)
3003                                  ->  Sort
3004                                        Sort Key: t3.c1
3005                                        ->  Tid Scan on t3
3006                                              TID Cond: (ctid = '(1,1)'::tid)
3007                                  ->  Sort
3008                                        Sort Key: t4.c1
3009                                        ->  Tid Scan on t4
3010                                              TID Cond: (ctid = '(1,1)'::tid)
3011                            ->  Seq Scan on t2
3012                                  Filter: (ctid = '(1,1)'::tid)
3013          ->  Tid Scan on r2
3014                TID Cond: (ctid = '(1,1)'::tid)
3015                Filter: (c1 = 1)
3016
3017  Aggregate
3018    ->  Nested Loop
3019          ->  Hash Join
3020                Hash Cond: (t1.c1 = t2.c1)
3021                ->  Tid Scan on t1
3022                      TID Cond: (ctid = '(1,1)'::tid)
3023                ->  Hash
3024                      ->  Nested Loop
3025                            Join Filter: (t3.c1 = t2.c1)
3026                            ->  Merge Join
3027                                  Merge Cond: (t3.c1 = t4.c1)
3028                                  ->  Sort
3029                                        Sort Key: t3.c1
3030                                        ->  Tid Scan on t3
3031                                              TID Cond: (ctid = '(1,1)'::tid)
3032                                  ->  Sort
3033                                        Sort Key: t4.c1
3034                                        ->  Tid Scan on t4
3035                                              TID Cond: (ctid = '(1,1)'::tid)
3036                            ->  Seq Scan on t2
3037                                  Filter: (ctid = '(1,1)'::tid)
3038          ->  Tid Scan on r2
3039                TID Cond: (ctid = '(1,1)'::tid)
3040                Filter: (c1 = 1)
3041 (49 rows)
3042
3043 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3044                            QUERY PLAN
3045 -----------------------------------------------------------------
3046  Aggregate
3047    ->  Nested Loop
3048          Join Filter: (b1t1.c1 = b1t4.c1)
3049          ->  Nested Loop
3050                Join Filter: (b1t1.c1 = b1t3.c1)
3051                ->  Nested Loop
3052                      Join Filter: (b1t1.c1 = b1t2.c1)
3053                      ->  Nested Loop
3054                            ->  Tid Scan on r2_
3055                                  TID Cond: (ctid = '(1,1)'::tid)
3056                                  Filter: (c1 = 1)
3057                            ->  Tid Scan on t1 b1t1
3058                                  TID Cond: (ctid = '(1,1)'::tid)
3059                      ->  Seq Scan on t2 b1t2
3060                            Filter: (ctid = '(1,1)'::tid)
3061                ->  Tid Scan on t3 b1t3
3062                      TID Cond: (ctid = '(1,1)'::tid)
3063          ->  Tid Scan on t4 b1t4
3064                TID Cond: (ctid = '(1,1)'::tid)
3065
3066  Aggregate
3067    ->  Nested Loop
3068          Join Filter: (b2t1.c1 = b2t4.c1)
3069          ->  Nested Loop
3070                Join Filter: (b2t1.c1 = b2t3.c1)
3071                ->  Nested Loop
3072                      Join Filter: (b2t1.c1 = b2t2.c1)
3073                      ->  Nested Loop
3074                            ->  Tid Scan on r2_
3075                                  TID Cond: (ctid = '(1,1)'::tid)
3076                                  Filter: (c1 = 1)
3077                            ->  Tid Scan on t1 b2t1
3078                                  TID Cond: (ctid = '(1,1)'::tid)
3079                      ->  Seq Scan on t2 b2t2
3080                            Filter: (ctid = '(1,1)'::tid)
3081                ->  Tid Scan on t3 b2t3
3082                      TID Cond: (ctid = '(1,1)'::tid)
3083          ->  Tid Scan on t4 b2t4
3084                TID Cond: (ctid = '(1,1)'::tid)
3085 (39 rows)
3086
3087 /*+Leading(
3088 b1t1 b1t2 b1t3 b1t4
3089 b2t1 b2t2 b2t3 b2t4 r2_
3090 )
3091 MergeJoin(b1t1 b1t2)
3092 HashJoin(b1t1 b1t2 b1t3)
3093 NestLoop(b1t1 b1t2 b1t3 b1t4)
3094 MergeJoin(b1t1 b1t2 b1t3 b1t4 r2_)
3095 MergeJoin(b2t1 b2t2)
3096 HashJoin(b2t1 b2t2 b2t3)
3097 NestLoop(b2t1 b2t2 b2t3 b2t4)
3098 MergeJoin(b2t1 b2t2 b2t3 b2t4 r2_)
3099 */
3100 EXPLAIN (COSTS false) UPDATE s1.r2_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3101 LOG:  pg_hint_plan:
3102 used hint:
3103 MergeJoin(b1t1 b1t2)
3104 HashJoin(b1t1 b1t2 b1t3)
3105 NestLoop(b1t1 b1t2 b1t3 b1t4)
3106 MergeJoin(b1t1 b1t2 b1t3 b1t4 r2_)
3107 Leading(b1t1 b1t2 b1t3 b1t4 b2t1 b2t2 b2t3 b2t4 r2_)
3108 not used hint:
3109 MergeJoin(b2t1 b2t2)
3110 HashJoin(b2t1 b2t2 b2t3)
3111 NestLoop(b2t1 b2t2 b2t3 b2t4)
3112 MergeJoin(b2t1 b2t2 b2t3 b2t4 r2_)
3113 duplication hint:
3114 error hint:
3115
3116 LOG:  pg_hint_plan:
3117 used hint:
3118 MergeJoin(b2t1 b2t2)
3119 HashJoin(b2t1 b2t2 b2t3)
3120 NestLoop(b2t1 b2t2 b2t3 b2t4)
3121 MergeJoin(b2t1 b2t2 b2t3 b2t4 r2_)
3122 Leading(b1t1 b1t2 b1t3 b1t4 b2t1 b2t2 b2t3 b2t4 r2_)
3123 not used hint:
3124 MergeJoin(b1t1 b1t2)
3125 HashJoin(b1t1 b1t2 b1t3)
3126 NestLoop(b1t1 b1t2 b1t3 b1t4)
3127 MergeJoin(b1t1 b1t2 b1t3 b1t4 r2_)
3128 duplication hint:
3129 error hint:
3130
3131                                  QUERY PLAN
3132 -----------------------------------------------------------------------------
3133  Aggregate
3134    ->  Nested Loop
3135          ->  Nested Loop
3136                Join Filter: (b1t1.c1 = b1t4.c1)
3137                ->  Hash Join
3138                      Hash Cond: (b1t3.c1 = b1t1.c1)
3139                      ->  Tid Scan on t3 b1t3
3140                            TID Cond: (ctid = '(1,1)'::tid)
3141                      ->  Hash
3142                            ->  Merge Join
3143                                  Merge Cond: (b1t1.c1 = b1t2.c1)
3144                                  ->  Sort
3145                                        Sort Key: b1t1.c1
3146                                        ->  Tid Scan on t1 b1t1
3147                                              TID Cond: (ctid = '(1,1)'::tid)
3148                                  ->  Sort
3149                                        Sort Key: b1t2.c1
3150                                        ->  Seq Scan on t2 b1t2
3151                                              Filter: (ctid = '(1,1)'::tid)
3152                ->  Tid Scan on t4 b1t4
3153                      TID Cond: (ctid = '(1,1)'::tid)
3154          ->  Tid Scan on r2_
3155                TID Cond: (ctid = '(1,1)'::tid)
3156                Filter: (c1 = 1)
3157
3158  Aggregate
3159    ->  Nested Loop
3160          ->  Nested Loop
3161                Join Filter: (b2t1.c1 = b2t4.c1)
3162                ->  Hash Join
3163                      Hash Cond: (b2t3.c1 = b2t1.c1)
3164                      ->  Tid Scan on t3 b2t3
3165                            TID Cond: (ctid = '(1,1)'::tid)
3166                      ->  Hash
3167                            ->  Merge Join
3168                                  Merge Cond: (b2t1.c1 = b2t2.c1)
3169                                  ->  Sort
3170                                        Sort Key: b2t1.c1
3171                                        ->  Tid Scan on t1 b2t1
3172                                              TID Cond: (ctid = '(1,1)'::tid)
3173                                  ->  Sort
3174                                        Sort Key: b2t2.c1
3175                                        ->  Seq Scan on t2 b2t2
3176                                              Filter: (ctid = '(1,1)'::tid)
3177                ->  Tid Scan on t4 b2t4
3178                      TID Cond: (ctid = '(1,1)'::tid)
3179          ->  Tid Scan on r2_
3180                TID Cond: (ctid = '(1,1)'::tid)
3181                Filter: (c1 = 1)
3182 (49 rows)
3183
3184 -- No. J-2-3-3
3185 EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3186                            QUERY PLAN
3187 -----------------------------------------------------------------
3188  Aggregate
3189    ->  Nested Loop
3190          Join Filter: (t1.c1 = t4.c1)
3191          ->  Nested Loop
3192                Join Filter: (t1.c1 = t3.c1)
3193                ->  Nested Loop
3194                      Join Filter: (t1.c1 = t2.c1)
3195                      ->  Nested Loop
3196                            ->  Tid Scan on r3
3197                                  TID Cond: (ctid = '(1,1)'::tid)
3198                                  Filter: (c1 = 1)
3199                            ->  Tid Scan on t1
3200                                  TID Cond: (ctid = '(1,1)'::tid)
3201                      ->  Seq Scan on t2
3202                            Filter: (ctid = '(1,1)'::tid)
3203                ->  Tid Scan on t3
3204                      TID Cond: (ctid = '(1,1)'::tid)
3205          ->  Tid Scan on t4
3206                TID Cond: (ctid = '(1,1)'::tid)
3207
3208  Aggregate
3209    ->  Nested Loop
3210          Join Filter: (t1.c1 = t4.c1)
3211          ->  Nested Loop
3212                Join Filter: (t1.c1 = t3.c1)
3213                ->  Nested Loop
3214                      Join Filter: (t1.c1 = t2.c1)
3215                      ->  Nested Loop
3216                            ->  Tid Scan on r3
3217                                  TID Cond: (ctid = '(1,1)'::tid)
3218                                  Filter: (c1 = 1)
3219                            ->  Tid Scan on t1
3220                                  TID Cond: (ctid = '(1,1)'::tid)
3221                      ->  Seq Scan on t2
3222                            Filter: (ctid = '(1,1)'::tid)
3223                ->  Tid Scan on t3
3224                      TID Cond: (ctid = '(1,1)'::tid)
3225          ->  Tid Scan on t4
3226                TID Cond: (ctid = '(1,1)'::tid)
3227
3228  Aggregate
3229    ->  Nested Loop
3230          Join Filter: (t1.c1 = t4.c1)
3231          ->  Nested Loop
3232                Join Filter: (t1.c1 = t3.c1)
3233                ->  Nested Loop
3234                      Join Filter: (t1.c1 = t2.c1)
3235                      ->  Nested Loop
3236                            ->  Tid Scan on r3
3237                                  TID Cond: (ctid = '(1,1)'::tid)
3238                                  Filter: (c1 = 1)
3239                            ->  Tid Scan on t1
3240                                  TID Cond: (ctid = '(1,1)'::tid)
3241                      ->  Seq Scan on t2
3242                            Filter: (ctid = '(1,1)'::tid)
3243                ->  Tid Scan on t3
3244                      TID Cond: (ctid = '(1,1)'::tid)
3245          ->  Tid Scan on t4
3246                TID Cond: (ctid = '(1,1)'::tid)
3247 (59 rows)
3248
3249 /*+
3250 Leading(t4 t3 t2 t1 r3)
3251 MergeJoin(t4 t3 t2 t1 r3)
3252 HashJoin(t4 t3 t2 t1)
3253 NestLoop(t4 t3 t2)
3254 MergeJoin(t4 t3)
3255 */
3256 EXPLAIN (COSTS false) UPDATE s1.r3 SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3257 LOG:  pg_hint_plan:
3258 used hint:
3259 MergeJoin(t3 t4)
3260 NestLoop(t2 t3 t4)
3261 HashJoin(t1 t2 t3 t4)
3262 MergeJoin(r3 t1 t2 t3 t4)
3263 Leading(t4 t3 t2 t1 r3)
3264 not used hint:
3265 duplication hint:
3266 error hint:
3267
3268 LOG:  pg_hint_plan:
3269 used hint:
3270 MergeJoin(t3 t4)
3271 NestLoop(t2 t3 t4)
3272 HashJoin(t1 t2 t3 t4)
3273 MergeJoin(r3 t1 t2 t3 t4)
3274 Leading(t4 t3 t2 t1 r3)
3275 not used hint:
3276 duplication hint:
3277 error hint:
3278
3279 LOG:  pg_hint_plan:
3280 used hint:
3281 MergeJoin(t3 t4)
3282 NestLoop(t2 t3 t4)
3283 HashJoin(t1 t2 t3 t4)
3284 MergeJoin(r3 t1 t2 t3 t4)
3285 Leading(t4 t3 t2 t1 r3)
3286 not used hint:
3287 duplication hint:
3288 error hint:
3289
3290                                  QUERY PLAN
3291 -----------------------------------------------------------------------------
3292  Aggregate
3293    ->  Nested Loop
3294          ->  Hash Join
3295                Hash Cond: (t1.c1 = t2.c1)
3296                ->  Tid Scan on t1
3297                      TID Cond: (ctid = '(1,1)'::tid)
3298                ->  Hash
3299                      ->  Nested Loop
3300                            Join Filter: (t3.c1 = t2.c1)
3301                            ->  Merge Join
3302                                  Merge Cond: (t3.c1 = t4.c1)
3303                                  ->  Sort
3304                                        Sort Key: t3.c1
3305                                        ->  Tid Scan on t3
3306                                              TID Cond: (ctid = '(1,1)'::tid)
3307                                  ->  Sort
3308                                        Sort Key: t4.c1
3309                                        ->  Tid Scan on t4
3310                                              TID Cond: (ctid = '(1,1)'::tid)
3311                            ->  Seq Scan on t2
3312                                  Filter: (ctid = '(1,1)'::tid)
3313          ->  Tid Scan on r3
3314                TID Cond: (ctid = '(1,1)'::tid)
3315                Filter: (c1 = 1)
3316
3317  Aggregate
3318    ->  Nested Loop
3319          ->  Hash Join
3320                Hash Cond: (t1.c1 = t2.c1)
3321                ->  Tid Scan on t1
3322                      TID Cond: (ctid = '(1,1)'::tid)
3323                ->  Hash
3324                      ->  Nested Loop
3325                            Join Filter: (t3.c1 = t2.c1)
3326                            ->  Merge Join
3327                                  Merge Cond: (t3.c1 = t4.c1)
3328                                  ->  Sort
3329                                        Sort Key: t3.c1
3330                                        ->  Tid Scan on t3
3331                                              TID Cond: (ctid = '(1,1)'::tid)
3332                                  ->  Sort
3333                                        Sort Key: t4.c1
3334                                        ->  Tid Scan on t4
3335                                              TID Cond: (ctid = '(1,1)'::tid)
3336                            ->  Seq Scan on t2
3337                                  Filter: (ctid = '(1,1)'::tid)
3338          ->  Tid Scan on r3
3339                TID Cond: (ctid = '(1,1)'::tid)
3340                Filter: (c1 = 1)
3341
3342  Aggregate
3343    ->  Nested Loop
3344          ->  Hash Join
3345                Hash Cond: (t1.c1 = t2.c1)
3346                ->  Tid Scan on t1
3347                      TID Cond: (ctid = '(1,1)'::tid)
3348                ->  Hash
3349                      ->  Nested Loop
3350                            Join Filter: (t3.c1 = t2.c1)
3351                            ->  Merge Join
3352                                  Merge Cond: (t3.c1 = t4.c1)
3353                                  ->  Sort
3354                                        Sort Key: t3.c1
3355                                        ->  Tid Scan on t3
3356                                              TID Cond: (ctid = '(1,1)'::tid)
3357                                  ->  Sort
3358                                        Sort Key: t4.c1
3359                                        ->  Tid Scan on t4
3360                                              TID Cond: (ctid = '(1,1)'::tid)
3361                            ->  Seq Scan on t2
3362                                  Filter: (ctid = '(1,1)'::tid)
3363          ->  Tid Scan on r3
3364                TID Cond: (ctid = '(1,1)'::tid)
3365                Filter: (c1 = 1)
3366 (74 rows)
3367
3368 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3369                            QUERY PLAN
3370 -----------------------------------------------------------------
3371  Aggregate
3372    ->  Nested Loop
3373          Join Filter: (b1t1.c1 = b1t4.c1)
3374          ->  Nested Loop
3375                Join Filter: (b1t1.c1 = b1t3.c1)
3376                ->  Nested Loop
3377                      Join Filter: (b1t1.c1 = b1t2.c1)
3378                      ->  Nested Loop
3379                            ->  Tid Scan on r3_
3380                                  TID Cond: (ctid = '(1,1)'::tid)
3381                                  Filter: (c1 = 1)
3382                            ->  Tid Scan on t1 b1t1
3383                                  TID Cond: (ctid = '(1,1)'::tid)
3384                      ->  Seq Scan on t2 b1t2
3385                            Filter: (ctid = '(1,1)'::tid)
3386                ->  Tid Scan on t3 b1t3
3387                      TID Cond: (ctid = '(1,1)'::tid)
3388          ->  Tid Scan on t4 b1t4
3389                TID Cond: (ctid = '(1,1)'::tid)
3390
3391  Aggregate
3392    ->  Nested Loop
3393          Join Filter: (b2t1.c1 = b2t4.c1)
3394          ->  Nested Loop
3395                Join Filter: (b2t1.c1 = b2t3.c1)
3396                ->  Nested Loop
3397                      Join Filter: (b2t1.c1 = b2t2.c1)
3398                      ->  Nested Loop
3399                            ->  Tid Scan on r3_
3400                                  TID Cond: (ctid = '(1,1)'::tid)
3401                                  Filter: (c1 = 1)
3402                            ->  Tid Scan on t1 b2t1
3403                                  TID Cond: (ctid = '(1,1)'::tid)
3404                      ->  Seq Scan on t2 b2t2
3405                            Filter: (ctid = '(1,1)'::tid)
3406                ->  Tid Scan on t3 b2t3
3407                      TID Cond: (ctid = '(1,1)'::tid)
3408          ->  Tid Scan on t4 b2t4
3409                TID Cond: (ctid = '(1,1)'::tid)
3410
3411  Aggregate
3412    ->  Nested Loop
3413          Join Filter: (b3t1.c1 = b3t4.c1)
3414          ->  Nested Loop
3415                Join Filter: (b3t1.c1 = b3t3.c1)
3416                ->  Nested Loop
3417                      Join Filter: (b3t1.c1 = b3t2.c1)
3418                      ->  Nested Loop
3419                            ->  Tid Scan on r3_
3420                                  TID Cond: (ctid = '(1,1)'::tid)
3421                                  Filter: (c1 = 1)
3422                            ->  Tid Scan on t1 b3t1
3423                                  TID Cond: (ctid = '(1,1)'::tid)
3424                      ->  Seq Scan on t2 b3t2
3425                            Filter: (ctid = '(1,1)'::tid)
3426                ->  Tid Scan on t3 b3t3
3427                      TID Cond: (ctid = '(1,1)'::tid)
3428          ->  Tid Scan on t4 b3t4
3429                TID Cond: (ctid = '(1,1)'::tid)
3430 (59 rows)
3431
3432 /*+Leading(
3433 b1t1 b1t2 b1t3 b1t4
3434 b2t1 b2t2 b2t3 b2t4
3435 b3t1 b3t2 b3t3 b3t4 r3_
3436 )
3437 MergeJoin(b1t1 b1t2)
3438 HashJoin(b1t1 b1t2 b1t3)
3439 NestLoop(b1t1 b1t2 b1t3 b1t4)
3440 MergeJoin(b1t1 b1t2 b1t3 b1t4 r3_)
3441 MergeJoin(b2t1 b2t2)
3442 HashJoin(b2t1 b2t2 b2t3)
3443 NestLoop(b2t1 b2t2 b2t3 b2t4)
3444 MergeJoin(b2t1 b2t2 b2t3 b2t4 r3_)
3445 MergeJoin(b3t1 b3t2)
3446 HashJoin(b3t1 b3t2 b3t3)
3447 NestLoop(b3t1 b3t2 b3t3 b3t4)
3448 MergeJoin(b3t1 b3t2 b3t3 b3t4 r3_)
3449 */
3450 EXPLAIN (COSTS false) UPDATE s1.r3_ SET c1 = c1 WHERE c1 = 1 AND ctid = '(1,1)';
3451 LOG:  pg_hint_plan:
3452 used hint:
3453 MergeJoin(b1t1 b1t2)
3454 HashJoin(b1t1 b1t2 b1t3)
3455 NestLoop(b1t1 b1t2 b1t3 b1t4)
3456 MergeJoin(b1t1 b1t2 b1t3 b1t4 r3_)
3457 Leading(b1t1 b1t2 b1t3 b1t4 b2t1 b2t2 b2t3 b2t4 b3t1 b3t2 b3t3 b3t4 r3_)
3458 not used hint:
3459 MergeJoin(b2t1 b2t2)
3460 MergeJoin(b3t1 b3t2)
3461 HashJoin(b2t1 b2t2 b2t3)
3462 HashJoin(b3t1 b3t2 b3t3)
3463 NestLoop(b2t1 b2t2 b2t3 b2t4)
3464 NestLoop(b3t1 b3t2 b3t3 b3t4)
3465 MergeJoin(b2t1 b2t2 b2t3 b2t4 r3_)
3466 MergeJoin(b3t1 b3t2 b3t3 b3t4 r3_)
3467 duplication hint:
3468 error hint:
3469
3470 LOG:  pg_hint_plan:
3471 used hint:
3472 MergeJoin(b2t1 b2t2)
3473 HashJoin(b2t1 b2t2 b2t3)
3474 NestLoop(b2t1 b2t2 b2t3 b2t4)
3475 MergeJoin(b2t1 b2t2 b2t3 b2t4 r3_)
3476 Leading(b1t1 b1t2 b1t3 b1t4 b2t1 b2t2 b2t3 b2t4 b3t1 b3t2 b3t3 b3t4 r3_)
3477 not used hint:
3478 MergeJoin(b1t1 b1t2)
3479 MergeJoin(b3t1 b3t2)
3480 HashJoin(b1t1 b1t2 b1t3)
3481 HashJoin(b3t1 b3t2 b3t3)
3482 NestLoop(b1t1 b1t2 b1t3 b1t4)
3483 NestLoop(b3t1 b3t2 b3t3 b3t4)
3484 MergeJoin(b1t1 b1t2 b1t3 b1t4 r3_)
3485 MergeJoin(b3t1 b3t2 b3t3 b3t4 r3_)
3486 duplication hint:
3487 error hint:
3488
3489 LOG:  pg_hint_plan:
3490 used hint:
3491 MergeJoin(b3t1 b3t2)
3492 HashJoin(b3t1 b3t2 b3t3)
3493 NestLoop(b3t1 b3t2 b3t3 b3t4)
3494 MergeJoin(b3t1 b3t2 b3t3 b3t4 r3_)
3495 Leading(b1t1 b1t2 b1t3 b1t4 b2t1 b2t2 b2t3 b2t4 b3t1 b3t2 b3t3 b3t4 r3_)
3496 not used hint:
3497 MergeJoin(b1t1 b1t2)
3498 MergeJoin(b2t1 b2t2)
3499 HashJoin(b1t1 b1t2 b1t3)
3500 HashJoin(b2t1 b2t2 b2t3)
3501 NestLoop(b1t1 b1t2 b1t3 b1t4)
3502 NestLoop(b2t1 b2t2 b2t3 b2t4)
3503 MergeJoin(b1t1 b1t2 b1t3 b1t4 r3_)
3504 MergeJoin(b2t1 b2t2 b2t3 b2t4 r3_)
3505 duplication hint:
3506 error hint:
3507
3508                                  QUERY PLAN
3509 -----------------------------------------------------------------------------
3510  Aggregate
3511    ->  Nested Loop
3512          ->  Nested Loop
3513                Join Filter: (b1t1.c1 = b1t4.c1)
3514                ->  Hash Join
3515                      Hash Cond: (b1t3.c1 = b1t1.c1)
3516                      ->  Tid Scan on t3 b1t3
3517                            TID Cond: (ctid = '(1,1)'::tid)
3518                      ->  Hash
3519                            ->  Merge Join
3520                                  Merge Cond: (b1t1.c1 = b1t2.c1)
3521                                  ->  Sort
3522                                        Sort Key: b1t1.c1
3523                                        ->  Tid Scan on t1 b1t1
3524                                              TID Cond: (ctid = '(1,1)'::tid)
3525                                  ->  Sort
3526                                        Sort Key: b1t2.c1
3527                                        ->  Seq Scan on t2 b1t2
3528                                              Filter: (ctid = '(1,1)'::tid)
3529                ->  Tid Scan on t4 b1t4
3530                      TID Cond: (ctid = '(1,1)'::tid)
3531          ->  Tid Scan on r3_
3532                TID Cond: (ctid = '(1,1)'::tid)
3533                Filter: (c1 = 1)
3534
3535  Aggregate
3536    ->  Nested Loop
3537          ->  Nested Loop
3538                Join Filter: (b2t1.c1 = b2t4.c1)
3539                ->  Hash Join
3540                      Hash Cond: (b2t3.c1 = b2t1.c1)
3541                      ->  Tid Scan on t3 b2t3
3542                            TID Cond: (ctid = '(1,1)'::tid)
3543                      ->  Hash
3544                            ->  Merge Join
3545                                  Merge Cond: (b2t1.c1 = b2t2.c1)
3546                                  ->  Sort
3547                                        Sort Key: b2t1.c1
3548                                        ->  Tid Scan on t1 b2t1
3549                                              TID Cond: (ctid = '(1,1)'::tid)
3550                                  ->  Sort
3551                                        Sort Key: b2t2.c1
3552                                        ->  Seq Scan on t2 b2t2
3553                                              Filter: (ctid = '(1,1)'::tid)
3554                ->  Tid Scan on t4 b2t4
3555                      TID Cond: (ctid = '(1,1)'::tid)
3556          ->  Tid Scan on r3_
3557                TID Cond: (ctid = '(1,1)'::tid)
3558                Filter: (c1 = 1)
3559
3560  Aggregate
3561    ->  Nested Loop
3562          ->  Nested Loop
3563                Join Filter: (b3t1.c1 = b3t4.c1)
3564                ->  Hash Join
3565                      Hash Cond: (b3t3.c1 = b3t1.c1)
3566                      ->  Tid Scan on t3 b3t3
3567                            TID Cond: (ctid = '(1,1)'::tid)
3568                      ->  Hash
3569                            ->  Merge Join
3570                                  Merge Cond: (b3t1.c1 = b3t2.c1)
3571                                  ->  Sort
3572                                        Sort Key: b3t1.c1
3573                                        ->  Tid Scan on t1 b3t1
3574                                              TID Cond: (ctid = '(1,1)'::tid)
3575                                  ->  Sort
3576                                        Sort Key: b3t2.c1
3577                                        ->  Seq Scan on t2 b3t2
3578                                              Filter: (ctid = '(1,1)'::tid)
3579                ->  Tid Scan on t4 b3t4
3580                      TID Cond: (ctid = '(1,1)'::tid)
3581          ->  Tid Scan on r3_
3582                TID Cond: (ctid = '(1,1)'::tid)
3583                Filter: (c1 = 1)
3584 (74 rows)
3585
3586 -- No. J-2-3-4
3587 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1 v2 WHERE v1.c1 = v2.c1;
3588             QUERY PLAN
3589 ----------------------------------
3590  Hash Join
3591    Hash Cond: (v1t1.c1 = v1t1.c1)
3592    ->  Seq Scan on t1 v1t1
3593    ->  Hash
3594          ->  Seq Scan on t1 v1t1
3595 (5 rows)
3596
3597 /*+HashJoin(v1t1 v1t1)*/
3598 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1 v2 WHERE v1.c1 = v2.c1;
3599 INFO:  hint syntax error at or near "HashJoin(v1t1 v1t1)"
3600 DETAIL:  Relation name "v1t1" is ambiguous.
3601 LOG:  pg_hint_plan:
3602 used hint:
3603 not used hint:
3604 duplication hint:
3605 error hint:
3606 HashJoin(v1t1 v1t1)
3607
3608             QUERY PLAN
3609 ----------------------------------
3610  Hash Join
3611    Hash Cond: (v1t1.c1 = v1t1.c1)
3612    ->  Seq Scan on t1 v1t1
3613    ->  Hash
3614          ->  Seq Scan on t1 v1t1
3615 (5 rows)
3616
3617 -- No. J-2-3-5
3618 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1_ v2 WHERE v1.c1 = v2.c1;
3619             QUERY PLAN
3620 -----------------------------------
3621  Hash Join
3622    Hash Cond: (v1t1.c1 = v1t1_.c1)
3623    ->  Seq Scan on t1 v1t1
3624    ->  Hash
3625          ->  Seq Scan on t1 v1t1_
3626 (5 rows)
3627
3628 /*+NestLoop(v1t1 v1t1_)*/
3629 EXPLAIN (COSTS false) SELECT * FROM s1.v1 v1, s1.v1_ v2 WHERE v1.c1 = v2.c1;
3630 LOG:  pg_hint_plan:
3631 used hint:
3632 NestLoop(v1t1 v1t1_)
3633 not used hint:
3634 duplication hint:
3635 error hint:
3636
3637                 QUERY PLAN
3638 ------------------------------------------
3639  Nested Loop
3640    ->  Seq Scan on t1 v1t1
3641    ->  Index Scan using t1_i1 on t1 v1t1_
3642          Index Cond: (c1 = v1t1.c1)
3643 (4 rows)
3644
3645 -- No. J-2-3-6
3646 EXPLAIN (COSTS false) SELECT * FROM s1.r4 t1, s1.r4 t2 WHERE t1.c1 = t2.c1;
3647             QUERY PLAN
3648 ----------------------------------
3649  Hash Join
3650    Hash Cond: (r4t1.c1 = r4t1.c1)
3651    ->  Seq Scan on t1 r4t1
3652    ->  Hash
3653          ->  Seq Scan on t1 r4t1
3654 (5 rows)
3655
3656 /*+HashJoin(r4t1 r4t1)*/
3657 EXPLAIN (COSTS false) SELECT * FROM s1.r4 t1, s1.r4 t2 WHERE t1.c1 = t2.c1;
3658 INFO:  hint syntax error at or near "HashJoin(r4t1 r4t1)"
3659 DETAIL:  Relation name "r4t1" is ambiguous.
3660 LOG:  pg_hint_plan:
3661 used hint:
3662 not used hint:
3663 duplication hint:
3664 error hint:
3665 HashJoin(r4t1 r4t1)
3666
3667             QUERY PLAN
3668 ----------------------------------
3669  Hash Join
3670    Hash Cond: (r4t1.c1 = r4t1.c1)
3671    ->  Seq Scan on t1 r4t1
3672    ->  Hash
3673          ->  Seq Scan on t1 r4t1
3674 (5 rows)
3675
3676 -- No. J-2-3-7
3677 EXPLAIN (COSTS false) SELECT * FROM s1.r4 t1, s1.r5 t2 WHERE t1.c1 = t2.c1;
3678             QUERY PLAN
3679 ----------------------------------
3680  Hash Join
3681    Hash Cond: (r4t1.c1 = r5t1.c1)
3682    ->  Seq Scan on t1 r4t1
3683    ->  Hash
3684          ->  Seq Scan on t1 r5t1
3685 (5 rows)
3686
3687 /*+NestLoop(r4t1 r5t1)*/
3688 EXPLAIN (COSTS false) SELECT * FROM s1.r4 t1, s1.r5 t2 WHERE t1.c1 = t2.c1;
3689 LOG:  pg_hint_plan:
3690 used hint:
3691 NestLoop(r4t1 r5t1)
3692 not used hint:
3693 duplication hint:
3694 error hint:
3695
3696                QUERY PLAN
3697 -----------------------------------------
3698  Nested Loop
3699    ->  Seq Scan on t1 r4t1
3700    ->  Index Scan using t1_i1 on t1 r5t1
3701          Index Cond: (c1 = r4t1.c1)
3702 (4 rows)
3703
3704 ----
3705 ---- No. J-2-4 VALUES clause
3706 ----
3707 -- No. J-2-4-1
3708 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3709                    QUERY PLAN
3710 -------------------------------------------------
3711  Nested Loop
3712    ->  Hash Join
3713          Hash Cond: (t2.c1 = "*VALUES*".column1)
3714          ->  Seq Scan on t2
3715          ->  Hash
3716                ->  Values Scan on "*VALUES*"
3717    ->  Index Scan using t1_i1 on t1
3718          Index Cond: (c1 = t2.c1)
3719 (8 rows)
3720
3721 /*+ Leading(t3 t1 t2) HashJoin(t3 t1)NestLoop(t3 t1 t2)*/
3722 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3723 LOG:  pg_hint_plan:
3724 used hint:
3725 Leading(t3 t1 t2)
3726 not used hint:
3727 HashJoin(t1 t3)
3728 NestLoop(t1 t2 t3)
3729 duplication hint:
3730 error hint:
3731
3732                  QUERY PLAN
3733 ---------------------------------------------
3734  Nested Loop
3735    Join Filter: (t1.c1 = "*VALUES*".column1)
3736    ->  Values Scan on "*VALUES*"
3737    ->  Merge Join
3738          Merge Cond: (t1.c1 = t2.c1)
3739          ->  Index Scan using t1_i1 on t1
3740          ->  Sort
3741                Sort Key: t2.c1
3742                ->  Seq Scan on t2
3743 (9 rows)
3744
3745 /*+ Leading(*VALUES* t1 t2) HashJoin(*VALUES* t1)NestLoop(*VALUES* t1 t2)*/
3746 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3747 LOG:  pg_hint_plan:
3748 used hint:
3749 HashJoin(*VALUES* t1)
3750 NestLoop(*VALUES* t1 t2)
3751 Leading(*VALUES* t1 t2)
3752 not used hint:
3753 duplication hint:
3754 error hint:
3755
3756                    QUERY PLAN
3757 -------------------------------------------------
3758  Nested Loop
3759    ->  Hash Join
3760          Hash Cond: (t1.c1 = "*VALUES*".column1)
3761          ->  Seq Scan on t1
3762          ->  Hash
3763                ->  Values Scan on "*VALUES*"
3764    ->  Index Scan using t2_i1 on t2
3765          Index Cond: (c1 = t1.c1)
3766 (8 rows)
3767
3768 -- No. J-2-4-2
3769 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3770                       QUERY PLAN
3771 -------------------------------------------------------
3772  Nested Loop
3773    Join Filter: (t1.c1 = "*VALUES*".column1)
3774    ->  Nested Loop
3775          ->  Hash Join
3776                Hash Cond: (t2.c1 = "*VALUES*".column1)
3777                ->  Seq Scan on t2
3778                ->  Hash
3779                      ->  Values Scan on "*VALUES*"
3780          ->  Index Scan using t1_i1 on t1
3781                Index Cond: (c1 = t2.c1)
3782    ->  Values Scan on "*VALUES*"
3783 (11 rows)
3784
3785 /*+ Leading(t4 t3 t2 t1) NestLoop(t4 t3)HashJoin(t4 t3 t2)MergeJoin(t4 t3 t2 t1)*/
3786 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3787 LOG:  pg_hint_plan:
3788 used hint:
3789 Leading(t4 t3 t2 t1)
3790 not used hint:
3791 NestLoop(t3 t4)
3792 HashJoin(t2 t3 t4)
3793 MergeJoin(t1 t2 t3 t4)
3794 duplication hint:
3795 error hint:
3796
3797                     QUERY PLAN
3798 ---------------------------------------------------
3799  Nested Loop
3800    Join Filter: (t1.c1 = "*VALUES*".column1)
3801    ->  Nested Loop
3802          Join Filter: (t1.c1 = "*VALUES*".column1)
3803          ->  Merge Join
3804                Merge Cond: (t1.c1 = t2.c1)
3805                ->  Index Scan using t1_i1 on t1
3806                ->  Sort
3807                      Sort Key: t2.c1
3808                      ->  Seq Scan on t2
3809          ->  Values Scan on "*VALUES*"
3810    ->  Values Scan on "*VALUES*"
3811 (12 rows)
3812
3813 /*+ Leading(*VALUES* t3 t2 t1) NestLoop(t4 t3)HashJoin(*VALUES* t3 t2)MergeJoin(*VALUES* t3 t2 t1)*/
3814 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3815 INFO:  hint syntax error at or near "HashJoin(*VALUES* t3 t2)MergeJoin(*VALUES* t3 t2 t1)"
3816 DETAIL:  Relation name "*VALUES*" is ambiguous.
3817 INFO:  hint syntax error at or near "MergeJoin(*VALUES* t3 t2 t1)"
3818 DETAIL:  Relation name "*VALUES*" is ambiguous.
3819 INFO:  hint syntax error at or near "Leading(*VALUES* t3 t2 t1) NestLoop(t4 t3)HashJoin(*VALUES* t3 t2)MergeJoin(*VALUES* t3 t2 t1)"
3820 DETAIL:  Relation name "*VALUES*" is ambiguous.
3821 LOG:  pg_hint_plan:
3822 used hint:
3823 not used hint:
3824 NestLoop(t3 t4)
3825 Leading(*VALUES* t3 t2 t1)
3826 duplication hint:
3827 error hint:
3828 HashJoin(*VALUES* t2 t3)
3829 MergeJoin(*VALUES* t1 t2 t3)
3830
3831                       QUERY PLAN
3832 -------------------------------------------------------
3833  Nested Loop
3834    Join Filter: (t1.c1 = "*VALUES*".column1)
3835    ->  Nested Loop
3836          ->  Hash Join
3837                Hash Cond: (t2.c1 = "*VALUES*".column1)
3838                ->  Seq Scan on t2
3839                ->  Hash
3840                      ->  Values Scan on "*VALUES*"
3841          ->  Index Scan using t1_i1 on t1
3842                Index Cond: (c1 = t2.c1)
3843    ->  Values Scan on "*VALUES*"
3844 (11 rows)
3845
3846 ----
3847 ---- No. J-3-1 join method hint
3848 ----
3849 -- No. J-3-1-1~6
3850 SET enable_nestloop TO on;
3851 SET enable_mergejoin TO off;
3852 SET enable_hashjoin TO off;
3853 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3854              QUERY PLAN
3855 ------------------------------------
3856  Nested Loop
3857    ->  Seq Scan on t2
3858    ->  Index Scan using t1_i1 on t1
3859          Index Cond: (c1 = t2.c1)
3860 (4 rows)
3861
3862 /*+NestLoop(t1 t2)*/
3863 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3864 LOG:  pg_hint_plan:
3865 used hint:
3866 NestLoop(t1 t2)
3867 not used hint:
3868 duplication hint:
3869 error hint:
3870
3871              QUERY PLAN
3872 ------------------------------------
3873  Nested Loop
3874    ->  Seq Scan on t2
3875    ->  Index Scan using t1_i1 on t1
3876          Index Cond: (c1 = t2.c1)
3877 (4 rows)
3878
3879 /*+HashJoin(t1 t2)*/
3880 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3881 LOG:  pg_hint_plan:
3882 used hint:
3883 HashJoin(t1 t2)
3884 not used hint:
3885 duplication hint:
3886 error hint:
3887
3888           QUERY PLAN
3889 ------------------------------
3890  Hash Join
3891    Hash Cond: (t1.c1 = t2.c1)
3892    ->  Seq Scan on t1
3893    ->  Hash
3894          ->  Seq Scan on t2
3895 (5 rows)
3896
3897 /*+MergeJoin(t1 t2)*/
3898 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3899 LOG:  pg_hint_plan:
3900 used hint:
3901 MergeJoin(t1 t2)
3902 not used hint:
3903 duplication hint:
3904 error hint:
3905
3906              QUERY PLAN
3907 ------------------------------------
3908  Merge Join
3909    Merge Cond: (t1.c1 = t2.c1)
3910    ->  Index Scan using t1_i1 on t1
3911    ->  Sort
3912          Sort Key: t2.c1
3913          ->  Seq Scan on t2
3914 (6 rows)
3915
3916 SET enable_mergejoin TO on;
3917 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.ctid = '(1,1)';;
3918                QUERY PLAN
3919 -----------------------------------------
3920  Nested Loop
3921    Join Filter: (t1.c1 = t2.c1)
3922    ->  Tid Scan on t1
3923          TID Cond: (ctid = '(1,1)'::tid)
3924    ->  Seq Scan on t2
3925 (5 rows)
3926
3927 /*+NoNestLoop(t1 t2)*/
3928 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1 AND t1.ctid = '(1,1)';;
3929 LOG:  pg_hint_plan:
3930 used hint:
3931 NoNestLoop(t1 t2)
3932 not used hint:
3933 duplication hint:
3934 error hint:
3935
3936                   QUERY PLAN
3937 -----------------------------------------------
3938  Merge Join
3939    Merge Cond: (t1.c1 = t2.c1)
3940    ->  Sort
3941          Sort Key: t1.c1
3942          ->  Tid Scan on t1
3943                TID Cond: (ctid = '(1,1)'::tid)
3944    ->  Sort
3945          Sort Key: t2.c1
3946          ->  Seq Scan on t2
3947 (9 rows)
3948
3949 SET enable_mergejoin TO off;
3950 /*+NoHashJoin(t1 t2)*/
3951 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3952 LOG:  pg_hint_plan:
3953 used hint:
3954 NoHashJoin(t1 t2)
3955 not used hint:
3956 duplication hint:
3957 error hint:
3958
3959              QUERY PLAN
3960 ------------------------------------
3961  Nested Loop
3962    ->  Seq Scan on t2
3963    ->  Index Scan using t1_i1 on t1
3964          Index Cond: (c1 = t2.c1)
3965 (4 rows)
3966
3967 /*+NoMergeJoin(t1 t2)*/
3968 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3969 LOG:  pg_hint_plan:
3970 used hint:
3971 NoMergeJoin(t1 t2)
3972 not used hint:
3973 duplication hint:
3974 error hint:
3975
3976              QUERY PLAN
3977 ------------------------------------
3978  Nested Loop
3979    ->  Seq Scan on t2
3980    ->  Index Scan using t1_i1 on t1
3981          Index Cond: (c1 = t2.c1)
3982 (4 rows)
3983
3984 -- No. J-3-1-7~12
3985 SET enable_nestloop TO off;
3986 SET enable_mergejoin TO off;
3987 SET enable_hashjoin TO on;
3988 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
3989           QUERY PLAN
3990 ------------------------------
3991  Hash Join
3992    Hash Cond: (t1.c1 = t2.c1)
3993    ->  Seq Scan on t1
3994    ->  Hash
3995          ->  Seq Scan on t2
3996 (5 rows)
3997
3998 /*+NestLoop(t1 t2)*/
3999 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4000 LOG:  pg_hint_plan:
4001 used hint:
4002 NestLoop(t1 t2)
4003 not used hint:
4004 duplication hint:
4005 error hint:
4006
4007              QUERY PLAN
4008 ------------------------------------
4009  Nested Loop
4010    ->  Seq Scan on t2
4011    ->  Index Scan using t1_i1 on t1
4012          Index Cond: (c1 = t2.c1)
4013 (4 rows)
4014
4015 /*+HashJoin(t1 t2)*/
4016 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4017 LOG:  pg_hint_plan:
4018 used hint:
4019 HashJoin(t1 t2)
4020 not used hint:
4021 duplication hint:
4022 error hint:
4023
4024           QUERY PLAN
4025 ------------------------------
4026  Hash Join
4027    Hash Cond: (t1.c1 = t2.c1)
4028    ->  Seq Scan on t1
4029    ->  Hash
4030          ->  Seq Scan on t2
4031 (5 rows)
4032
4033 /*+MergeJoin(t1 t2)*/
4034 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4035 LOG:  pg_hint_plan:
4036 used hint:
4037 MergeJoin(t1 t2)
4038 not used hint:
4039 duplication hint:
4040 error hint:
4041
4042              QUERY PLAN
4043 ------------------------------------
4044  Merge Join
4045    Merge Cond: (t1.c1 = t2.c1)
4046    ->  Index Scan using t1_i1 on t1
4047    ->  Sort
4048          Sort Key: t2.c1
4049          ->  Seq Scan on t2
4050 (6 rows)
4051
4052 /*+NoNestLoop(t1 t2)*/
4053 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4054 LOG:  pg_hint_plan:
4055 used hint:
4056 NoNestLoop(t1 t2)
4057 not used hint:
4058 duplication hint:
4059 error hint:
4060
4061           QUERY PLAN
4062 ------------------------------
4063  Hash Join
4064    Hash Cond: (t1.c1 = t2.c1)
4065    ->  Seq Scan on t1
4066    ->  Hash
4067          ->  Seq Scan on t2
4068 (5 rows)
4069
4070 /*+NoHashJoin(t1 t2)*/
4071 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4072 LOG:  pg_hint_plan:
4073 used hint:
4074 NoHashJoin(t1 t2)
4075 not used hint:
4076 duplication hint:
4077 error hint:
4078
4079              QUERY PLAN
4080 ------------------------------------
4081  Nested Loop
4082    ->  Seq Scan on t2
4083    ->  Index Scan using t1_i1 on t1
4084          Index Cond: (c1 = t2.c1)
4085 (4 rows)
4086
4087 /*+NoMergeJoin(t1 t2)*/
4088 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4089 LOG:  pg_hint_plan:
4090 used hint:
4091 NoMergeJoin(t1 t2)
4092 not used hint:
4093 duplication hint:
4094 error hint:
4095
4096           QUERY PLAN
4097 ------------------------------
4098  Hash Join
4099    Hash Cond: (t1.c1 = t2.c1)
4100    ->  Seq Scan on t1
4101    ->  Hash
4102          ->  Seq Scan on t2
4103 (5 rows)
4104
4105 -- No. J-3-1-13~18
4106 SET enable_nestloop TO off;
4107 SET enable_mergejoin TO on;
4108 SET enable_hashjoin TO off;
4109 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4110              QUERY PLAN
4111 ------------------------------------
4112  Merge Join
4113    Merge Cond: (t1.c1 = t2.c1)
4114    ->  Index Scan using t1_i1 on t1
4115    ->  Sort
4116          Sort Key: t2.c1
4117          ->  Seq Scan on t2
4118 (6 rows)
4119
4120 /*+NestLoop(t1 t2)*/
4121 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4122 LOG:  pg_hint_plan:
4123 used hint:
4124 NestLoop(t1 t2)
4125 not used hint:
4126 duplication hint:
4127 error hint:
4128
4129              QUERY PLAN
4130 ------------------------------------
4131  Nested Loop
4132    ->  Seq Scan on t2
4133    ->  Index Scan using t1_i1 on t1
4134          Index Cond: (c1 = t2.c1)
4135 (4 rows)
4136
4137 /*+HashJoin(t1 t2)*/
4138 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4139 LOG:  pg_hint_plan:
4140 used hint:
4141 HashJoin(t1 t2)
4142 not used hint:
4143 duplication hint:
4144 error hint:
4145
4146           QUERY PLAN
4147 ------------------------------
4148  Hash Join
4149    Hash Cond: (t1.c1 = t2.c1)
4150    ->  Seq Scan on t1
4151    ->  Hash
4152          ->  Seq Scan on t2
4153 (5 rows)
4154
4155 /*+MergeJoin(t1 t2)*/
4156 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4157 LOG:  pg_hint_plan:
4158 used hint:
4159 MergeJoin(t1 t2)
4160 not used hint:
4161 duplication hint:
4162 error hint:
4163
4164              QUERY PLAN
4165 ------------------------------------
4166  Merge Join
4167    Merge Cond: (t1.c1 = t2.c1)
4168    ->  Index Scan using t1_i1 on t1
4169    ->  Sort
4170          Sort Key: t2.c1
4171          ->  Seq Scan on t2
4172 (6 rows)
4173
4174 /*+NoNestLoop(t1 t2)*/
4175 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4176 LOG:  pg_hint_plan:
4177 used hint:
4178 NoNestLoop(t1 t2)
4179 not used hint:
4180 duplication hint:
4181 error hint:
4182
4183              QUERY PLAN
4184 ------------------------------------
4185  Merge Join
4186    Merge Cond: (t1.c1 = t2.c1)
4187    ->  Index Scan using t1_i1 on t1
4188    ->  Sort
4189          Sort Key: t2.c1
4190          ->  Seq Scan on t2
4191 (6 rows)
4192
4193 /*+NoHashJoin(t1 t2)*/
4194 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4195 LOG:  pg_hint_plan:
4196 used hint:
4197 NoHashJoin(t1 t2)
4198 not used hint:
4199 duplication hint:
4200 error hint:
4201
4202              QUERY PLAN
4203 ------------------------------------
4204  Merge Join
4205    Merge Cond: (t1.c1 = t2.c1)
4206    ->  Index Scan using t1_i1 on t1
4207    ->  Sort
4208          Sort Key: t2.c1
4209          ->  Seq Scan on t2
4210 (6 rows)
4211
4212 /*+NoMergeJoin(t1 t2)*/
4213 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4214 LOG:  pg_hint_plan:
4215 used hint:
4216 NoMergeJoin(t1 t2)
4217 not used hint:
4218 duplication hint:
4219 error hint:
4220
4221              QUERY PLAN
4222 ------------------------------------
4223  Nested Loop
4224    ->  Seq Scan on t2
4225    ->  Index Scan using t1_i1 on t1
4226          Index Cond: (c1 = t2.c1)
4227 (4 rows)
4228
4229 SET enable_nestloop TO on;
4230 SET enable_mergejoin TO on;
4231 SET enable_hashjoin TO on;
4232 ----
4233 ---- No. J-3-2 join inherit tables
4234 ----
4235 EXPLAIN (COSTS false) SELECT * FROM s1.p1, s1.p2 WHERE p1.c1 = p2.c1;
4236               QUERY PLAN
4237 ---------------------------------------
4238  Hash Join
4239    Hash Cond: (s1.p2.c1 = s1.p1.c1)
4240    ->  Append
4241          ->  Seq Scan on p2
4242          ->  Seq Scan on p2c1 p2
4243          ->  Seq Scan on p2c2 p2
4244          ->  Seq Scan on p2c3 p2
4245          ->  Seq Scan on p2c1c1 p2
4246          ->  Seq Scan on p2c1c2 p2
4247          ->  Seq Scan on p2c2c1 p2
4248          ->  Seq Scan on p2c2c2 p2
4249          ->  Seq Scan on p2c3c1 p2
4250          ->  Seq Scan on p2c3c2 p2
4251    ->  Hash
4252          ->  Append
4253                ->  Seq Scan on p1
4254                ->  Seq Scan on p1c1 p1
4255                ->  Seq Scan on p1c2 p1
4256                ->  Seq Scan on p1c3 p1
4257 (19 rows)
4258
4259 -- No. J-3-2-1
4260 /*+MergeJoin(p1 p2)*/
4261 EXPLAIN (COSTS false) SELECT * FROM s1.p1, s1.p2 WHERE p1.c1 = p2.c1;
4262 LOG:  pg_hint_plan:
4263 used hint:
4264 MergeJoin(p1 p2)
4265 not used hint:
4266 duplication hint:
4267 error hint:
4268
4269                QUERY PLAN
4270 -----------------------------------------
4271  Merge Join
4272    Merge Cond: (s1.p1.c1 = s1.p2.c1)
4273    ->  Sort
4274          Sort Key: s1.p1.c1
4275          ->  Append
4276                ->  Seq Scan on p1
4277                ->  Seq Scan on p1c1 p1
4278                ->  Seq Scan on p1c2 p1
4279                ->  Seq Scan on p1c3 p1
4280    ->  Sort
4281          Sort Key: s1.p2.c1
4282          ->  Append
4283                ->  Seq Scan on p2
4284                ->  Seq Scan on p2c1 p2
4285                ->  Seq Scan on p2c2 p2
4286                ->  Seq Scan on p2c3 p2
4287                ->  Seq Scan on p2c1c1 p2
4288                ->  Seq Scan on p2c1c2 p2
4289                ->  Seq Scan on p2c2c1 p2
4290                ->  Seq Scan on p2c2c2 p2
4291                ->  Seq Scan on p2c3c1 p2
4292                ->  Seq Scan on p2c3c2 p2
4293 (22 rows)
4294
4295 -- No. J-3-2-2
4296 /*+MergeJoin(p1c1 p2c1)*/
4297 EXPLAIN (COSTS false) SELECT * FROM s1.p1, s1.p2 WHERE p1.c1 = p2.c1;
4298 LOG:  pg_hint_plan:
4299 used hint:
4300 not used hint:
4301 MergeJoin(p1c1 p2c1)
4302 duplication hint:
4303 error hint:
4304
4305               QUERY PLAN
4306 ---------------------------------------
4307  Hash Join
4308    Hash Cond: (s1.p2.c1 = s1.p1.c1)
4309    ->  Append
4310          ->  Seq Scan on p2
4311          ->  Seq Scan on p2c1 p2
4312          ->  Seq Scan on p2c2 p2
4313          ->  Seq Scan on p2c3 p2
4314          ->  Seq Scan on p2c1c1 p2
4315          ->  Seq Scan on p2c1c2 p2
4316          ->  Seq Scan on p2c2c1 p2
4317          ->  Seq Scan on p2c2c2 p2
4318          ->  Seq Scan on p2c3c1 p2
4319          ->  Seq Scan on p2c3c2 p2
4320    ->  Hash
4321          ->  Append
4322                ->  Seq Scan on p1
4323                ->  Seq Scan on p1c1 p1
4324                ->  Seq Scan on p1c2 p1
4325                ->  Seq Scan on p1c3 p1
4326 (19 rows)
4327
4328 ----
4329 ---- No. J-3-3 conflict join method hint
4330 ----
4331 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4332              QUERY PLAN
4333 ------------------------------------
4334  Merge Join
4335    Merge Cond: (t1.c1 = t2.c1)
4336    ->  Index Scan using t1_i1 on t1
4337    ->  Sort
4338          Sort Key: t2.c1
4339          ->  Seq Scan on t2
4340 (6 rows)
4341
4342 -- No. J-3-3-1
4343 /*+HashJoin(t1 t2)NestLoop(t1 t2)*/
4344 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4345 INFO:  hint syntax error at or near "HashJoin(t1 t2)NestLoop(t1 t2)"
4346 DETAIL:  Conflict join method hint.
4347 LOG:  pg_hint_plan:
4348 used hint:
4349 NestLoop(t1 t2)
4350 not used hint:
4351 duplication hint:
4352 HashJoin(t1 t2)
4353 error hint:
4354
4355              QUERY PLAN
4356 ------------------------------------
4357  Nested Loop
4358    ->  Seq Scan on t2
4359    ->  Index Scan using t1_i1 on t1
4360          Index Cond: (c1 = t2.c1)
4361 (4 rows)
4362
4363 -- No. J-3-3-2
4364 /*+MergeJoin(t1 t2)HashJoin(t1 t2)NestLoop(t1 t2)*/
4365 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4366 INFO:  hint syntax error at or near "MergeJoin(t1 t2)HashJoin(t1 t2)NestLoop(t1 t2)"
4367 DETAIL:  Conflict join method hint.
4368 INFO:  hint syntax error at or near "HashJoin(t1 t2)NestLoop(t1 t2)"
4369 DETAIL:  Conflict join method hint.
4370 LOG:  pg_hint_plan:
4371 used hint:
4372 NestLoop(t1 t2)
4373 not used hint:
4374 duplication hint:
4375 MergeJoin(t1 t2)
4376 HashJoin(t1 t2)
4377 error hint:
4378
4379              QUERY PLAN
4380 ------------------------------------
4381  Nested Loop
4382    ->  Seq Scan on t2
4383    ->  Index Scan using t1_i1 on t1
4384          Index Cond: (c1 = t2.c1)
4385 (4 rows)
4386
4387 -- No. J-3-3-3
4388 /*+HashJoin(t1 t2)NestLoop(t2 t1)*/
4389 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4390 INFO:  hint syntax error at or near "HashJoin(t1 t2)NestLoop(t2 t1)"
4391 DETAIL:  Conflict join method hint.
4392 LOG:  pg_hint_plan:
4393 used hint:
4394 NestLoop(t1 t2)
4395 not used hint:
4396 duplication hint:
4397 HashJoin(t1 t2)
4398 error hint:
4399
4400              QUERY PLAN
4401 ------------------------------------
4402  Nested Loop
4403    ->  Seq Scan on t2
4404    ->  Index Scan using t1_i1 on t1
4405          Index Cond: (c1 = t2.c1)
4406 (4 rows)
4407
4408 -- No. J-3-3-4
4409 /*+MergeJoin(t2 t1)HashJoin(t1 t2)NestLoop(t2 t1)*/
4410 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2 WHERE t1.c1 = t2.c1;
4411 INFO:  hint syntax error at or near "MergeJoin(t2 t1)HashJoin(t1 t2)NestLoop(t2 t1)"
4412 DETAIL:  Conflict join method hint.
4413 INFO:  hint syntax error at or near "HashJoin(t1 t2)NestLoop(t2 t1)"
4414 DETAIL:  Conflict join method hint.
4415 LOG:  pg_hint_plan:
4416 used hint:
4417 NestLoop(t1 t2)
4418 not used hint:
4419 duplication hint:
4420 MergeJoin(t1 t2)
4421 HashJoin(t1 t2)
4422 error hint:
4423
4424              QUERY PLAN
4425 ------------------------------------
4426  Nested Loop
4427    ->  Seq Scan on t2
4428    ->  Index Scan using t1_i1 on t1
4429          Index Cond: (c1 = t2.c1)
4430 (4 rows)
4431
4432 ----
4433 ---- No. J-3-4 hint state output
4434 ----
4435 -- No. J-3-4-1
4436 /*+NestLoop(t1 t2)*/
4437 SELECT * FROM s1.t1, s1.t2 WHERE false;
4438 LOG:  pg_hint_plan:
4439 used hint:
4440 NestLoop(t1 t2)
4441 not used hint:
4442 duplication hint:
4443 error hint:
4444
4445  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4446 ----+----+----+----+----+----+----+----
4447 (0 rows)
4448
4449 -- No. J-3-4-2
4450 /*+HashJoin(t1 t2)*/
4451 SELECT * FROM s1.t1, s1.t2 WHERE false;
4452 LOG:  pg_hint_plan:
4453 used hint:
4454 HashJoin(t1 t2)
4455 not used hint:
4456 duplication hint:
4457 error hint:
4458
4459  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4460 ----+----+----+----+----+----+----+----
4461 (0 rows)
4462
4463 -- No. J-3-4-3
4464 /*+MergeJoin(t1 t2)*/
4465 SELECT * FROM s1.t1, s1.t2 WHERE false;
4466 LOG:  pg_hint_plan:
4467 used hint:
4468 MergeJoin(t1 t2)
4469 not used hint:
4470 duplication hint:
4471 error hint:
4472
4473  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4474 ----+----+----+----+----+----+----+----
4475 (0 rows)
4476
4477 -- No. J-3-4-4
4478 /*+NoNestLoop(t1 t2)*/
4479 SELECT * FROM s1.t1, s1.t2 WHERE false;
4480 LOG:  pg_hint_plan:
4481 used hint:
4482 NoNestLoop(t1 t2)
4483 not used hint:
4484 duplication hint:
4485 error hint:
4486
4487  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4488 ----+----+----+----+----+----+----+----
4489 (0 rows)
4490
4491 -- No. J-3-4-5
4492 /*+NoHashJoin(t1 t2)*/
4493 SELECT * FROM s1.t1, s1.t2 WHERE false;
4494 LOG:  pg_hint_plan:
4495 used hint:
4496 NoHashJoin(t1 t2)
4497 not used hint:
4498 duplication hint:
4499 error hint:
4500
4501  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4502 ----+----+----+----+----+----+----+----
4503 (0 rows)
4504
4505 -- No. J-3-4-6
4506 /*+NoMergeJoin(t1 t2)*/
4507 SELECT * FROM s1.t1, s1.t2 WHERE false;
4508 LOG:  pg_hint_plan:
4509 used hint:
4510 NoMergeJoin(t1 t2)
4511 not used hint:
4512 duplication hint:
4513 error hint:
4514
4515  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4516 ----+----+----+----+----+----+----+----
4517 (0 rows)
4518
4519 -- No. J-3-4-7
4520 /*+NestLoop()*/
4521 SELECT * FROM s1.t1 WHERE false;
4522 INFO:  hint syntax error at or near ""
4523 DETAIL:  NestLoop hint requires at least two relations.
4524 LOG:  pg_hint_plan:
4525 used hint:
4526 not used hint:
4527 duplication hint:
4528 error hint:
4529 NestLoop()
4530
4531  c1 | c2 | c3 | c4
4532 ----+----+----+----
4533 (0 rows)
4534
4535 -- No. J-3-4-8
4536 /*+NestLoop(t1)*/
4537 SELECT * FROM s1.t1 WHERE false;
4538 INFO:  hint syntax error at or near ""
4539 DETAIL:  NestLoop hint requires at least two relations.
4540 LOG:  pg_hint_plan:
4541 used hint:
4542 not used hint:
4543 duplication hint:
4544 error hint:
4545 NestLoop(t1)
4546
4547  c1 | c2 | c3 | c4
4548 ----+----+----+----
4549 (0 rows)
4550
4551 -- No. J-3-4-9
4552 /*+NestLoop(t1 t2)*/
4553 SELECT * FROM s1.t1, s1.t2 WHERE false;
4554 LOG:  pg_hint_plan:
4555 used hint:
4556 NestLoop(t1 t2)
4557 not used hint:
4558 duplication hint:
4559 error hint:
4560
4561  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4562 ----+----+----+----+----+----+----+----
4563 (0 rows)
4564
4565 -- No. J-3-4-10
4566 /*+NestLoop(t1 t2 t3)*/
4567 SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE false;
4568 LOG:  pg_hint_plan:
4569 used hint:
4570 NestLoop(t1 t2 t3)
4571 not used hint:
4572 duplication hint:
4573 error hint:
4574
4575  c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4 | c1 | c2 | c3 | c4
4576 ----+----+----+----+----+----+----+----+----+----+----+----
4577 (0 rows)
4578
4579 ----
4580 ---- No. J-3-5 not used hint
4581 ----
4582 -- No. J-3-5-1
4583 EXPLAIN (COSTS false) SELECT * FROM s1.t1 FULL OUTER JOIN s1.t2 ON (t1.c1 = t2.c1);
4584           QUERY PLAN
4585 ------------------------------
4586  Hash Full Join
4587    Hash Cond: (t1.c1 = t2.c1)
4588    ->  Seq Scan on t1
4589    ->  Hash
4590          ->  Seq Scan on t2
4591 (5 rows)
4592
4593 /*+NestLoop(t1 t2)*/
4594 EXPLAIN (COSTS true) SELECT * FROM s1.t1 FULL OUTER JOIN s1.t2 ON (t1.c1 = t2.c1);
4595 LOG:  pg_hint_plan:
4596 used hint:
4597 NestLoop(t1 t2)
4598 not used hint:
4599 duplication hint:
4600 error hint:
4601
4602                                 QUERY PLAN
4603 --------------------------------------------------------------------------
4604  Hash Full Join  (cost=10000000003.25..10000000024.00 rows=1000 width=29)
4605    Hash Cond: (t1.c1 = t2.c1)
4606    ->  Seq Scan on t1  (cost=0.00..16.00 rows=1000 width=15)
4607    ->  Hash  (cost=2.00..2.00 rows=100 width=14)
4608          ->  Seq Scan on t2  (cost=0.00..2.00 rows=100 width=14)
4609 (5 rows)
4610