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