expected/ut-L.out

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