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