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