expected/ut-J.out

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