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