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