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