expected/ut-J.out

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