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