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