expected/ut-L-9.1.out

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