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