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:  pg_hint_plan: 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:  pg_hint_plan: 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:  pg_hint_plan: 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:  pg_hint_plan: 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:  pg_hint_plan: 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'), (2,2,2,'2')) AS t1 (c1, c2, c3, c4), s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
 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'), (2,2,2,'2')) AS t1 (c1, c2, c3, c4), s1.t2, s1.t3, s1.t4 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
 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:  pg_hint_plan: 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:  pg_hint_plan: 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'), (2,2,2,'2')) 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'), (2,2,2,'2')) 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'), (2,2,2,'2')) 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'), (2,2,2,'2')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3656                       QUERY PLAN
3657 -------------------------------------------------------
3658  Nested Loop
3659    ->  Nested Loop
3660          Join Filter: (t2.c1 = "*VALUES*_1".column1)
3661          ->  Hash Join
3662                Hash Cond: (t2.c1 = "*VALUES*".column1)
3663                ->  Seq Scan on t2
3664                ->  Hash
3665                      ->  Values Scan on "*VALUES*"
3666          ->  Materialize
3667                ->  Values Scan on "*VALUES*_1"
3668    ->  Index Scan using t1_i1 on t1
3669          Index Cond: (c1 = t2.c1)
3670 (12 rows)
3671
3672 /*+ Leading(t4 t3 t2 t1) */
3673 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3674 LOG:  pg_hint_plan:
3675 used hint:
3676 not used hint:
3677 Leading(t4 t3 t2 t1)
3678 duplication hint:
3679 error hint:
3680
3681                       QUERY PLAN
3682 -------------------------------------------------------
3683  Nested Loop
3684    ->  Nested Loop
3685          Join Filter: (t2.c1 = "*VALUES*_1".column1)
3686          ->  Hash Join
3687                Hash Cond: (t2.c1 = "*VALUES*".column1)
3688                ->  Seq Scan on t2
3689                ->  Hash
3690                      ->  Values Scan on "*VALUES*"
3691          ->  Materialize
3692                ->  Values Scan on "*VALUES*_1"
3693    ->  Index Scan using t1_i1 on t1
3694          Index Cond: (c1 = t2.c1)
3695 (12 rows)
3696
3697 /*+ Leading(*VALUES* t3 t2 t1) */
3698 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t3 (c1, c2, c3, c4), (VALUES(1,1,1,'1'), (2,2,2,'2')) AS t4 (c1, c2, c3, c4) WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1 AND t1.c1 = t4.c1;
3699 INFO:  pg_hint_plan: hint syntax error at or near "Leading(*VALUES* t3 t2 t1) "
3700 DETAIL:  Relation name "*VALUES*" is ambiguous.
3701 LOG:  pg_hint_plan:
3702 used hint:
3703 not used hint:
3704 duplication hint:
3705 error hint:
3706 Leading(*VALUES* t3 t2 t1)
3707
3708                       QUERY PLAN
3709 -------------------------------------------------------
3710  Nested Loop
3711    ->  Nested Loop
3712          Join Filter: (t2.c1 = "*VALUES*_1".column1)
3713          ->  Hash Join
3714                Hash Cond: (t2.c1 = "*VALUES*".column1)
3715                ->  Seq Scan on t2
3716                ->  Hash
3717                      ->  Values Scan on "*VALUES*"
3718          ->  Materialize
3719                ->  Values Scan on "*VALUES*_1"
3720    ->  Index Scan using t1_i1 on t1
3721          Index Cond: (c1 = t2.c1)
3722 (12 rows)
3723
3724 ----
3725 ---- No. L-3-1 leading the order of table joins
3726 ----
3727 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3728                 QUERY PLAN
3729 ------------------------------------------
3730  Merge Join
3731    Merge Cond: (t1.c1 = t2.c1)
3732    ->  Merge Join
3733          Merge Cond: (t1.c1 = t3.c1)
3734          ->  Index Scan using t1_i1 on t1
3735          ->  Index Scan using t3_i1 on t3
3736    ->  Sort
3737          Sort Key: t2.c1
3738          ->  Seq Scan on t2
3739 (9 rows)
3740
3741 -- No. L-3-1-1
3742 /*+Leading(t3 t1 t2)*/
3743 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3744 LOG:  pg_hint_plan:
3745 used hint:
3746 Leading(t3 t1 t2)
3747 not used hint:
3748 duplication hint:
3749 error hint:
3750
3751                 QUERY PLAN
3752 ------------------------------------------
3753  Merge Join
3754    Merge Cond: (t1.c1 = t2.c1)
3755    ->  Merge Join
3756          Merge Cond: (t1.c1 = t3.c1)
3757          ->  Index Scan using t1_i1 on t1
3758          ->  Index Scan using t3_i1 on t3
3759    ->  Sort
3760          Sort Key: t2.c1
3761          ->  Seq Scan on t2
3762 (9 rows)
3763
3764 -- No. L-3-1-2
3765 /*+Leading(t1 t2 t3)*/
3766 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3767 LOG:  pg_hint_plan:
3768 used hint:
3769 Leading(t1 t2 t3)
3770 not used hint:
3771 duplication hint:
3772 error hint:
3773
3774                 QUERY PLAN
3775 ------------------------------------------
3776  Nested Loop
3777    ->  Merge Join
3778          Merge Cond: (t1.c1 = t2.c1)
3779          ->  Index Scan using t1_i1 on t1
3780          ->  Sort
3781                Sort Key: t2.c1
3782                ->  Seq Scan on t2
3783    ->  Index Scan using t3_i1 on t3
3784          Index Cond: (c1 = t1.c1)
3785 (9 rows)
3786
3787 ----
3788 ---- No. L-3-2 GUC parameter to disable hints
3789 ----
3790 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3791                 QUERY PLAN
3792 ------------------------------------------
3793  Merge Join
3794    Merge Cond: (t1.c1 = t2.c1)
3795    ->  Merge Join
3796          Merge Cond: (t1.c1 = t3.c1)
3797          ->  Index Scan using t1_i1 on t1
3798          ->  Index Scan using t3_i1 on t3
3799    ->  Sort
3800          Sort Key: t2.c1
3801          ->  Seq Scan on t2
3802 (9 rows)
3803
3804 -- No. L-3-2-1
3805 Set geqo_threshold = 3;
3806 Set geqo_seed = 0;
3807 /*+Leading(t1 t2 t3)*/
3808 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3809 LOG:  pg_hint_plan:
3810 used hint:
3811 not used hint:
3812 Leading(t1 t2 t3)
3813 duplication hint:
3814 error hint:
3815
3816                 QUERY PLAN
3817 ------------------------------------------
3818  Merge Join
3819    Merge Cond: (t1.c1 = t2.c1)
3820    ->  Merge Join
3821          Merge Cond: (t1.c1 = t3.c1)
3822          ->  Index Scan using t1_i1 on t1
3823          ->  Index Scan using t3_i1 on t3
3824    ->  Sort
3825          Sort Key: t2.c1
3826          ->  Seq Scan on t2
3827 (9 rows)
3828
3829 Reset geqo_threshold;
3830 -- No. L-3-2-2
3831 Set geqo_threshold = 4;
3832 Set geqo_seed = 0;
3833 /*+Leading(t1 t2 t3)*/
3834 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.t2, s1.t3 WHERE t1.c1 = t2.c1 AND t1.c1 = t3.c1;
3835 LOG:  pg_hint_plan:
3836 used hint:
3837 Leading(t1 t2 t3)
3838 not used hint:
3839 duplication hint:
3840 error hint:
3841
3842                 QUERY PLAN
3843 ------------------------------------------
3844  Nested Loop
3845    ->  Merge Join
3846          Merge Cond: (t1.c1 = t2.c1)
3847          ->  Index Scan using t1_i1 on t1
3848          ->  Sort
3849                Sort Key: t2.c1
3850                ->  Seq Scan on t2
3851    ->  Index Scan using t3_i1 on t3
3852          Index Cond: (c1 = t1.c1)
3853 (9 rows)
3854
3855 Reset geqo_threshold;
3856 -- No. L-3-2-3
3857 Set from_collapse_limit = 2;
3858 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.v2 WHERE t1.c1 = v2.c1;
3859                      QUERY PLAN
3860 -----------------------------------------------------
3861  Hash Join
3862    Hash Cond: (t1.c1 = v2t1.c1)
3863    ->  Seq Scan on t1
3864    ->  Hash
3865          ->  Merge Join
3866                Merge Cond: (v2t1.c1 = v2t2.c1)
3867                ->  Index Scan using t1_i1 on t1 v2t1
3868                ->  Sort
3869                      Sort Key: v2t2.c1
3870                      ->  Seq Scan on t2 v2t2
3871 (10 rows)
3872
3873 /*+Leading(t1 v2t1 v2t2)*/
3874 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.v2 WHERE t1.c1 = v2.c1;
3875 LOG:  pg_hint_plan:
3876 used hint:
3877 Leading(t1 v2t1 v2t2)
3878 not used hint:
3879 duplication hint:
3880 error hint:
3881
3882                      QUERY PLAN
3883 -----------------------------------------------------
3884  Hash Join
3885    Hash Cond: (t1.c1 = v2t1.c1)
3886    ->  Seq Scan on t1
3887    ->  Hash
3888          ->  Merge Join
3889                Merge Cond: (v2t1.c1 = v2t2.c1)
3890                ->  Index Scan using t1_i1 on t1 v2t1
3891                ->  Sort
3892                      Sort Key: v2t2.c1
3893                      ->  Seq Scan on t2 v2t2
3894 (10 rows)
3895
3896 Reset from_collapse_limit;
3897 -- No. L-3-2-4
3898 Set from_collapse_limit = 3;
3899 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.v2 WHERE t1.c1 = v2.c1;
3900                   QUERY PLAN
3901 -----------------------------------------------
3902  Merge Join
3903    Merge Cond: (v2t1.c1 = v2t2.c1)
3904    ->  Merge Join
3905          Merge Cond: (t1.c1 = v2t1.c1)
3906          ->  Index Scan using t1_i1 on t1
3907          ->  Index Scan using t1_i1 on t1 v2t1
3908    ->  Sort
3909          Sort Key: v2t2.c1
3910          ->  Seq Scan on t2 v2t2
3911 (9 rows)
3912
3913 /*+Leading(v2t1 v2t2 t1)*/
3914 EXPLAIN (COSTS false) SELECT * FROM s1.t1, s1.v2 WHERE t1.c1 = v2.c1;
3915 LOG:  pg_hint_plan:
3916 used hint:
3917 Leading(v2t1 v2t2 t1)
3918 not used hint:
3919 duplication hint:
3920 error hint:
3921
3922                      QUERY PLAN
3923 -----------------------------------------------------
3924  Hash Join
3925    Hash Cond: (t1.c1 = v2t1.c1)
3926    ->  Seq Scan on t1
3927    ->  Hash
3928          ->  Merge Join
3929                Merge Cond: (v2t1.c1 = v2t2.c1)
3930                ->  Index Scan using t1_i1 on t1 v2t1
3931                ->  Sort
3932                      Sort Key: v2t2.c1
3933                      ->  Seq Scan on t2 v2t2
3934 (10 rows)
3935
3936 Reset from_collapse_limit;
3937 -- No. L-3-2-5
3938 Set join_collapse_limit = 2;
3939 EXPLAIN (COSTS false) SELECT * FROM s1.t3
3940   JOIN s1.t2 ON (t3.c1 = t2.c1)
3941   JOIN s1.t1 ON (t1.c1 = t3.c1);
3942                 QUERY PLAN
3943 ------------------------------------------
3944  Hash Join
3945    Hash Cond: (t1.c1 = t3.c1)
3946    ->  Seq Scan on t1
3947    ->  Hash
3948          ->  Hash Join
3949                Hash Cond: (t3.c1 = t2.c1)
3950                ->  Seq Scan on t3
3951                ->  Hash
3952                      ->  Seq Scan on t2
3953 (9 rows)
3954
3955 /*+Leading(t1 t2 t3)*/
3956 EXPLAIN (COSTS false) SELECT * FROM s1.t3
3957   JOIN s1.t2 ON (t3.c1 = t2.c1)
3958   JOIN s1.t1 ON (t1.c1 = t3.c1);
3959 LOG:  pg_hint_plan:
3960 used hint:
3961 Leading(t1 t2 t3)
3962 not used hint:
3963 duplication hint:
3964 error hint:
3965
3966                 QUERY PLAN
3967 ------------------------------------------
3968  Hash Join
3969    Hash Cond: (t1.c1 = t3.c1)
3970    ->  Seq Scan on t1
3971    ->  Hash
3972          ->  Hash Join
3973                Hash Cond: (t3.c1 = t2.c1)
3974                ->  Seq Scan on t3
3975                ->  Hash
3976                      ->  Seq Scan on t2
3977 (9 rows)
3978
3979 Reset join_collapse_limit;
3980 -- No. L-3-2-6
3981 Set join_collapse_limit = 3;
3982 EXPLAIN (COSTS false) SELECT * FROM s1.t3
3983   JOIN s1.t2 ON (t3.c1 = t2.c1)
3984   JOIN s1.t1 ON (t1.c1 = t3.c1);
3985                 QUERY PLAN
3986 ------------------------------------------
3987  Nested Loop
3988    Join Filter: (t2.c1 = t3.c1)
3989    ->  Merge Join
3990          Merge Cond: (t1.c1 = t2.c1)
3991          ->  Index Scan using t1_i1 on t1
3992          ->  Sort
3993                Sort Key: t2.c1
3994                ->  Seq Scan on t2
3995    ->  Index Scan using t3_i1 on t3
3996          Index Cond: (c1 = t1.c1)
3997 (10 rows)
3998
3999 /*+Leading(t1 t2 t3)*/
4000 EXPLAIN (COSTS false) SELECT * FROM s1.t3
4001   JOIN s1.t2 ON (t3.c1 = t2.c1)
4002   JOIN s1.t1 ON (t1.c1 = t3.c1);
4003 LOG:  pg_hint_plan:
4004 used hint:
4005 Leading(t1 t2 t3)
4006 not used hint:
4007 duplication hint:
4008 error hint:
4009
4010                 QUERY PLAN
4011 ------------------------------------------
4012  Nested Loop
4013    Join Filter: (t2.c1 = t3.c1)
4014    ->  Merge Join
4015          Merge Cond: (t1.c1 = t2.c1)
4016          ->  Index Scan using t1_i1 on t1
4017          ->  Sort
4018                Sort Key: t2.c1
4019                ->  Seq Scan on t2
4020    ->  Index Scan using t3_i1 on t3
4021          Index Cond: (c1 = t1.c1)
4022 (10 rows)
4023
4024 Reset join_collapse_limit;
4025 ----
4026 ---- No. L-3-3 join between parents or between children
4027 ----
4028 -- No. L-3-3-1
4029 /*+Leading(t1 t2 t3)*/
4030 EXPLAIN (COSTS false) SELECT * FROM s1.p2c1 t1
4031   JOIN s1.p2c2 t2 ON (t1.c1 = t2.c1)
4032   JOIN s1.p2c3 t3 ON (t1.c1 = t3.c1);
4033 LOG:  pg_hint_plan:
4034 used hint:
4035 Leading(t1 t2 t3)
4036 not used hint:
4037 duplication hint:
4038 error hint:
4039
4040                    QUERY PLAN
4041 -------------------------------------------------
4042  Hash Join
4043    Hash Cond: (t1.c1 = t3.c1)
4044    ->  Hash Join
4045          Hash Cond: (t1.c1 = t2.c1)
4046          ->  Append
4047                ->  Seq Scan on p2c1 t1
4048                ->  Seq Scan on p2c1c1 t1_1
4049                ->  Seq Scan on p2c1c2 t1_2
4050          ->  Hash
4051                ->  Append
4052                      ->  Seq Scan on p2c2 t2
4053                      ->  Seq Scan on p2c2c1 t2_1
4054                      ->  Seq Scan on p2c2c2 t2_2
4055    ->  Hash
4056          ->  Append
4057                ->  Seq Scan on p2c3 t3
4058                ->  Seq Scan on p2c3c1 t3_1
4059                ->  Seq Scan on p2c3c2 t3_2
4060 (18 rows)
4061
4062 -- No. L-3-3-2
4063 /*+Leading(p2c1c1 p2c2c1 p2c3c1)*/
4064 EXPLAIN (COSTS false) SELECT * FROM s1.p2c1 t1
4065   JOIN s1.p2c2 t2 ON (t1.c1 = t2.c1)
4066   JOIN s1.p2c3 t3 ON (t1.c1 = t3.c1);
4067 LOG:  pg_hint_plan:
4068 used hint:
4069 not used hint:
4070 Leading(p2c1c1 p2c2c1 p2c3c1)
4071 duplication hint:
4072 error hint:
4073
4074                    QUERY PLAN
4075 -------------------------------------------------
4076  Hash Join
4077    Hash Cond: (t1.c1 = t3.c1)
4078    ->  Hash Join
4079          Hash Cond: (t1.c1 = t2.c1)
4080          ->  Append
4081                ->  Seq Scan on p2c1 t1
4082                ->  Seq Scan on p2c1c1 t1_1
4083                ->  Seq Scan on p2c1c2 t1_2
4084          ->  Hash
4085                ->  Append
4086                      ->  Seq Scan on p2c2 t2
4087                      ->  Seq Scan on p2c2c1 t2_1
4088                      ->  Seq Scan on p2c2c2 t2_2
4089    ->  Hash
4090          ->  Append
4091                ->  Seq Scan on p2c3 t3
4092                ->  Seq Scan on p2c3c1 t3_1
4093                ->  Seq Scan on p2c3c2 t3_2
4094 (18 rows)
4095
4096 ----
4097 ---- No. L-3-4 conflict leading hint
4098 ----
4099 -- No. L-3-4-1
4100 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4101   JOIN s1.t2 ON (t1.c1 = t2.c1)
4102   JOIN s1.t3 ON (t1.c1 = t3.c1);
4103                 QUERY PLAN
4104 ------------------------------------------
4105  Merge Join
4106    Merge Cond: (t1.c1 = t2.c1)
4107    ->  Merge Join
4108          Merge Cond: (t1.c1 = t3.c1)
4109          ->  Index Scan using t1_i1 on t1
4110          ->  Index Scan using t3_i1 on t3
4111    ->  Sort
4112          Sort Key: t2.c1
4113          ->  Seq Scan on t2
4114 (9 rows)
4115
4116 /*+Leading(t2 t3 t1)Leading(t1 t2 t3)*/
4117 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4118   JOIN s1.t2 ON (t1.c1 = t2.c1)
4119   JOIN s1.t3 ON (t1.c1 = t3.c1);
4120 INFO:  pg_hint_plan: hint syntax error at or near "Leading(t2 t3 t1)Leading(t1 t2 t3)"
4121 DETAIL:  Conflict leading hint.
4122 LOG:  pg_hint_plan:
4123 used hint:
4124 Leading(t1 t2 t3)
4125 not used hint:
4126 duplication hint:
4127 Leading(t2 t3 t1)
4128 error hint:
4129
4130                 QUERY PLAN
4131 ------------------------------------------
4132  Nested Loop
4133    ->  Merge Join
4134          Merge Cond: (t1.c1 = t2.c1)
4135          ->  Index Scan using t1_i1 on t1
4136          ->  Sort
4137                Sort Key: t2.c1
4138                ->  Seq Scan on t2
4139    ->  Index Scan using t3_i1 on t3
4140          Index Cond: (c1 = t1.c1)
4141 (9 rows)
4142
4143 -- No. L-3-4-2
4144 /*+Leading(t3 t1 t2)Leading(t2 t3 t1)Leading(t1 t2 t3)*/
4145 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4146   JOIN s1.t2 ON (t1.c1 = t2.c1)
4147   JOIN s1.t3 ON (t1.c1 = t3.c1);
4148 INFO:  pg_hint_plan: hint syntax error at or near "Leading(t3 t1 t2)Leading(t2 t3 t1)Leading(t1 t2 t3)"
4149 DETAIL:  Conflict leading hint.
4150 INFO:  pg_hint_plan: hint syntax error at or near "Leading(t2 t3 t1)Leading(t1 t2 t3)"
4151 DETAIL:  Conflict leading hint.
4152 LOG:  pg_hint_plan:
4153 used hint:
4154 Leading(t1 t2 t3)
4155 not used hint:
4156 duplication hint:
4157 Leading(t3 t1 t2)
4158 Leading(t2 t3 t1)
4159 error hint:
4160
4161                 QUERY PLAN
4162 ------------------------------------------
4163  Nested Loop
4164    ->  Merge Join
4165          Merge Cond: (t1.c1 = t2.c1)
4166          ->  Index Scan using t1_i1 on t1
4167          ->  Sort
4168                Sort Key: t2.c1
4169                ->  Seq Scan on t2
4170    ->  Index Scan using t3_i1 on t3
4171          Index Cond: (c1 = t1.c1)
4172 (9 rows)
4173
4174 -- No. L-3-4-3
4175 /*+Leading(t2 t3 t1)Leading()*/
4176 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4177   JOIN s1.t2 ON (t1.c1 = t2.c1)
4178   JOIN s1.t3 ON (t1.c1 = t3.c1);
4179 INFO:  pg_hint_plan: hint syntax error at or near "Leading()"
4180 DETAIL:  Leading hint requires at least two relations.
4181 LOG:  pg_hint_plan:
4182 used hint:
4183 Leading(t2 t3 t1)
4184 not used hint:
4185 duplication hint:
4186 error hint:
4187 Leading()
4188
4189                 QUERY PLAN
4190 ------------------------------------------
4191  Merge Join
4192    Merge Cond: (t1.c1 = t2.c1)
4193    ->  Index Scan using t1_i1 on t1
4194    ->  Sort
4195          Sort Key: t2.c1
4196          ->  Hash Join
4197                Hash Cond: (t3.c1 = t2.c1)
4198                ->  Seq Scan on t3
4199                ->  Hash
4200                      ->  Seq Scan on t2
4201 (10 rows)
4202
4203 -- No. L-3-4-4
4204 /*+Leading(t3 t1 t2)Leading(t2 t3 t1)Leading()*/
4205 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4206   JOIN s1.t2 ON (t1.c1 = t2.c1)
4207   JOIN s1.t3 ON (t1.c1 = t3.c1);
4208 INFO:  pg_hint_plan: hint syntax error at or near "Leading()"
4209 DETAIL:  Leading hint requires at least two relations.
4210 INFO:  pg_hint_plan: hint syntax error at or near "Leading(t3 t1 t2)Leading(t2 t3 t1)Leading()"
4211 DETAIL:  Conflict leading hint.
4212 LOG:  pg_hint_plan:
4213 used hint:
4214 Leading(t2 t3 t1)
4215 not used hint:
4216 duplication hint:
4217 Leading(t3 t1 t2)
4218 error hint:
4219 Leading()
4220
4221                 QUERY PLAN
4222 ------------------------------------------
4223  Merge Join
4224    Merge Cond: (t1.c1 = t2.c1)
4225    ->  Index Scan using t1_i1 on t1
4226    ->  Sort
4227          Sort Key: t2.c1
4228          ->  Hash Join
4229                Hash Cond: (t3.c1 = t2.c1)
4230                ->  Seq Scan on t3
4231                ->  Hash
4232                      ->  Seq Scan on t2
4233 (10 rows)
4234
4235 ----
4236 ---- No. L-3-5 hint state output
4237 ----
4238 -- No. L-3-5-1
4239 /*+Leading()*/
4240 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4241   JOIN s1.t2 ON (t1.c1 = t2.c1)
4242   JOIN s1.t3 ON (t1.c1 = t3.c1);
4243 INFO:  pg_hint_plan: hint syntax error at or near "Leading()"
4244 DETAIL:  Leading hint requires at least two relations.
4245 LOG:  pg_hint_plan:
4246 used hint:
4247 not used hint:
4248 duplication hint:
4249 error hint:
4250 Leading()
4251
4252                 QUERY PLAN
4253 ------------------------------------------
4254  Merge Join
4255    Merge Cond: (t1.c1 = t2.c1)
4256    ->  Merge Join
4257          Merge Cond: (t1.c1 = t3.c1)
4258          ->  Index Scan using t1_i1 on t1
4259          ->  Index Scan using t3_i1 on t3
4260    ->  Sort
4261          Sort Key: t2.c1
4262          ->  Seq Scan on t2
4263 (9 rows)
4264
4265 -- No. L-3-5-2
4266 /*+Leading(t1)*/
4267 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4268   JOIN s1.t2 ON (t1.c1 = t2.c1)
4269   JOIN s1.t3 ON (t1.c1 = t3.c1);
4270 INFO:  pg_hint_plan: hint syntax error at or near "Leading(t1)"
4271 DETAIL:  Leading hint requires at least two relations.
4272 LOG:  pg_hint_plan:
4273 used hint:
4274 not used hint:
4275 duplication hint:
4276 error hint:
4277 Leading(t1)
4278
4279                 QUERY PLAN
4280 ------------------------------------------
4281  Merge Join
4282    Merge Cond: (t1.c1 = t2.c1)
4283    ->  Merge Join
4284          Merge Cond: (t1.c1 = t3.c1)
4285          ->  Index Scan using t1_i1 on t1
4286          ->  Index Scan using t3_i1 on t3
4287    ->  Sort
4288          Sort Key: t2.c1
4289          ->  Seq Scan on t2
4290 (9 rows)
4291
4292 -- No. L-3-5-3
4293 /*+Leading(t1 t2)*/
4294 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4295   JOIN s1.t2 ON (t1.c1 = t2.c1)
4296   JOIN s1.t3 ON (t1.c1 = t3.c1);
4297 LOG:  pg_hint_plan:
4298 used hint:
4299 Leading(t1 t2)
4300 not used hint:
4301 duplication hint:
4302 error hint:
4303
4304                 QUERY PLAN
4305 ------------------------------------------
4306  Nested Loop
4307    ->  Merge Join
4308          Merge Cond: (t1.c1 = t2.c1)
4309          ->  Index Scan using t1_i1 on t1
4310          ->  Sort
4311                Sort Key: t2.c1
4312                ->  Seq Scan on t2
4313    ->  Index Scan using t3_i1 on t3
4314          Index Cond: (c1 = t1.c1)
4315 (9 rows)
4316
4317 -- No. L-3-5-4
4318 /*+Leading(t1 t2 t3)*/
4319 EXPLAIN (COSTS false) SELECT * FROM s1.t1
4320   JOIN s1.t2 ON (t1.c1 = t2.c1)
4321   JOIN s1.t3 ON (t1.c1 = t3.c1);
4322 LOG:  pg_hint_plan:
4323 used hint:
4324 Leading(t1 t2 t3)
4325 not used hint:
4326 duplication hint:
4327 error hint:
4328
4329                 QUERY PLAN
4330 ------------------------------------------
4331  Nested Loop
4332    ->  Merge Join
4333          Merge Cond: (t1.c1 = t2.c1)
4334          ->  Index Scan using t1_i1 on t1
4335          ->  Sort
4336                Sort Key: t2.c1
4337                ->  Seq Scan on t2
4338    ->  Index Scan using t3_i1 on t3
4339          Index Cond: (c1 = t1.c1)
4340 (9 rows)
4341
4342 ----
4343 ---- No. L-3-6 specified Inner/Outer side
4344 ----
4345 -- No. L-3-6-1
4346 /*+Leading((t2))*/
4347 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;
4348 INFO:  pg_hint_plan: hint syntax error at or near "Leading((t2))"
4349 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
4350 LOG:  pg_hint_plan:
4351 used hint:
4352 not used hint:
4353 duplication hint:
4354 error hint:
4355 Leading((t2))
4356
4357                    QUERY PLAN
4358 ------------------------------------------------
4359  Nested Loop
4360    Join Filter: (t1.c1 = t4.c1)
4361    ->  Merge Join
4362          Merge Cond: (t1.c1 = t2.c1)
4363          ->  Merge Join
4364                Merge Cond: (t1.c1 = t3.c1)
4365                ->  Index Scan using t1_i1 on t1
4366                ->  Index Scan using t3_i1 on t3
4367          ->  Sort
4368                Sort Key: t2.c1
4369                ->  Seq Scan on t2
4370    ->  Index Scan using t4_i1 on t4
4371          Index Cond: (c1 = t3.c1)
4372 (13 rows)
4373
4374 -- No. L-3-6-2
4375 /*+Leading((t2 t3))*/
4376 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;
4377 LOG:  pg_hint_plan:
4378 used hint:
4379 Leading((t2 t3))
4380 not used hint:
4381 duplication hint:
4382 error hint:
4383
4384                    QUERY PLAN
4385 ------------------------------------------------
4386  Nested Loop
4387    Join Filter: (t1.c1 = t4.c1)
4388    ->  Nested Loop
4389          Join Filter: (t2.c1 = t1.c1)
4390          ->  Nested Loop
4391                ->  Index Scan using t2_i1 on t2
4392                ->  Index Scan using t3_i1 on t3
4393                      Index Cond: (c1 = t2.c1)
4394          ->  Index Scan using t1_i1 on t1
4395                Index Cond: (c1 = t3.c1)
4396    ->  Index Scan using t4_i1 on t4
4397          Index Cond: (c1 = t3.c1)
4398 (12 rows)
4399
4400 -- No. L-3-6-3
4401 /*+Leading((t2 t3 t4))*/
4402 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;
4403 INFO:  pg_hint_plan: hint syntax error at or near "Leading((t2 t3 t4))"
4404 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
4405 LOG:  pg_hint_plan:
4406 used hint:
4407 not used hint:
4408 duplication hint:
4409 error hint:
4410 Leading((t2 t3 t4))
4411
4412                    QUERY PLAN
4413 ------------------------------------------------
4414  Nested Loop
4415    Join Filter: (t1.c1 = t4.c1)
4416    ->  Merge Join
4417          Merge Cond: (t1.c1 = t2.c1)
4418          ->  Merge Join
4419                Merge Cond: (t1.c1 = t3.c1)
4420                ->  Index Scan using t1_i1 on t1
4421                ->  Index Scan using t3_i1 on t3
4422          ->  Sort
4423                Sort Key: t2.c1
4424                ->  Seq Scan on t2
4425    ->  Index Scan using t4_i1 on t4
4426          Index Cond: (c1 = t3.c1)
4427 (13 rows)
4428
4429 -- No. L-3-6-4
4430 /*+Leading(((t1 t2) (t3 t4)))*/
4431 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;
4432 LOG:  pg_hint_plan:
4433 used hint:
4434 Leading(((t1 t2) (t3 t4)))
4435 not used hint:
4436 duplication hint:
4437 error hint:
4438
4439                 QUERY PLAN
4440 ------------------------------------------
4441  Hash Join
4442    Hash Cond: (t1.c1 = t3.c1)
4443    ->  Merge Join
4444          Merge Cond: (t1.c1 = t2.c1)
4445          ->  Index Scan using t1_i1 on t1
4446          ->  Sort
4447                Sort Key: t2.c1
4448                ->  Seq Scan on t2
4449    ->  Hash
4450          ->  Hash Join
4451                Hash Cond: (t3.c1 = t4.c1)
4452                ->  Seq Scan on t3
4453                ->  Hash
4454                      ->  Seq Scan on t4
4455 (14 rows)
4456
4457 -- No. L-3-6-5
4458 /*+Leading((((t1 t3) t4) t2)))*/
4459 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;
4460 INFO:  pg_hint_plan: hint syntax error at or near ")"
4461 DETAIL:  Unrecognized hint keyword ")".
4462 LOG:  pg_hint_plan:
4463 used hint:
4464 Leading((((t1 t3) t4) t2))
4465 not used hint:
4466 duplication hint:
4467 error hint:
4468
4469                    QUERY PLAN
4470 ------------------------------------------------
4471  Merge Join
4472    Merge Cond: (t1.c1 = t2.c1)
4473    ->  Merge Join
4474          Merge Cond: (t1.c1 = t4.c1)
4475          ->  Merge Join
4476                Merge Cond: (t1.c1 = t3.c1)
4477                ->  Index Scan using t1_i1 on t1
4478                ->  Index Scan using t3_i1 on t3
4479          ->  Index Scan using t4_i1 on t4
4480    ->  Sort
4481          Sort Key: t2.c1
4482          ->  Seq Scan on t2
4483 (12 rows)
4484
4485 -- No. L-3-6-6
4486 /*+Leading((t1 (t3 (t4 t2))))*/
4487 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;
4488 LOG:  pg_hint_plan:
4489 used hint:
4490 Leading((t1 (t3 (t4 t2))))
4491 not used hint:
4492 duplication hint:
4493 error hint:
4494
4495                       QUERY PLAN
4496 ------------------------------------------------------
4497  Merge Join
4498    Merge Cond: (t1.c1 = t2.c1)
4499    ->  Index Scan using t1_i1 on t1
4500    ->  Sort
4501          Sort Key: t2.c1
4502          ->  Hash Join
4503                Hash Cond: (t3.c1 = t2.c1)
4504                ->  Seq Scan on t3
4505                ->  Hash
4506                      ->  Hash Join
4507                            Hash Cond: (t4.c1 = t2.c1)
4508                            ->  Seq Scan on t4
4509                            ->  Hash
4510                                  ->  Seq Scan on t2
4511 (14 rows)
4512