expected/ut-L-9.2.out

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