expected/ut-J-9.2.out

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