expected/ut-L.out

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