expected/ut-J-9.2.out

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