expected/pg_hint_plan.out

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