expected/ut-J-9.1.out

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