expected/ut-L-9.2.out

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