expected/ut-L.out

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