expected/pg_hint_plan-9.2.out

   1 SET search_path TO public;
   2 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
   3               QUERY PLAN
   4 --------------------------------------
   5  Merge Join
   6    Merge Cond: (t1.id = t2.id)
   7    ->  Index Scan using t1_pkey on t1
   8    ->  Index Scan using t2_pkey on t2
   9 (4 rows)
  10
  11 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
  12                 QUERY PLAN
  13 -------------------------------------------
  14  Merge Join
  15    Merge Cond: (t2.val = t1.val)
  16    ->  Index Scan using t2_val on t2
  17    ->  Materialize
  18          ->  Index Scan using t1_val on t1
  19 (5 rows)
  20
  21 LOAD 'pg_hint_plan';
  22 SET pg_hint_plan.debug_print TO on;
  23 SET client_min_messages TO LOG;
  24 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  25               QUERY PLAN
  26 --------------------------------------
  27  Merge Join
  28    Merge Cond: (t1.id = t2.id)
  29    ->  Index Scan using t1_pkey on t1
  30    ->  Index Scan using t2_pkey on t2
  31 (4 rows)
  32
  33 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.val = t2.val;
  34                 QUERY PLAN
  35 -------------------------------------------
  36  Merge Join
  37    Merge Cond: (t2.val = t1.val)
  38    ->  Index Scan using t2_val on t2
  39    ->  Materialize
  40          ->  Index Scan using t1_val on t1
  41 (5 rows)
  42
  43 /*+ Test (t1 t2) */
  44 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  45 INFO:  hint syntax error at or near "Test (t1 t2) "
  46 DETAIL:  Unrecognized hint keyword "Test".
  47               QUERY PLAN
  48 --------------------------------------
  49  Merge Join
  50    Merge Cond: (t1.id = t2.id)
  51    ->  Index Scan using t1_pkey on t1
  52    ->  Index Scan using t2_pkey on t2
  53 (4 rows)
  54
  55 SET pg_hint_plan.enable_hint TO off;
  56 /*+ Test (t1 t2) */
  57 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  58               QUERY PLAN
  59 --------------------------------------
  60  Merge Join
  61    Merge Cond: (t1.id = t2.id)
  62    ->  Index Scan using t1_pkey on t1
  63    ->  Index Scan using t2_pkey on t2
  64 (4 rows)
  65
  66 SET pg_hint_plan.enable_hint TO on;
  67 /*Set(enable_indexscan off)*/
  68 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  69               QUERY PLAN
  70 --------------------------------------
  71  Merge Join
  72    Merge Cond: (t1.id = t2.id)
  73    ->  Index Scan using t1_pkey on t1
  74    ->  Index Scan using t2_pkey on t2
  75 (4 rows)
  76
  77 --+Set(enable_indexscan off)
  78 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  79               QUERY PLAN
  80 --------------------------------------
  81  Merge Join
  82    Merge Cond: (t1.id = t2.id)
  83    ->  Index Scan using t1_pkey on t1
  84    ->  Index Scan using t2_pkey on t2
  85 (4 rows)
  86
  87 /*+Set(enable_indexscan off) /* nest comment */ */
  88 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
  89 INFO:  hint syntax error at or near "/* nest comment */ */
  90 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;"
  91 DETAIL:  Nested block comments are not supported.
  92               QUERY PLAN
  93 --------------------------------------
  94  Merge Join
  95    Merge Cond: (t1.id = t2.id)
  96    ->  Index Scan using t1_pkey on t1
  97    ->  Index Scan using t2_pkey on t2
  98 (4 rows)
  99
 100 /*+Set(enable_indexscan off)*/
 101 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 102 LOG:  pg_hint_plan:
 103 used hint:
 104 Set(enable_indexscan off)
 105 not used hint:
 106 duplication hint:
 107 error hint:
 108
 109           QUERY PLAN
 110 ------------------------------
 111  Hash Join
 112    Hash Cond: (t1.id = t2.id)
 113    ->  Seq Scan on t1
 114    ->  Hash
 115          ->  Seq Scan on t2
 116 (5 rows)
 117
 118 EXPLAIN (COSTS false) /*+Set(enable_indexscan off)*/
 119  SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 120 LOG:  pg_hint_plan:
 121 used hint:
 122 Set(enable_indexscan off)
 123 not used hint:
 124 duplication hint:
 125 error hint:
 126
 127           QUERY PLAN
 128 ------------------------------
 129  Hash Join
 130    Hash Cond: (t1.id = t2.id)
 131    ->  Seq Scan on t1
 132    ->  Hash
 133          ->  Seq Scan on t2
 134 (5 rows)
 135
 136 /*+ Set(enable_indexscan off) Set(enable_hashjoin off) */
 137 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 138 LOG:  pg_hint_plan:
 139 used hint:
 140 Set(enable_hashjoin off)
 141 Set(enable_indexscan off)
 142 not used hint:
 143 duplication hint:
 144 error hint:
 145
 146           QUERY PLAN
 147 -------------------------------
 148  Merge Join
 149    Merge Cond: (t1.id = t2.id)
 150    ->  Sort
 151          Sort Key: t1.id
 152          ->  Seq Scan on t1
 153    ->  Sort
 154          Sort Key: t2.id
 155          ->  Seq Scan on t2
 156 (8 rows)
 157
 158 /*+      Set     (       enable_indexscan        off     )       */
 159 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 160 LOG:  pg_hint_plan:
 161 used hint:
 162 Set(enable_indexscan off)
 163 not used hint:
 164 duplication hint:
 165 error hint:
 166
 167           QUERY PLAN
 168 ------------------------------
 169  Hash Join
 170    Hash Cond: (t1.id = t2.id)
 171    ->  Seq Scan on t1
 172    ->  Hash
 173          ->  Seq Scan on t2
 174 (5 rows)
 175
 176 /*+
 177                 Set
 178                 (
 179                 enable_indexscan
 180                 off
 181                 )
 182                 */
 183 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 184 LOG:  pg_hint_plan:
 185 used hint:
 186 Set(enable_indexscan off)
 187 not used hint:
 188 duplication hint:
 189 error hint:
 190
 191           QUERY PLAN
 192 ------------------------------
 193  Hash Join
 194    Hash Cond: (t1.id = t2.id)
 195    ->  Seq Scan on t1
 196    ->  Hash
 197          ->  Seq Scan on t2
 198 (5 rows)
 199
 200 /*+ Set(enable_indexscan off)Set(enable_nestloop off)Set(enable_mergejoin off)
 201                 Set(enable_seqscan off)
 202                 */
 203 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 204 LOG:  pg_hint_plan:
 205 used hint:
 206 Set(enable_indexscan off)
 207 Set(enable_mergejoin off)
 208 Set(enable_nestloop off)
 209 Set(enable_seqscan off)
 210 not used hint:
 211 duplication hint:
 212 error hint:
 213
 214                 QUERY PLAN
 215 ------------------------------------------
 216  Nested Loop
 217    ->  Index Scan using t2_pkey on t2
 218    ->  Bitmap Heap Scan on t1
 219          Recheck Cond: (id = t2.id)
 220          ->  Bitmap Index Scan on t1_pkey
 221                Index Cond: (id = t2.id)
 222 (6 rows)
 223
 224 /*+Set(work_mem "1M")*/
 225 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 226 INFO:  invalid value for parameter "work_mem": "1M"
 227 HINT:  Valid units for this parameter are "kB", "MB", and "GB".
 228 LOG:  pg_hint_plan:
 229 used hint:
 230 not used hint:
 231 duplication hint:
 232 error hint:
 233 Set(work_mem 1M)
 234
 235               QUERY PLAN
 236 --------------------------------------
 237  Merge Join
 238    Merge Cond: (t1.id = t2.id)
 239    ->  Index Scan using t1_pkey on t1
 240    ->  Index Scan using t2_pkey on t2
 241 (4 rows)
 242
 243 /*+Set(work_mem "1MB")*/
 244 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 245 LOG:  pg_hint_plan:
 246 used hint:
 247 Set(work_mem 1MB)
 248 not used hint:
 249 duplication hint:
 250 error hint:
 251
 252               QUERY PLAN
 253 --------------------------------------
 254  Merge Join
 255    Merge Cond: (t1.id = t2.id)
 256    ->  Index Scan using t1_pkey on t1
 257    ->  Index Scan using t2_pkey on t2
 258 (4 rows)
 259
 260 /*+Set(work_mem TO "1MB")*/
 261 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 262 INFO:  hint syntax error at or near "Set(work_mem TO "1MB")"
 263 DETAIL:  Set hint requires name and value of GUC parameter.
 264 LOG:  pg_hint_plan:
 265 used hint:
 266 not used hint:
 267 duplication hint:
 268 error hint:
 269 Set(work_mem TO 1MB)
 270
 271               QUERY PLAN
 272 --------------------------------------
 273  Merge Join
 274    Merge Cond: (t1.id = t2.id)
 275    ->  Index Scan using t1_pkey on t1
 276    ->  Index Scan using t2_pkey on t2
 277 (4 rows)
 278
 279 /*+SeqScan(t1 t2)*/
 280 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 281 INFO:  hint syntax error at or near ""
 282 DETAIL:  SeqScan hint accepts only one relation.
 283 LOG:  pg_hint_plan:
 284 used hint:
 285 not used hint:
 286 duplication hint:
 287 error hint:
 288 SeqScan(t1 t2)
 289
 290               QUERY PLAN
 291 --------------------------------------
 292  Merge Join
 293    Merge Cond: (t1.id = t2.id)
 294    ->  Index Scan using t1_pkey on t1
 295    ->  Index Scan using t2_pkey on t2
 296 (4 rows)
 297
 298 /*+SeqScan(t1)*/
 299 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 300 LOG:  pg_hint_plan:
 301 used hint:
 302 SeqScan(t1)
 303 not used hint:
 304 duplication hint:
 305 error hint:
 306
 307           QUERY PLAN
 308 ------------------------------
 309  Hash Join
 310    Hash Cond: (t1.id = t2.id)
 311    ->  Seq Scan on t1
 312    ->  Hash
 313          ->  Seq Scan on t2
 314 (5 rows)
 315
 316 /*+SeqScan(t1)IndexScan(t2)*/
 317 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 318 LOG:  pg_hint_plan:
 319 used hint:
 320 SeqScan(t1)
 321 IndexScan(t2)
 322 not used hint:
 323 duplication hint:
 324 error hint:
 325
 326                  QUERY PLAN
 327 --------------------------------------------
 328  Hash Join
 329    Hash Cond: (t1.id = t2.id)
 330    ->  Seq Scan on t1
 331    ->  Hash
 332          ->  Index Scan using t2_pkey on t2
 333 (5 rows)
 334
 335 /*+BitmapScan(t2)*/
 336 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 337 LOG:  pg_hint_plan:
 338 used hint:
 339 BitmapScan(t2)
 340 not used hint:
 341 duplication hint:
 342 error hint:
 343
 344                 QUERY PLAN
 345 ------------------------------------------
 346  Nested Loop
 347    ->  Seq Scan on t1
 348    ->  Bitmap Heap Scan on t2
 349          Recheck Cond: (id = t1.id)
 350          ->  Bitmap Index Scan on t2_pkey
 351                Index Cond: (id = t1.id)
 352 (6 rows)
 353
 354 /*+BitmapScan(t2)NoSeqScan(t1)*/
 355 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 356 LOG:  pg_hint_plan:
 357 used hint:
 358 NoSeqScan(t1)
 359 BitmapScan(t2)
 360 not used hint:
 361 duplication hint:
 362 error hint:
 363
 364                 QUERY PLAN
 365 ------------------------------------------
 366  Nested Loop
 367    ->  Index Scan using t1_pkey on t1
 368    ->  Bitmap Heap Scan on t2
 369          Recheck Cond: (id = t1.id)
 370          ->  Bitmap Index Scan on t2_pkey
 371                Index Cond: (id = t1.id)
 372 (6 rows)
 373
 374 /*+NoIndexScan(t1)*/
 375 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 376 LOG:  pg_hint_plan:
 377 used hint:
 378 NoIndexScan(t1)
 379 not used hint:
 380 duplication hint:
 381 error hint:
 382
 383           QUERY PLAN
 384 ------------------------------
 385  Hash Join
 386    Hash Cond: (t1.id = t2.id)
 387    ->  Seq Scan on t1
 388    ->  Hash
 389          ->  Seq Scan on t2
 390 (5 rows)
 391
 392 /*+NoBitmapScan(t1)*/
 393 EXPLAIN (COSTS false) SELECT * FROM t1, t4 WHERE t1.val < 10;
 394 LOG:  pg_hint_plan:
 395 used hint:
 396 NoBitmapScan(t1)
 397 not used hint:
 398 duplication hint:
 399 error hint:
 400
 401          QUERY PLAN
 402 ----------------------------
 403  Nested Loop
 404    ->  Seq Scan on t1
 405          Filter: (val < 10)
 406    ->  Materialize
 407          ->  Seq Scan on t4
 408 (5 rows)
 409
 410 /*+TidScan(t4)*/
 411 EXPLAIN (COSTS false) SELECT * FROM t3, t4 WHERE t3.id = t4.id AND t4.ctid = '(1,1)';
 412 LOG:  pg_hint_plan:
 413 used hint:
 414 TidScan(t4)
 415 not used hint:
 416 duplication hint:
 417 error hint:
 418
 419                   QUERY PLAN
 420 -----------------------------------------------
 421  Merge Join
 422    Merge Cond: (t3.id = t4.id)
 423    ->  Index Scan using t3_pkey on t3
 424    ->  Sort
 425          Sort Key: t4.id
 426          ->  Tid Scan on t4
 427                TID Cond: (ctid = '(1,1)'::tid)
 428 (7 rows)
 429
 430 /*+NoTidScan(t1)*/
 431 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)';
 432 LOG:  pg_hint_plan:
 433 used hint:
 434 NoTidScan(t1)
 435 not used hint:
 436 duplication hint:
 437 error hint:
 438
 439               QUERY PLAN
 440 ---------------------------------------
 441  Nested Loop
 442    ->  Seq Scan on t1
 443          Filter: (ctid = '(1,1)'::tid)
 444    ->  Index Scan using t2_pkey on t2
 445          Index Cond: (id = t1.id)
 446 (5 rows)
 447
 448 /*+HashJoin(t1 t2)*/
 449 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 450 LOG:  pg_hint_plan:
 451 used hint:
 452 HashJoin(t1 t2)
 453 not used hint:
 454 duplication hint:
 455 error hint:
 456
 457           QUERY PLAN
 458 ------------------------------
 459  Hash Join
 460    Hash Cond: (t1.id = t2.id)
 461    ->  Seq Scan on t1
 462    ->  Hash
 463          ->  Seq Scan on t2
 464 (5 rows)
 465
 466 /*+NestLoop(t1 t2)*/
 467 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 468 LOG:  pg_hint_plan:
 469 used hint:
 470 NestLoop(t1 t2)
 471 not used hint:
 472 duplication hint:
 473 error hint:
 474
 475               QUERY PLAN
 476 --------------------------------------
 477  Nested Loop
 478    ->  Seq Scan on t2
 479    ->  Index Scan using t1_pkey on t1
 480          Index Cond: (id = t2.id)
 481 (4 rows)
 482
 483 /*+NoMergeJoin(t1 t2)*/
 484 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
 485 LOG:  pg_hint_plan:
 486 used hint:
 487 NoMergeJoin(t1 t2)
 488 not used hint:
 489 duplication hint:
 490 error hint:
 491
 492           QUERY PLAN
 493 ------------------------------
 494  Hash Join
 495    Hash Cond: (t1.id = t2.id)
 496    ->  Seq Scan on t1
 497    ->  Hash
 498          ->  Seq Scan on t2
 499 (5 rows)
 500
 501 /*+MergeJoin(t1 t3)*/
 502 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
 503 LOG:  pg_hint_plan:
 504 used hint:
 505 MergeJoin(t1 t3)
 506 not used hint:
 507 duplication hint:
 508 error hint:
 509
 510              QUERY PLAN
 511 -------------------------------------
 512  Merge Join
 513    Merge Cond: (t1.val = t3.val)
 514    ->  Index Scan using t1_val on t1
 515    ->  Sort
 516          Sort Key: t3.val
 517          ->  Seq Scan on t3
 518 (6 rows)
 519
 520 /*+NestLoop(t1 t3)*/
 521 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
 522 LOG:  pg_hint_plan:
 523 used hint:
 524 NestLoop(t1 t3)
 525 not used hint:
 526 duplication hint:
 527 error hint:
 528
 529              QUERY PLAN
 530 -------------------------------------
 531  Nested Loop
 532    ->  Seq Scan on t3
 533    ->  Index Scan using t1_val on t1
 534          Index Cond: (val = t3.val)
 535 (4 rows)
 536
 537 /*+NoHashJoin(t1 t3)*/
 538 EXPLAIN (COSTS false) SELECT * FROM t1, t3 WHERE t1.val = t3.val;
 539 LOG:  pg_hint_plan:
 540 used hint:
 541 NoHashJoin(t1 t3)
 542 not used hint:
 543 duplication hint:
 544 error hint:
 545
 546              QUERY PLAN
 547 -------------------------------------
 548  Nested Loop
 549    ->  Seq Scan on t3
 550    ->  Index Scan using t1_val on t1
 551          Index Cond: (val = t3.val)
 552 (4 rows)
 553
 554 /*+MergeJoin(t4 t1 t2 t3)*/
 555 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 556 LOG:  pg_hint_plan:
 557 used hint:
 558 MergeJoin(t1 t2 t3 t4)
 559 not used hint:
 560 duplication hint:
 561 error hint:
 562
 563                     QUERY PLAN
 564 --------------------------------------------------
 565  Merge Join
 566    Merge Cond: (t1.id = t4.id)
 567    ->  Merge Join
 568          Merge Cond: (t1.id = t3.id)
 569          ->  Merge Join
 570                Merge Cond: (t1.id = t2.id)
 571                ->  Index Scan using t1_pkey on t1
 572                ->  Index Scan using t2_pkey on t2
 573          ->  Index Scan using t3_pkey on t3
 574    ->  Sort
 575          Sort Key: t4.id
 576          ->  Seq Scan on t4
 577 (12 rows)
 578
 579 /*+HashJoin(t3 t4 t1 t2)*/
 580 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 581 LOG:  pg_hint_plan:
 582 used hint:
 583 HashJoin(t1 t2 t3 t4)
 584 not used hint:
 585 duplication hint:
 586 error hint:
 587
 588                        QUERY PLAN
 589 --------------------------------------------------------
 590  Hash Join
 591    Hash Cond: (t3.id = t1.id)
 592    ->  Seq Scan on t3
 593    ->  Hash
 594          ->  Merge Join
 595                Merge Cond: (t1.id = t4.id)
 596                ->  Merge Join
 597                      Merge Cond: (t1.id = t2.id)
 598                      ->  Index Scan using t1_pkey on t1
 599                      ->  Index Scan using t2_pkey on t2
 600                ->  Sort
 601                      Sort Key: t4.id
 602                      ->  Seq Scan on t4
 603 (13 rows)
 604
 605 /*+NestLoop(t2 t3 t4 t1) IndexScan(t3)*/
 606 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 607 LOG:  pg_hint_plan:
 608 used hint:
 609 IndexScan(t3)
 610 NestLoop(t1 t2 t3 t4)
 611 not used hint:
 612 duplication hint:
 613 error hint:
 614
 615                     QUERY PLAN
 616 --------------------------------------------------
 617  Nested Loop
 618    ->  Merge Join
 619          Merge Cond: (t1.id = t4.id)
 620          ->  Merge Join
 621                Merge Cond: (t1.id = t2.id)
 622                ->  Index Scan using t1_pkey on t1
 623                ->  Index Scan using t2_pkey on t2
 624          ->  Sort
 625                Sort Key: t4.id
 626                ->  Seq Scan on t4
 627    ->  Index Scan using t3_pkey on t3
 628          Index Cond: (id = t1.id)
 629 (12 rows)
 630
 631 /*+NoNestLoop(t4 t1 t3 t2)*/
 632 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 633 LOG:  pg_hint_plan:
 634 used hint:
 635 NoNestLoop(t1 t2 t3 t4)
 636 not used hint:
 637 duplication hint:
 638 error hint:
 639
 640                     QUERY PLAN
 641 --------------------------------------------------
 642  Merge Join
 643    Merge Cond: (t1.id = t4.id)
 644    ->  Merge Join
 645          Merge Cond: (t1.id = t3.id)
 646          ->  Merge Join
 647                Merge Cond: (t1.id = t2.id)
 648                ->  Index Scan using t1_pkey on t1
 649                ->  Index Scan using t2_pkey on t2
 650          ->  Index Scan using t3_pkey on t3
 651    ->  Sort
 652          Sort Key: t4.id
 653          ->  Seq Scan on t4
 654 (12 rows)
 655
 656 /*+Leading( */
 657 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 658 INFO:  hint syntax error at or near ""
 659 DETAIL:  Closing parenthesis is necessary.
 660                     QUERY PLAN
 661 --------------------------------------------------
 662  Nested Loop
 663    ->  Merge Join
 664          Merge Cond: (t1.id = t4.id)
 665          ->  Merge Join
 666                Merge Cond: (t1.id = t2.id)
 667                ->  Index Scan using t1_pkey on t1
 668                ->  Index Scan using t2_pkey on t2
 669          ->  Sort
 670                Sort Key: t4.id
 671                ->  Seq Scan on t4
 672    ->  Index Scan using t3_pkey on t3
 673          Index Cond: (id = t1.id)
 674 (12 rows)
 675
 676 /*+Leading( )*/
 677 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 678 INFO:  hint syntax error at or near "Leading( )"
 679 DETAIL:  Leading hint requires at least two relations.
 680 LOG:  pg_hint_plan:
 681 used hint:
 682 not used hint:
 683 duplication hint:
 684 error hint:
 685 Leading()
 686
 687                     QUERY PLAN
 688 --------------------------------------------------
 689  Nested Loop
 690    ->  Merge Join
 691          Merge Cond: (t1.id = t4.id)
 692          ->  Merge Join
 693                Merge Cond: (t1.id = t2.id)
 694                ->  Index Scan using t1_pkey on t1
 695                ->  Index Scan using t2_pkey on t2
 696          ->  Sort
 697                Sort Key: t4.id
 698                ->  Seq Scan on t4
 699    ->  Index Scan using t3_pkey on t3
 700          Index Cond: (id = t1.id)
 701 (12 rows)
 702
 703 /*+Leading( t3 )*/
 704 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 705 INFO:  hint syntax error at or near "Leading( t3 )"
 706 DETAIL:  Leading hint requires at least two relations.
 707 LOG:  pg_hint_plan:
 708 used hint:
 709 not used hint:
 710 duplication hint:
 711 error hint:
 712 Leading(t3)
 713
 714                     QUERY PLAN
 715 --------------------------------------------------
 716  Nested Loop
 717    ->  Merge Join
 718          Merge Cond: (t1.id = t4.id)
 719          ->  Merge Join
 720                Merge Cond: (t1.id = t2.id)
 721                ->  Index Scan using t1_pkey on t1
 722                ->  Index Scan using t2_pkey on t2
 723          ->  Sort
 724                Sort Key: t4.id
 725                ->  Seq Scan on t4
 726    ->  Index Scan using t3_pkey on t3
 727          Index Cond: (id = t1.id)
 728 (12 rows)
 729
 730 /*+Leading( t3 t4 )*/
 731 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 732 LOG:  pg_hint_plan:
 733 used hint:
 734 Leading(t3 t4)
 735 not used hint:
 736 duplication hint:
 737 error hint:
 738
 739                     QUERY PLAN
 740 --------------------------------------------------
 741  Nested Loop
 742    ->  Nested Loop
 743          ->  Merge Join
 744                Merge Cond: (t3.id = t4.id)
 745                ->  Index Scan using t3_pkey on t3
 746                ->  Sort
 747                      Sort Key: t4.id
 748                      ->  Seq Scan on t4
 749          ->  Index Scan using t2_pkey on t2
 750                Index Cond: (id = t3.id)
 751    ->  Index Scan using t1_pkey on t1
 752          Index Cond: (id = t2.id)
 753 (12 rows)
 754
 755 /*+Leading(t3 t4 t1)*/
 756 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 757 LOG:  pg_hint_plan:
 758 used hint:
 759 Leading(t3 t4 t1)
 760 not used hint:
 761 duplication hint:
 762 error hint:
 763
 764                     QUERY PLAN
 765 --------------------------------------------------
 766  Nested Loop
 767    ->  Merge Join
 768          Merge Cond: (t3.id = t1.id)
 769          ->  Merge Join
 770                Merge Cond: (t3.id = t4.id)
 771                ->  Index Scan using t3_pkey on t3
 772                ->  Sort
 773                      Sort Key: t4.id
 774                      ->  Seq Scan on t4
 775          ->  Index Scan using t1_pkey on t1
 776    ->  Index Scan using t2_pkey on t2
 777          Index Cond: (id = t1.id)
 778 (12 rows)
 779
 780 /*+Leading(t3 t4 t1 t2)*/
 781 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 782 LOG:  pg_hint_plan:
 783 used hint:
 784 Leading(t3 t4 t1 t2)
 785 not used hint:
 786 duplication hint:
 787 error hint:
 788
 789                     QUERY PLAN
 790 --------------------------------------------------
 791  Nested Loop
 792    ->  Merge Join
 793          Merge Cond: (t3.id = t1.id)
 794          ->  Merge Join
 795                Merge Cond: (t3.id = t4.id)
 796                ->  Index Scan using t3_pkey on t3
 797                ->  Sort
 798                      Sort Key: t4.id
 799                      ->  Seq Scan on t4
 800          ->  Index Scan using t1_pkey on t1
 801    ->  Index Scan using t2_pkey on t2
 802          Index Cond: (id = t1.id)
 803 (12 rows)
 804
 805 /*+Leading(t3 t4 t1 t2 t1)*/
 806 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 807 INFO:  hint syntax error at or near "Leading(t3 t4 t1 t2 t1)"
 808 DETAIL:  Relation name "t1" is duplicated.
 809 LOG:  pg_hint_plan:
 810 used hint:
 811 not used hint:
 812 duplication hint:
 813 error hint:
 814 Leading(t3 t4 t1 t2 t1)
 815
 816                     QUERY PLAN
 817 --------------------------------------------------
 818  Nested Loop
 819    ->  Merge Join
 820          Merge Cond: (t1.id = t4.id)
 821          ->  Merge Join
 822                Merge Cond: (t1.id = t2.id)
 823                ->  Index Scan using t1_pkey on t1
 824                ->  Index Scan using t2_pkey on t2
 825          ->  Sort
 826                Sort Key: t4.id
 827                ->  Seq Scan on t4
 828    ->  Index Scan using t3_pkey on t3
 829          Index Cond: (id = t1.id)
 830 (12 rows)
 831
 832 /*+Leading(t3 t4 t4)*/
 833 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id;
 834 INFO:  hint syntax error at or near "Leading(t3 t4 t4)"
 835 DETAIL:  Relation name "t4" is duplicated.
 836 LOG:  pg_hint_plan:
 837 used hint:
 838 not used hint:
 839 duplication hint:
 840 error hint:
 841 Leading(t3 t4 t4)
 842
 843                     QUERY PLAN
 844 --------------------------------------------------
 845  Nested Loop
 846    ->  Merge Join
 847          Merge Cond: (t1.id = t4.id)
 848          ->  Merge Join
 849                Merge Cond: (t1.id = t2.id)
 850                ->  Index Scan using t1_pkey on t1
 851                ->  Index Scan using t2_pkey on t2
 852          ->  Sort
 853                Sort Key: t4.id
 854                ->  Seq Scan on t4
 855    ->  Index Scan using t3_pkey on t3
 856          Index Cond: (id = t1.id)
 857 (12 rows)
 858
 859 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
 860                   QUERY PLAN
 861 -----------------------------------------------
 862  Nested Loop
 863    ->  Values Scan on "*VALUES*"
 864    ->  Index Scan using t1_pkey on t1
 865          Index Cond: (id = "*VALUES*".column1)
 866 (4 rows)
 867
 868 /*+HashJoin(t1 t2)*/
 869 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
 870 LOG:  pg_hint_plan:
 871 used hint:
 872 not used hint:
 873 HashJoin(t1 t2)
 874 duplication hint:
 875 error hint:
 876
 877                   QUERY PLAN
 878 -----------------------------------------------
 879  Nested Loop
 880    ->  Values Scan on "*VALUES*"
 881    ->  Index Scan using t1_pkey on t1
 882          Index Cond: (id = "*VALUES*".column1)
 883 (4 rows)
 884
 885 /*+HashJoin(t1 *VALUES*)*/
 886 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
 887 LOG:  pg_hint_plan:
 888 used hint:
 889 HashJoin(*VALUES* t1)
 890 not used hint:
 891 duplication hint:
 892 error hint:
 893
 894                 QUERY PLAN
 895 -------------------------------------------
 896  Hash Join
 897    Hash Cond: (t1.id = "*VALUES*".column1)
 898    ->  Seq Scan on t1
 899    ->  Hash
 900          ->  Values Scan on "*VALUES*"
 901 (5 rows)
 902
 903 /*+HashJoin(t1 *VALUES*) IndexScan(t1) IndexScan(*VALUES*)*/
 904 EXPLAIN (COSTS false) SELECT * FROM t1, (VALUES(1,1),(2,2),(3,3)) AS t2(id,val) WHERE t1.id = t2.id;
 905 LOG:  pg_hint_plan:
 906 used hint:
 907 IndexScan(t1)
 908 HashJoin(*VALUES* t1)
 909 not used hint:
 910 IndexScan(*VALUES*)
 911 duplication hint:
 912 error hint:
 913
 914                 QUERY PLAN
 915 -------------------------------------------
 916  Hash Join
 917    Hash Cond: (t1.id = "*VALUES*".column1)
 918    ->  Index Scan using t1_pkey on t1
 919    ->  Hash
 920          ->  Values Scan on "*VALUES*"
 921 (5 rows)
 922
 923 -- single table scan hint test
 924 EXPLAIN (COSTS false) 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);
 925                                QUERY PLAN
 926 ------------------------------------------------------------------------
 927  Index Only Scan using t1_pkey on t1
 928    Index Cond: (id = $3)
 929    InitPlan 2 (returns $1)
 930      ->  Result
 931            InitPlan 1 (returns $0)
 932              ->  Limit
 933                    ->  Index Only Scan Backward using t1_pkey on t1 v_1
 934                          Index Cond: ((id IS NOT NULL) AND (id < 10))
 935    InitPlan 4 (returns $3)
 936      ->  Result
 937            InitPlan 3 (returns $2)
 938              ->  Limit
 939                    ->  Index Only Scan Backward using t1_pkey on t1 v_2
 940                          Index Cond: ((id IS NOT NULL) AND (id < 10))
 941 (14 rows)
 942
 943 /*+BitmapScan(v_1)*/
 944 EXPLAIN (COSTS false) 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(v_1)
 948 not used hint:
 949 duplication hint:
 950 error hint:
 951
 952                                QUERY PLAN
 953 ------------------------------------------------------------------------
 954  Index Only Scan using t1_pkey on t1
 955    Index Cond: (id = $2)
 956    InitPlan 1 (returns $0)
 957      ->  Aggregate
 958            ->  Bitmap Heap Scan on t1 v_1
 959                  Recheck Cond: (id < 10)
 960                  ->  Bitmap Index Scan on t1_pkey
 961                        Index Cond: (id < 10)
 962    InitPlan 3 (returns $2)
 963      ->  Result
 964            InitPlan 2 (returns $1)
 965              ->  Limit
 966                    ->  Index Only Scan Backward using t1_pkey on t1 v_2
 967                          Index Cond: ((id IS NOT NULL) AND (id < 10))
 968 (14 rows)
 969
 970 /*+BitmapScan(v_2)*/
 971 EXPLAIN (COSTS false) 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);
 972 LOG:  pg_hint_plan:
 973 used hint:
 974 BitmapScan(v_2)
 975 not used hint:
 976 duplication hint:
 977 error hint:
 978
 979                                QUERY PLAN
 980 ------------------------------------------------------------------------
 981  Index Only Scan using t1_pkey on t1
 982    Index Cond: (id = $2)
 983    InitPlan 2 (returns $1)
 984      ->  Result
 985            InitPlan 1 (returns $0)
 986              ->  Limit
 987                    ->  Index Only Scan Backward using t1_pkey on t1 v_1
 988                          Index Cond: ((id IS NOT NULL) AND (id < 10))
 989    InitPlan 3 (returns $2)
 990      ->  Aggregate
 991            ->  Bitmap Heap Scan on t1 v_2
 992                  Recheck Cond: (id < 10)
 993                  ->  Bitmap Index Scan on t1_pkey
 994                        Index Cond: (id < 10)
 995 (14 rows)
 996
 997 /*+BitmapScan(t1)*/
 998 EXPLAIN (COSTS false) 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);
 999 LOG:  pg_hint_plan:
1000 used hint:
1001 BitmapScan(t1)
1002 not used hint:
1003 duplication hint:
1004 error hint:
1005
1006                                QUERY PLAN
1007 ------------------------------------------------------------------------
1008  Bitmap Heap Scan on t1
1009    Recheck Cond: (id = $3)
1010    InitPlan 2 (returns $1)
1011      ->  Result
1012            InitPlan 1 (returns $0)
1013              ->  Limit
1014                    ->  Index Only Scan Backward using t1_pkey on t1 v_1
1015                          Index Cond: ((id IS NOT NULL) AND (id < 10))
1016    InitPlan 4 (returns $3)
1017      ->  Result
1018            InitPlan 3 (returns $2)
1019              ->  Limit
1020                    ->  Index Only Scan Backward using t1_pkey on t1 v_2
1021                          Index Cond: ((id IS NOT NULL) AND (id < 10))
1022    ->  Bitmap Index Scan on t1_pkey
1023          Index Cond: (id = $3)
1024 (16 rows)
1025
1026 /*+BitmapScan(v_1)BitmapScan(v_2)*/
1027 EXPLAIN (COSTS false) 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);
1028 LOG:  pg_hint_plan:
1029 used hint:
1030 BitmapScan(v_1)
1031 BitmapScan(v_2)
1032 not used hint:
1033 duplication hint:
1034 error hint:
1035
1036                     QUERY PLAN
1037 --------------------------------------------------
1038  Index Only Scan using t1_pkey on t1
1039    Index Cond: (id = $1)
1040    InitPlan 1 (returns $0)
1041      ->  Aggregate
1042            ->  Bitmap Heap Scan on t1 v_1
1043                  Recheck Cond: (id < 10)
1044                  ->  Bitmap Index Scan on t1_pkey
1045                        Index Cond: (id < 10)
1046    InitPlan 2 (returns $1)
1047      ->  Aggregate
1048            ->  Bitmap Heap Scan on t1 v_2
1049                  Recheck Cond: (id < 10)
1050                  ->  Bitmap Index Scan on t1_pkey
1051                        Index Cond: (id < 10)
1052 (14 rows)
1053
1054 /*+BitmapScan(v_1)BitmapScan(t1)*/
1055 EXPLAIN (COSTS false) 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);
1056 LOG:  pg_hint_plan:
1057 used hint:
1058 BitmapScan(t1)
1059 BitmapScan(v_1)
1060 not used hint:
1061 duplication hint:
1062 error hint:
1063
1064                                QUERY PLAN
1065 ------------------------------------------------------------------------
1066  Bitmap Heap Scan on t1
1067    Recheck Cond: (id = $2)
1068    InitPlan 1 (returns $0)
1069      ->  Aggregate
1070            ->  Bitmap Heap Scan on t1 v_1
1071                  Recheck Cond: (id < 10)
1072                  ->  Bitmap Index Scan on t1_pkey
1073                        Index Cond: (id < 10)
1074    InitPlan 3 (returns $2)
1075      ->  Result
1076            InitPlan 2 (returns $1)
1077              ->  Limit
1078                    ->  Index Only Scan Backward using t1_pkey on t1 v_2
1079                          Index Cond: ((id IS NOT NULL) AND (id < 10))
1080    ->  Bitmap Index Scan on t1_pkey
1081          Index Cond: (id = $2)
1082 (16 rows)
1083
1084 /*+BitmapScan(v_2)BitmapScan(t1)*/
1085 EXPLAIN (COSTS false) 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);
1086 LOG:  pg_hint_plan:
1087 used hint:
1088 BitmapScan(t1)
1089 BitmapScan(v_2)
1090 not used hint:
1091 duplication hint:
1092 error hint:
1093
1094                                QUERY PLAN
1095 ------------------------------------------------------------------------
1096  Bitmap Heap Scan on t1
1097    Recheck Cond: (id = $2)
1098    InitPlan 2 (returns $1)
1099      ->  Result
1100            InitPlan 1 (returns $0)
1101              ->  Limit
1102                    ->  Index Only Scan Backward using t1_pkey on t1 v_1
1103                          Index Cond: ((id IS NOT NULL) AND (id < 10))
1104    InitPlan 3 (returns $2)
1105      ->  Aggregate
1106            ->  Bitmap Heap Scan on t1 v_2
1107                  Recheck Cond: (id < 10)
1108                  ->  Bitmap Index Scan on t1_pkey
1109                        Index Cond: (id < 10)
1110    ->  Bitmap Index Scan on t1_pkey
1111          Index Cond: (id = $2)
1112 (16 rows)
1113
1114 /*+BitmapScan(v_1)BitmapScan(v_2)BitmapScan(t1)*/
1115 EXPLAIN (COSTS false) 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);
1116 LOG:  pg_hint_plan:
1117 used hint:
1118 BitmapScan(t1)
1119 BitmapScan(v_1)
1120 BitmapScan(v_2)
1121 not used hint:
1122 duplication hint:
1123 error hint:
1124
1125                     QUERY PLAN
1126 --------------------------------------------------
1127  Bitmap Heap Scan on t1
1128    Recheck Cond: (id = $1)
1129    InitPlan 1 (returns $0)
1130      ->  Aggregate
1131            ->  Bitmap Heap Scan on t1 v_1
1132                  Recheck Cond: (id < 10)
1133                  ->  Bitmap Index Scan on t1_pkey
1134                        Index Cond: (id < 10)
1135    InitPlan 2 (returns $1)
1136      ->  Aggregate
1137            ->  Bitmap Heap Scan on t1 v_2
1138                  Recheck Cond: (id < 10)
1139                  ->  Bitmap Index Scan on t1_pkey
1140                        Index Cond: (id < 10)
1141    ->  Bitmap Index Scan on t1_pkey
1142          Index Cond: (id = $1)
1143 (16 rows)
1144
1145 -- full scan hint pattern test
1146 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1147             QUERY PLAN
1148 -----------------------------------
1149  Tid Scan on t1
1150    TID Cond: (ctid = '(1,1)'::tid)
1151    Filter: (id < 10)
1152 (3 rows)
1153
1154 /*+SeqScan(t1)*/
1155 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1156 LOG:  pg_hint_plan:
1157 used hint:
1158 SeqScan(t1)
1159 not used hint:
1160 duplication hint:
1161 error hint:
1162
1163                    QUERY PLAN
1164 -------------------------------------------------
1165  Seq Scan on t1
1166    Filter: ((id < 10) AND (ctid = '(1,1)'::tid))
1167 (2 rows)
1168
1169 /*+IndexScan(t1)*/
1170 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1171 LOG:  pg_hint_plan:
1172 used hint:
1173 IndexScan(t1)
1174 not used hint:
1175 duplication hint:
1176 error hint:
1177
1178            QUERY PLAN
1179 ---------------------------------
1180  Index Scan using t1_pkey on t1
1181    Index Cond: (id < 10)
1182    Filter: (ctid = '(1,1)'::tid)
1183 (3 rows)
1184
1185 /*+BitmapScan(t1)*/
1186 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1187 LOG:  pg_hint_plan:
1188 used hint:
1189 BitmapScan(t1)
1190 not used hint:
1191 duplication hint:
1192 error hint:
1193
1194              QUERY PLAN
1195 ------------------------------------
1196  Bitmap Heap Scan on t1
1197    Recheck Cond: (id < 10)
1198    Filter: (ctid = '(1,1)'::tid)
1199    ->  Bitmap Index Scan on t1_pkey
1200          Index Cond: (id < 10)
1201 (5 rows)
1202
1203 /*+TidScan(t1)*/
1204 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1205 LOG:  pg_hint_plan:
1206 used hint:
1207 TidScan(t1)
1208 not used hint:
1209 duplication hint:
1210 error hint:
1211
1212             QUERY PLAN
1213 -----------------------------------
1214  Tid Scan on t1
1215    TID Cond: (ctid = '(1,1)'::tid)
1216    Filter: (id < 10)
1217 (3 rows)
1218
1219 /*+NoSeqScan(t1)*/
1220 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1221 LOG:  pg_hint_plan:
1222 used hint:
1223 NoSeqScan(t1)
1224 not used hint:
1225 duplication hint:
1226 error hint:
1227
1228             QUERY PLAN
1229 -----------------------------------
1230  Tid Scan on t1
1231    TID Cond: (ctid = '(1,1)'::tid)
1232    Filter: (id < 10)
1233 (3 rows)
1234
1235 /*+NoIndexScan(t1)*/
1236 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1237 LOG:  pg_hint_plan:
1238 used hint:
1239 NoIndexScan(t1)
1240 not used hint:
1241 duplication hint:
1242 error hint:
1243
1244             QUERY PLAN
1245 -----------------------------------
1246  Tid Scan on t1
1247    TID Cond: (ctid = '(1,1)'::tid)
1248    Filter: (id < 10)
1249 (3 rows)
1250
1251 /*+NoBitmapScan(t1)*/
1252 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1253 LOG:  pg_hint_plan:
1254 used hint:
1255 NoBitmapScan(t1)
1256 not used hint:
1257 duplication hint:
1258 error hint:
1259
1260             QUERY PLAN
1261 -----------------------------------
1262  Tid Scan on t1
1263    TID Cond: (ctid = '(1,1)'::tid)
1264    Filter: (id < 10)
1265 (3 rows)
1266
1267 /*+NoTidScan(t1)*/
1268 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE id < 10 AND ctid = '(1,1)';
1269 LOG:  pg_hint_plan:
1270 used hint:
1271 NoTidScan(t1)
1272 not used hint:
1273 duplication hint:
1274 error hint:
1275
1276            QUERY PLAN
1277 ---------------------------------
1278  Index Scan using t1_pkey on t1
1279    Index Cond: (id < 10)
1280    Filter: (ctid = '(1,1)'::tid)
1281 (3 rows)
1282
1283 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1284                QUERY PLAN
1285 -----------------------------------------
1286  Nested Loop
1287    Join Filter: (t1.id = t2.id)
1288    ->  Tid Scan on t1
1289          TID Cond: (ctid = '(1,1)'::tid)
1290    ->  Tid Scan on t2
1291          TID Cond: (ctid = '(1,1)'::tid)
1292 (6 rows)
1293
1294 /*+SeqScan(t1)*/
1295 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1296 LOG:  pg_hint_plan:
1297 used hint:
1298 SeqScan(t1)
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(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(t2)
1318 not used hint:
1319 duplication hint:
1320 error hint:
1321
1322                QUERY PLAN
1323 -----------------------------------------
1324  Nested Loop
1325    Join Filter: (t1.id = t2.id)
1326    ->  Tid Scan on t1
1327          TID Cond: (ctid = '(1,1)'::tid)
1328    ->  Seq Scan on t2
1329          Filter: (ctid = '(1,1)'::tid)
1330 (6 rows)
1331
1332 /*+SeqScan(t1) SeqScan(t2)*/
1333 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1334 LOG:  pg_hint_plan:
1335 used hint:
1336 SeqScan(t1)
1337 SeqScan(t2)
1338 not used hint:
1339 duplication hint:
1340 error hint:
1341
1342               QUERY PLAN
1343 ---------------------------------------
1344  Nested Loop
1345    Join Filter: (t1.id = t2.id)
1346    ->  Seq Scan on t1
1347          Filter: (ctid = '(1,1)'::tid)
1348    ->  Seq Scan on t2
1349          Filter: (ctid = '(1,1)'::tid)
1350 (6 rows)
1351
1352 /*+SeqScan(t1) IndexScan(t2)*/
1353 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1354 LOG:  pg_hint_plan:
1355 used hint:
1356 SeqScan(t1)
1357 IndexScan(t2)
1358 not used hint:
1359 duplication hint:
1360 error hint:
1361
1362               QUERY PLAN
1363 ---------------------------------------
1364  Nested Loop
1365    ->  Seq Scan on t1
1366          Filter: (ctid = '(1,1)'::tid)
1367    ->  Index Scan using t2_pkey on t2
1368          Index Cond: (id = t1.id)
1369          Filter: (ctid = '(1,1)'::tid)
1370 (6 rows)
1371
1372 /*+SeqScan(t1) BitmapScan(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 SeqScan(t1)
1377 BitmapScan(t2)
1378 not used hint:
1379 duplication hint:
1380 error hint:
1381
1382                 QUERY PLAN
1383 ------------------------------------------
1384  Nested Loop
1385    ->  Seq Scan on t1
1386          Filter: (ctid = '(1,1)'::tid)
1387    ->  Bitmap Heap Scan on t2
1388          Recheck Cond: (id = t1.id)
1389          Filter: (ctid = '(1,1)'::tid)
1390          ->  Bitmap Index Scan on t2_pkey
1391                Index Cond: (id = t1.id)
1392 (8 rows)
1393
1394 /*+SeqScan(t1) TidScan(t2)*/
1395 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1396 LOG:  pg_hint_plan:
1397 used hint:
1398 SeqScan(t1)
1399 TidScan(t2)
1400 not used hint:
1401 duplication hint:
1402 error hint:
1403
1404                QUERY PLAN
1405 -----------------------------------------
1406  Nested Loop
1407    Join Filter: (t1.id = t2.id)
1408    ->  Seq Scan on t1
1409          Filter: (ctid = '(1,1)'::tid)
1410    ->  Tid Scan on t2
1411          TID Cond: (ctid = '(1,1)'::tid)
1412 (6 rows)
1413
1414 /*+SeqScan(t1) NoSeqScan(t2)*/
1415 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1416 LOG:  pg_hint_plan:
1417 used hint:
1418 SeqScan(t1)
1419 NoSeqScan(t2)
1420 not used hint:
1421 duplication hint:
1422 error hint:
1423
1424                QUERY PLAN
1425 -----------------------------------------
1426  Nested Loop
1427    Join Filter: (t1.id = t2.id)
1428    ->  Seq Scan on t1
1429          Filter: (ctid = '(1,1)'::tid)
1430    ->  Tid Scan on t2
1431          TID Cond: (ctid = '(1,1)'::tid)
1432 (6 rows)
1433
1434 /*+SeqScan(t1) NoIndexScan(t2)*/
1435 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1436 LOG:  pg_hint_plan:
1437 used hint:
1438 SeqScan(t1)
1439 NoIndexScan(t2)
1440 not used hint:
1441 duplication hint:
1442 error hint:
1443
1444                QUERY PLAN
1445 -----------------------------------------
1446  Nested Loop
1447    Join Filter: (t1.id = t2.id)
1448    ->  Seq Scan on t1
1449          Filter: (ctid = '(1,1)'::tid)
1450    ->  Tid Scan on t2
1451          TID Cond: (ctid = '(1,1)'::tid)
1452 (6 rows)
1453
1454 /*+SeqScan(t1) NoBitmapScan(t2)*/
1455 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1456 LOG:  pg_hint_plan:
1457 used hint:
1458 SeqScan(t1)
1459 NoBitmapScan(t2)
1460 not used hint:
1461 duplication hint:
1462 error hint:
1463
1464                QUERY PLAN
1465 -----------------------------------------
1466  Nested Loop
1467    Join Filter: (t1.id = t2.id)
1468    ->  Seq Scan on t1
1469          Filter: (ctid = '(1,1)'::tid)
1470    ->  Tid Scan on t2
1471          TID Cond: (ctid = '(1,1)'::tid)
1472 (6 rows)
1473
1474 /*+SeqScan(t1) NoTidScan(t2)*/
1475 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1476 LOG:  pg_hint_plan:
1477 used hint:
1478 SeqScan(t1)
1479 NoTidScan(t2)
1480 not used hint:
1481 duplication hint:
1482 error hint:
1483
1484               QUERY PLAN
1485 ---------------------------------------
1486  Nested Loop
1487    ->  Seq Scan on t1
1488          Filter: (ctid = '(1,1)'::tid)
1489    ->  Index Scan using t2_pkey on t2
1490          Index Cond: (id = t1.id)
1491          Filter: (ctid = '(1,1)'::tid)
1492 (6 rows)
1493
1494 /*+IndexScan(t1)*/
1495 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1496 LOG:  pg_hint_plan:
1497 used hint:
1498 IndexScan(t1)
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(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(t2)
1518 not used hint:
1519 duplication hint:
1520 error hint:
1521
1522                QUERY PLAN
1523 -----------------------------------------
1524  Nested Loop
1525    ->  Tid Scan on t1
1526          TID Cond: (ctid = '(1,1)'::tid)
1527    ->  Index Scan using t2_pkey on t2
1528          Index Cond: (id = t1.id)
1529          Filter: (ctid = '(1,1)'::tid)
1530 (6 rows)
1531
1532 /*+IndexScan(t1) SeqScan(t2)*/
1533 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1534 LOG:  pg_hint_plan:
1535 used hint:
1536 IndexScan(t1)
1537 SeqScan(t2)
1538 not used hint:
1539 duplication hint:
1540 error hint:
1541
1542               QUERY PLAN
1543 ---------------------------------------
1544  Nested Loop
1545    ->  Seq Scan on t2
1546          Filter: (ctid = '(1,1)'::tid)
1547    ->  Index Scan using t1_pkey on t1
1548          Index Cond: (id = t2.id)
1549          Filter: (ctid = '(1,1)'::tid)
1550 (6 rows)
1551
1552 /*+IndexScan(t1) IndexScan(t2)*/
1553 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1554 LOG:  pg_hint_plan:
1555 used hint:
1556 IndexScan(t1)
1557 IndexScan(t2)
1558 not used hint:
1559 duplication hint:
1560 error hint:
1561
1562               QUERY PLAN
1563 ---------------------------------------
1564  Nested Loop
1565    ->  Index Scan using t2_pkey on t2
1566          Filter: (ctid = '(1,1)'::tid)
1567    ->  Index Scan using t1_pkey on t1
1568          Index Cond: (id = t2.id)
1569          Filter: (ctid = '(1,1)'::tid)
1570 (6 rows)
1571
1572 /*+IndexScan(t1) BitmapScan(t2)*/
1573 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1574 LOG:  pg_hint_plan:
1575 used hint:
1576 IndexScan(t1)
1577 BitmapScan(t2)
1578 not used hint:
1579 duplication hint:
1580 error hint:
1581
1582                 QUERY PLAN
1583 ------------------------------------------
1584  Nested Loop
1585    ->  Index Scan using t1_pkey on t1
1586          Filter: (ctid = '(1,1)'::tid)
1587    ->  Bitmap Heap Scan on t2
1588          Recheck Cond: (id = t1.id)
1589          Filter: (ctid = '(1,1)'::tid)
1590          ->  Bitmap Index Scan on t2_pkey
1591                Index Cond: (id = t1.id)
1592 (8 rows)
1593
1594 /*+IndexScan(t1) TidScan(t2)*/
1595 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1596 LOG:  pg_hint_plan:
1597 used hint:
1598 IndexScan(t1)
1599 TidScan(t2)
1600 not used hint:
1601 duplication hint:
1602 error hint:
1603
1604                QUERY PLAN
1605 -----------------------------------------
1606  Nested Loop
1607    ->  Tid Scan on t2
1608          TID Cond: (ctid = '(1,1)'::tid)
1609    ->  Index Scan using t1_pkey on t1
1610          Index Cond: (id = t2.id)
1611          Filter: (ctid = '(1,1)'::tid)
1612 (6 rows)
1613
1614 /*+IndexScan(t1) NoSeqScan(t2)*/
1615 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1616 LOG:  pg_hint_plan:
1617 used hint:
1618 IndexScan(t1)
1619 NoSeqScan(t2)
1620 not used hint:
1621 duplication hint:
1622 error hint:
1623
1624                QUERY PLAN
1625 -----------------------------------------
1626  Nested Loop
1627    ->  Tid Scan on t2
1628          TID Cond: (ctid = '(1,1)'::tid)
1629    ->  Index Scan using t1_pkey on t1
1630          Index Cond: (id = t2.id)
1631          Filter: (ctid = '(1,1)'::tid)
1632 (6 rows)
1633
1634 /*+IndexScan(t1) NoIndexScan(t2)*/
1635 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1636 LOG:  pg_hint_plan:
1637 used hint:
1638 IndexScan(t1)
1639 NoIndexScan(t2)
1640 not used hint:
1641 duplication hint:
1642 error hint:
1643
1644                QUERY PLAN
1645 -----------------------------------------
1646  Nested Loop
1647    ->  Tid Scan on t2
1648          TID Cond: (ctid = '(1,1)'::tid)
1649    ->  Index Scan using t1_pkey on t1
1650          Index Cond: (id = t2.id)
1651          Filter: (ctid = '(1,1)'::tid)
1652 (6 rows)
1653
1654 /*+IndexScan(t1) NoBitmapScan(t2)*/
1655 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1656 LOG:  pg_hint_plan:
1657 used hint:
1658 IndexScan(t1)
1659 NoBitmapScan(t2)
1660 not used hint:
1661 duplication hint:
1662 error hint:
1663
1664                QUERY PLAN
1665 -----------------------------------------
1666  Nested Loop
1667    ->  Tid Scan on t2
1668          TID Cond: (ctid = '(1,1)'::tid)
1669    ->  Index Scan using t1_pkey on t1
1670          Index Cond: (id = t2.id)
1671          Filter: (ctid = '(1,1)'::tid)
1672 (6 rows)
1673
1674 /*+IndexScan(t1) NoTidScan(t2)*/
1675 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1676 LOG:  pg_hint_plan:
1677 used hint:
1678 IndexScan(t1)
1679 NoTidScan(t2)
1680 not used hint:
1681 duplication hint:
1682 error hint:
1683
1684               QUERY PLAN
1685 ---------------------------------------
1686  Nested Loop
1687    ->  Seq Scan on t2
1688          Filter: (ctid = '(1,1)'::tid)
1689    ->  Index Scan using t1_pkey on t1
1690          Index Cond: (id = t2.id)
1691          Filter: (ctid = '(1,1)'::tid)
1692 (6 rows)
1693
1694 /*+BitmapScan(t1)*/
1695 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1696 LOG:  pg_hint_plan:
1697 used hint:
1698 BitmapScan(t1)
1699 not used hint:
1700 duplication hint:
1701 error hint:
1702
1703                 QUERY PLAN
1704 ------------------------------------------
1705  Nested Loop
1706    ->  Tid Scan on t2
1707          TID Cond: (ctid = '(1,1)'::tid)
1708    ->  Bitmap Heap Scan on t1
1709          Recheck Cond: (id = t2.id)
1710          Filter: (ctid = '(1,1)'::tid)
1711          ->  Bitmap Index Scan on t1_pkey
1712                Index Cond: (id = t2.id)
1713 (8 rows)
1714
1715 /*+BitmapScan(t2)*/
1716 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1717 LOG:  pg_hint_plan:
1718 used hint:
1719 BitmapScan(t2)
1720 not used hint:
1721 duplication hint:
1722 error hint:
1723
1724                 QUERY PLAN
1725 ------------------------------------------
1726  Nested Loop
1727    ->  Tid Scan on t1
1728          TID Cond: (ctid = '(1,1)'::tid)
1729    ->  Bitmap Heap Scan on t2
1730          Recheck Cond: (id = t1.id)
1731          Filter: (ctid = '(1,1)'::tid)
1732          ->  Bitmap Index Scan on t2_pkey
1733                Index Cond: (id = t1.id)
1734 (8 rows)
1735
1736 /*+BitmapScan(t2)*/
1737 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1738 LOG:  pg_hint_plan:
1739 used hint:
1740 BitmapScan(t2)
1741 not used hint:
1742 duplication hint:
1743 error hint:
1744
1745                 QUERY PLAN
1746 ------------------------------------------
1747  Nested Loop
1748    ->  Tid Scan on t1
1749          TID Cond: (ctid = '(1,1)'::tid)
1750    ->  Bitmap Heap Scan on t2
1751          Recheck Cond: (id = t1.id)
1752          Filter: (ctid = '(1,1)'::tid)
1753          ->  Bitmap Index Scan on t2_pkey
1754                Index Cond: (id = t1.id)
1755 (8 rows)
1756
1757 /*+BitmapScan(t1) SeqScan(t2)*/
1758 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1759 LOG:  pg_hint_plan:
1760 used hint:
1761 BitmapScan(t1)
1762 SeqScan(t2)
1763 not used hint:
1764 duplication hint:
1765 error hint:
1766
1767                 QUERY PLAN
1768 ------------------------------------------
1769  Nested Loop
1770    ->  Seq Scan on t2
1771          Filter: (ctid = '(1,1)'::tid)
1772    ->  Bitmap Heap Scan on t1
1773          Recheck Cond: (id = t2.id)
1774          Filter: (ctid = '(1,1)'::tid)
1775          ->  Bitmap Index Scan on t1_pkey
1776                Index Cond: (id = t2.id)
1777 (8 rows)
1778
1779 /*+BitmapScan(t1) IndexScan(t2)*/
1780 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1781 LOG:  pg_hint_plan:
1782 used hint:
1783 BitmapScan(t1)
1784 IndexScan(t2)
1785 not used hint:
1786 duplication hint:
1787 error hint:
1788
1789                 QUERY PLAN
1790 ------------------------------------------
1791  Nested Loop
1792    ->  Index Scan using t2_pkey on t2
1793          Filter: (ctid = '(1,1)'::tid)
1794    ->  Bitmap Heap Scan on t1
1795          Recheck Cond: (id = t2.id)
1796          Filter: (ctid = '(1,1)'::tid)
1797          ->  Bitmap Index Scan on t1_pkey
1798                Index Cond: (id = t2.id)
1799 (8 rows)
1800
1801 /*+BitmapScan(t1) BitmapScan(t2)*/
1802 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1803 LOG:  pg_hint_plan:
1804 used hint:
1805 BitmapScan(t1)
1806 BitmapScan(t2)
1807 not used hint:
1808 duplication hint:
1809 error hint:
1810
1811                 QUERY PLAN
1812 ------------------------------------------
1813  Nested Loop
1814    ->  Index Scan using t2_pkey on t2
1815          Filter: (ctid = '(1,1)'::tid)
1816    ->  Bitmap Heap Scan on t1
1817          Recheck Cond: (id = t2.id)
1818          Filter: (ctid = '(1,1)'::tid)
1819          ->  Bitmap Index Scan on t1_pkey
1820                Index Cond: (id = t2.id)
1821 (8 rows)
1822
1823 /*+BitmapScan(t1) TidScan(t2)*/
1824 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1825 LOG:  pg_hint_plan:
1826 used hint:
1827 BitmapScan(t1)
1828 TidScan(t2)
1829 not used hint:
1830 duplication hint:
1831 error hint:
1832
1833                 QUERY PLAN
1834 ------------------------------------------
1835  Nested Loop
1836    ->  Tid Scan on t2
1837          TID Cond: (ctid = '(1,1)'::tid)
1838    ->  Bitmap Heap Scan on t1
1839          Recheck Cond: (id = t2.id)
1840          Filter: (ctid = '(1,1)'::tid)
1841          ->  Bitmap Index Scan on t1_pkey
1842                Index Cond: (id = t2.id)
1843 (8 rows)
1844
1845 /*+BitmapScan(t1) NoSeqScan(t2)*/
1846 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1847 LOG:  pg_hint_plan:
1848 used hint:
1849 BitmapScan(t1)
1850 NoSeqScan(t2)
1851 not used hint:
1852 duplication hint:
1853 error hint:
1854
1855                 QUERY PLAN
1856 ------------------------------------------
1857  Nested Loop
1858    ->  Tid Scan on t2
1859          TID Cond: (ctid = '(1,1)'::tid)
1860    ->  Bitmap Heap Scan on t1
1861          Recheck Cond: (id = t2.id)
1862          Filter: (ctid = '(1,1)'::tid)
1863          ->  Bitmap Index Scan on t1_pkey
1864                Index Cond: (id = t2.id)
1865 (8 rows)
1866
1867 /*+BitmapScan(t1) NoIndexScan(t2)*/
1868 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1869 LOG:  pg_hint_plan:
1870 used hint:
1871 BitmapScan(t1)
1872 NoIndexScan(t2)
1873 not used hint:
1874 duplication hint:
1875 error hint:
1876
1877                 QUERY PLAN
1878 ------------------------------------------
1879  Nested Loop
1880    ->  Tid Scan on t2
1881          TID Cond: (ctid = '(1,1)'::tid)
1882    ->  Bitmap Heap Scan on t1
1883          Recheck Cond: (id = t2.id)
1884          Filter: (ctid = '(1,1)'::tid)
1885          ->  Bitmap Index Scan on t1_pkey
1886                Index Cond: (id = t2.id)
1887 (8 rows)
1888
1889 /*+BitmapScan(t1) NoBitmapScan(t2)*/
1890 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1891 LOG:  pg_hint_plan:
1892 used hint:
1893 BitmapScan(t1)
1894 NoBitmapScan(t2)
1895 not used hint:
1896 duplication hint:
1897 error hint:
1898
1899                 QUERY PLAN
1900 ------------------------------------------
1901  Nested Loop
1902    ->  Tid Scan on t2
1903          TID Cond: (ctid = '(1,1)'::tid)
1904    ->  Bitmap Heap Scan on t1
1905          Recheck Cond: (id = t2.id)
1906          Filter: (ctid = '(1,1)'::tid)
1907          ->  Bitmap Index Scan on t1_pkey
1908                Index Cond: (id = t2.id)
1909 (8 rows)
1910
1911 /*+BitmapScan(t1) NoTidScan(t2)*/
1912 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1913 LOG:  pg_hint_plan:
1914 used hint:
1915 BitmapScan(t1)
1916 NoTidScan(t2)
1917 not used hint:
1918 duplication hint:
1919 error hint:
1920
1921                 QUERY PLAN
1922 ------------------------------------------
1923  Nested Loop
1924    ->  Seq Scan on t2
1925          Filter: (ctid = '(1,1)'::tid)
1926    ->  Bitmap Heap Scan on t1
1927          Recheck Cond: (id = t2.id)
1928          Filter: (ctid = '(1,1)'::tid)
1929          ->  Bitmap Index Scan on t1_pkey
1930                Index Cond: (id = t2.id)
1931 (8 rows)
1932
1933 /*+TidScan(t1)*/
1934 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1935 LOG:  pg_hint_plan:
1936 used hint:
1937 TidScan(t1)
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(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(t2)
1957 not used hint:
1958 duplication hint:
1959 error hint:
1960
1961                QUERY PLAN
1962 -----------------------------------------
1963  Nested Loop
1964    Join Filter: (t1.id = t2.id)
1965    ->  Tid Scan on t1
1966          TID Cond: (ctid = '(1,1)'::tid)
1967    ->  Tid Scan on t2
1968          TID Cond: (ctid = '(1,1)'::tid)
1969 (6 rows)
1970
1971 /*+TidScan(t1) SeqScan(t2)*/
1972 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1973 LOG:  pg_hint_plan:
1974 used hint:
1975 TidScan(t1)
1976 SeqScan(t2)
1977 not used hint:
1978 duplication hint:
1979 error hint:
1980
1981                QUERY PLAN
1982 -----------------------------------------
1983  Nested Loop
1984    Join Filter: (t1.id = t2.id)
1985    ->  Tid Scan on t1
1986          TID Cond: (ctid = '(1,1)'::tid)
1987    ->  Seq Scan on t2
1988          Filter: (ctid = '(1,1)'::tid)
1989 (6 rows)
1990
1991 /*+TidScan(t1) IndexScan(t2)*/
1992 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
1993 LOG:  pg_hint_plan:
1994 used hint:
1995 TidScan(t1)
1996 IndexScan(t2)
1997 not used hint:
1998 duplication hint:
1999 error hint:
2000
2001                QUERY PLAN
2002 -----------------------------------------
2003  Nested Loop
2004    ->  Tid Scan on t1
2005          TID Cond: (ctid = '(1,1)'::tid)
2006    ->  Index Scan using t2_pkey on t2
2007          Index Cond: (id = t1.id)
2008          Filter: (ctid = '(1,1)'::tid)
2009 (6 rows)
2010
2011 /*+TidScan(t1) BitmapScan(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 TidScan(t1)
2016 BitmapScan(t2)
2017 not used hint:
2018 duplication hint:
2019 error hint:
2020
2021                 QUERY PLAN
2022 ------------------------------------------
2023  Nested Loop
2024    ->  Tid Scan on t1
2025          TID Cond: (ctid = '(1,1)'::tid)
2026    ->  Bitmap Heap Scan on t2
2027          Recheck Cond: (id = t1.id)
2028          Filter: (ctid = '(1,1)'::tid)
2029          ->  Bitmap Index Scan on t2_pkey
2030                Index Cond: (id = t1.id)
2031 (8 rows)
2032
2033 /*+TidScan(t1) TidScan(t2)*/
2034 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2035 LOG:  pg_hint_plan:
2036 used hint:
2037 TidScan(t1)
2038 TidScan(t2)
2039 not used hint:
2040 duplication hint:
2041 error hint:
2042
2043                QUERY PLAN
2044 -----------------------------------------
2045  Nested Loop
2046    Join Filter: (t1.id = t2.id)
2047    ->  Tid Scan on t1
2048          TID Cond: (ctid = '(1,1)'::tid)
2049    ->  Tid Scan on t2
2050          TID Cond: (ctid = '(1,1)'::tid)
2051 (6 rows)
2052
2053 /*+TidScan(t1) NoSeqScan(t2)*/
2054 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2055 LOG:  pg_hint_plan:
2056 used hint:
2057 TidScan(t1)
2058 NoSeqScan(t2)
2059 not used hint:
2060 duplication hint:
2061 error hint:
2062
2063                QUERY PLAN
2064 -----------------------------------------
2065  Nested Loop
2066    Join Filter: (t1.id = t2.id)
2067    ->  Tid Scan on t1
2068          TID Cond: (ctid = '(1,1)'::tid)
2069    ->  Tid Scan on t2
2070          TID Cond: (ctid = '(1,1)'::tid)
2071 (6 rows)
2072
2073 /*+TidScan(t1) NoIndexScan(t2)*/
2074 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2075 LOG:  pg_hint_plan:
2076 used hint:
2077 TidScan(t1)
2078 NoIndexScan(t2)
2079 not used hint:
2080 duplication hint:
2081 error hint:
2082
2083                QUERY PLAN
2084 -----------------------------------------
2085  Nested Loop
2086    Join Filter: (t1.id = t2.id)
2087    ->  Tid Scan on t1
2088          TID Cond: (ctid = '(1,1)'::tid)
2089    ->  Tid Scan on t2
2090          TID Cond: (ctid = '(1,1)'::tid)
2091 (6 rows)
2092
2093 /*+TidScan(t1) NoBitmapScan(t2)*/
2094 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2095 LOG:  pg_hint_plan:
2096 used hint:
2097 TidScan(t1)
2098 NoBitmapScan(t2)
2099 not used hint:
2100 duplication hint:
2101 error hint:
2102
2103                QUERY PLAN
2104 -----------------------------------------
2105  Nested Loop
2106    Join Filter: (t1.id = t2.id)
2107    ->  Tid Scan on t1
2108          TID Cond: (ctid = '(1,1)'::tid)
2109    ->  Tid Scan on t2
2110          TID Cond: (ctid = '(1,1)'::tid)
2111 (6 rows)
2112
2113 /*+TidScan(t1) NoTidScan(t2)*/
2114 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2115 LOG:  pg_hint_plan:
2116 used hint:
2117 TidScan(t1)
2118 NoTidScan(t2)
2119 not used hint:
2120 duplication hint:
2121 error hint:
2122
2123                QUERY PLAN
2124 -----------------------------------------
2125  Nested Loop
2126    ->  Tid Scan on t1
2127          TID Cond: (ctid = '(1,1)'::tid)
2128    ->  Index Scan using t2_pkey on t2
2129          Index Cond: (id = t1.id)
2130          Filter: (ctid = '(1,1)'::tid)
2131 (6 rows)
2132
2133 /*+NoSeqScan(t1)*/
2134 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2135 LOG:  pg_hint_plan:
2136 used hint:
2137 NoSeqScan(t1)
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(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(t2)
2157 not used hint:
2158 duplication hint:
2159 error hint:
2160
2161                QUERY PLAN
2162 -----------------------------------------
2163  Nested Loop
2164    Join Filter: (t1.id = t2.id)
2165    ->  Tid Scan on t1
2166          TID Cond: (ctid = '(1,1)'::tid)
2167    ->  Tid Scan on t2
2168          TID Cond: (ctid = '(1,1)'::tid)
2169 (6 rows)
2170
2171 /*+NoSeqScan(t1) SeqScan(t2)*/
2172 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2173 LOG:  pg_hint_plan:
2174 used hint:
2175 NoSeqScan(t1)
2176 SeqScan(t2)
2177 not used hint:
2178 duplication hint:
2179 error hint:
2180
2181                QUERY PLAN
2182 -----------------------------------------
2183  Nested Loop
2184    Join Filter: (t1.id = t2.id)
2185    ->  Tid Scan on t1
2186          TID Cond: (ctid = '(1,1)'::tid)
2187    ->  Seq Scan on t2
2188          Filter: (ctid = '(1,1)'::tid)
2189 (6 rows)
2190
2191 /*+NoSeqScan(t1) IndexScan(t2)*/
2192 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2193 LOG:  pg_hint_plan:
2194 used hint:
2195 NoSeqScan(t1)
2196 IndexScan(t2)
2197 not used hint:
2198 duplication hint:
2199 error hint:
2200
2201                QUERY PLAN
2202 -----------------------------------------
2203  Nested Loop
2204    ->  Tid Scan on t1
2205          TID Cond: (ctid = '(1,1)'::tid)
2206    ->  Index Scan using t2_pkey on t2
2207          Index Cond: (id = t1.id)
2208          Filter: (ctid = '(1,1)'::tid)
2209 (6 rows)
2210
2211 /*+NoSeqScan(t1) BitmapScan(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 NoSeqScan(t1)
2216 BitmapScan(t2)
2217 not used hint:
2218 duplication hint:
2219 error hint:
2220
2221                 QUERY PLAN
2222 ------------------------------------------
2223  Nested Loop
2224    ->  Tid Scan on t1
2225          TID Cond: (ctid = '(1,1)'::tid)
2226    ->  Bitmap Heap Scan on t2
2227          Recheck Cond: (id = t1.id)
2228          Filter: (ctid = '(1,1)'::tid)
2229          ->  Bitmap Index Scan on t2_pkey
2230                Index Cond: (id = t1.id)
2231 (8 rows)
2232
2233 /*+NoSeqScan(t1) TidScan(t2)*/
2234 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2235 LOG:  pg_hint_plan:
2236 used hint:
2237 NoSeqScan(t1)
2238 TidScan(t2)
2239 not used hint:
2240 duplication hint:
2241 error hint:
2242
2243                QUERY PLAN
2244 -----------------------------------------
2245  Nested Loop
2246    Join Filter: (t1.id = t2.id)
2247    ->  Tid Scan on t1
2248          TID Cond: (ctid = '(1,1)'::tid)
2249    ->  Tid Scan on t2
2250          TID Cond: (ctid = '(1,1)'::tid)
2251 (6 rows)
2252
2253 /*+NoSeqScan(t1) NoSeqScan(t2)*/
2254 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2255 LOG:  pg_hint_plan:
2256 used hint:
2257 NoSeqScan(t1)
2258 NoSeqScan(t2)
2259 not used hint:
2260 duplication hint:
2261 error hint:
2262
2263                QUERY PLAN
2264 -----------------------------------------
2265  Nested Loop
2266    Join Filter: (t1.id = t2.id)
2267    ->  Tid Scan on t1
2268          TID Cond: (ctid = '(1,1)'::tid)
2269    ->  Tid Scan on t2
2270          TID Cond: (ctid = '(1,1)'::tid)
2271 (6 rows)
2272
2273 /*+NoSeqScan(t1) NoIndexScan(t2)*/
2274 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2275 LOG:  pg_hint_plan:
2276 used hint:
2277 NoSeqScan(t1)
2278 NoIndexScan(t2)
2279 not used hint:
2280 duplication hint:
2281 error hint:
2282
2283                QUERY PLAN
2284 -----------------------------------------
2285  Nested Loop
2286    Join Filter: (t1.id = t2.id)
2287    ->  Tid Scan on t1
2288          TID Cond: (ctid = '(1,1)'::tid)
2289    ->  Tid Scan on t2
2290          TID Cond: (ctid = '(1,1)'::tid)
2291 (6 rows)
2292
2293 /*+NoSeqScan(t1) NoBitmapScan(t2)*/
2294 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2295 LOG:  pg_hint_plan:
2296 used hint:
2297 NoSeqScan(t1)
2298 NoBitmapScan(t2)
2299 not used hint:
2300 duplication hint:
2301 error hint:
2302
2303                QUERY PLAN
2304 -----------------------------------------
2305  Nested Loop
2306    Join Filter: (t1.id = t2.id)
2307    ->  Tid Scan on t1
2308          TID Cond: (ctid = '(1,1)'::tid)
2309    ->  Tid Scan on t2
2310          TID Cond: (ctid = '(1,1)'::tid)
2311 (6 rows)
2312
2313 /*+NoSeqScan(t1) NoTidScan(t2)*/
2314 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2315 LOG:  pg_hint_plan:
2316 used hint:
2317 NoSeqScan(t1)
2318 NoTidScan(t2)
2319 not used hint:
2320 duplication hint:
2321 error hint:
2322
2323                QUERY PLAN
2324 -----------------------------------------
2325  Nested Loop
2326    ->  Tid Scan on t1
2327          TID Cond: (ctid = '(1,1)'::tid)
2328    ->  Index Scan using t2_pkey on t2
2329          Index Cond: (id = t1.id)
2330          Filter: (ctid = '(1,1)'::tid)
2331 (6 rows)
2332
2333 /*+NoIndexScan(t1)*/
2334 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2335 LOG:  pg_hint_plan:
2336 used hint:
2337 NoIndexScan(t1)
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(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(t2)
2357 not used hint:
2358 duplication hint:
2359 error hint:
2360
2361                QUERY PLAN
2362 -----------------------------------------
2363  Nested Loop
2364    Join Filter: (t1.id = t2.id)
2365    ->  Tid Scan on t1
2366          TID Cond: (ctid = '(1,1)'::tid)
2367    ->  Tid Scan on t2
2368          TID Cond: (ctid = '(1,1)'::tid)
2369 (6 rows)
2370
2371 /*+NoIndexScan(t1) SeqScan(t2)*/
2372 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2373 LOG:  pg_hint_plan:
2374 used hint:
2375 NoIndexScan(t1)
2376 SeqScan(t2)
2377 not used hint:
2378 duplication hint:
2379 error hint:
2380
2381                QUERY PLAN
2382 -----------------------------------------
2383  Nested Loop
2384    Join Filter: (t1.id = t2.id)
2385    ->  Tid Scan on t1
2386          TID Cond: (ctid = '(1,1)'::tid)
2387    ->  Seq Scan on t2
2388          Filter: (ctid = '(1,1)'::tid)
2389 (6 rows)
2390
2391 /*+NoIndexScan(t1) IndexScan(t2)*/
2392 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2393 LOG:  pg_hint_plan:
2394 used hint:
2395 NoIndexScan(t1)
2396 IndexScan(t2)
2397 not used hint:
2398 duplication hint:
2399 error hint:
2400
2401                QUERY PLAN
2402 -----------------------------------------
2403  Nested Loop
2404    ->  Tid Scan on t1
2405          TID Cond: (ctid = '(1,1)'::tid)
2406    ->  Index Scan using t2_pkey on t2
2407          Index Cond: (id = t1.id)
2408          Filter: (ctid = '(1,1)'::tid)
2409 (6 rows)
2410
2411 /*+NoIndexScan(t1) BitmapScan(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 NoIndexScan(t1)
2416 BitmapScan(t2)
2417 not used hint:
2418 duplication hint:
2419 error hint:
2420
2421                 QUERY PLAN
2422 ------------------------------------------
2423  Nested Loop
2424    ->  Tid Scan on t1
2425          TID Cond: (ctid = '(1,1)'::tid)
2426    ->  Bitmap Heap Scan on t2
2427          Recheck Cond: (id = t1.id)
2428          Filter: (ctid = '(1,1)'::tid)
2429          ->  Bitmap Index Scan on t2_pkey
2430                Index Cond: (id = t1.id)
2431 (8 rows)
2432
2433 /*+NoIndexScan(t1) TidScan(t2)*/
2434 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2435 LOG:  pg_hint_plan:
2436 used hint:
2437 NoIndexScan(t1)
2438 TidScan(t2)
2439 not used hint:
2440 duplication hint:
2441 error hint:
2442
2443                QUERY PLAN
2444 -----------------------------------------
2445  Nested Loop
2446    Join Filter: (t1.id = t2.id)
2447    ->  Tid Scan on t1
2448          TID Cond: (ctid = '(1,1)'::tid)
2449    ->  Tid Scan on t2
2450          TID Cond: (ctid = '(1,1)'::tid)
2451 (6 rows)
2452
2453 /*+NoIndexScan(t1) NoSeqScan(t2)*/
2454 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2455 LOG:  pg_hint_plan:
2456 used hint:
2457 NoIndexScan(t1)
2458 NoSeqScan(t2)
2459 not used hint:
2460 duplication hint:
2461 error hint:
2462
2463                QUERY PLAN
2464 -----------------------------------------
2465  Nested Loop
2466    Join Filter: (t1.id = t2.id)
2467    ->  Tid Scan on t1
2468          TID Cond: (ctid = '(1,1)'::tid)
2469    ->  Tid Scan on t2
2470          TID Cond: (ctid = '(1,1)'::tid)
2471 (6 rows)
2472
2473 /*+NoIndexScan(t1) NoIndexScan(t2)*/
2474 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2475 LOG:  pg_hint_plan:
2476 used hint:
2477 NoIndexScan(t1)
2478 NoIndexScan(t2)
2479 not used hint:
2480 duplication hint:
2481 error hint:
2482
2483                QUERY PLAN
2484 -----------------------------------------
2485  Nested Loop
2486    Join Filter: (t1.id = t2.id)
2487    ->  Tid Scan on t1
2488          TID Cond: (ctid = '(1,1)'::tid)
2489    ->  Tid Scan on t2
2490          TID Cond: (ctid = '(1,1)'::tid)
2491 (6 rows)
2492
2493 /*+NoIndexScan(t1) NoBitmapScan(t2)*/
2494 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2495 LOG:  pg_hint_plan:
2496 used hint:
2497 NoIndexScan(t1)
2498 NoBitmapScan(t2)
2499 not used hint:
2500 duplication hint:
2501 error hint:
2502
2503                QUERY PLAN
2504 -----------------------------------------
2505  Nested Loop
2506    Join Filter: (t1.id = t2.id)
2507    ->  Tid Scan on t1
2508          TID Cond: (ctid = '(1,1)'::tid)
2509    ->  Tid Scan on t2
2510          TID Cond: (ctid = '(1,1)'::tid)
2511 (6 rows)
2512
2513 /*+NoIndexScan(t1) NoTidScan(t2)*/
2514 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2515 LOG:  pg_hint_plan:
2516 used hint:
2517 NoIndexScan(t1)
2518 NoTidScan(t2)
2519 not used hint:
2520 duplication hint:
2521 error hint:
2522
2523                QUERY PLAN
2524 -----------------------------------------
2525  Nested Loop
2526    ->  Tid Scan on t1
2527          TID Cond: (ctid = '(1,1)'::tid)
2528    ->  Index Scan using t2_pkey on t2
2529          Index Cond: (id = t1.id)
2530          Filter: (ctid = '(1,1)'::tid)
2531 (6 rows)
2532
2533 /*+NoBitmapScan(t1)*/
2534 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2535 LOG:  pg_hint_plan:
2536 used hint:
2537 NoBitmapScan(t1)
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(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(t2)
2557 not used hint:
2558 duplication hint:
2559 error hint:
2560
2561                QUERY PLAN
2562 -----------------------------------------
2563  Nested Loop
2564    Join Filter: (t1.id = t2.id)
2565    ->  Tid Scan on t1
2566          TID Cond: (ctid = '(1,1)'::tid)
2567    ->  Tid Scan on t2
2568          TID Cond: (ctid = '(1,1)'::tid)
2569 (6 rows)
2570
2571 /*+NoBitmapScan(t1) SeqScan(t2)*/
2572 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2573 LOG:  pg_hint_plan:
2574 used hint:
2575 NoBitmapScan(t1)
2576 SeqScan(t2)
2577 not used hint:
2578 duplication hint:
2579 error hint:
2580
2581                QUERY PLAN
2582 -----------------------------------------
2583  Nested Loop
2584    Join Filter: (t1.id = t2.id)
2585    ->  Tid Scan on t1
2586          TID Cond: (ctid = '(1,1)'::tid)
2587    ->  Seq Scan on t2
2588          Filter: (ctid = '(1,1)'::tid)
2589 (6 rows)
2590
2591 /*+NoBitmapScan(t1) IndexScan(t2)*/
2592 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2593 LOG:  pg_hint_plan:
2594 used hint:
2595 NoBitmapScan(t1)
2596 IndexScan(t2)
2597 not used hint:
2598 duplication hint:
2599 error hint:
2600
2601                QUERY PLAN
2602 -----------------------------------------
2603  Nested Loop
2604    ->  Tid Scan on t1
2605          TID Cond: (ctid = '(1,1)'::tid)
2606    ->  Index Scan using t2_pkey on t2
2607          Index Cond: (id = t1.id)
2608          Filter: (ctid = '(1,1)'::tid)
2609 (6 rows)
2610
2611 /*+NoBitmapScan(t1) BitmapScan(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 NoBitmapScan(t1)
2616 BitmapScan(t2)
2617 not used hint:
2618 duplication hint:
2619 error hint:
2620
2621                 QUERY PLAN
2622 ------------------------------------------
2623  Nested Loop
2624    ->  Tid Scan on t1
2625          TID Cond: (ctid = '(1,1)'::tid)
2626    ->  Bitmap Heap Scan on t2
2627          Recheck Cond: (id = t1.id)
2628          Filter: (ctid = '(1,1)'::tid)
2629          ->  Bitmap Index Scan on t2_pkey
2630                Index Cond: (id = t1.id)
2631 (8 rows)
2632
2633 /*+NoBitmapScan(t1) TidScan(t2)*/
2634 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2635 LOG:  pg_hint_plan:
2636 used hint:
2637 NoBitmapScan(t1)
2638 TidScan(t2)
2639 not used hint:
2640 duplication hint:
2641 error hint:
2642
2643                QUERY PLAN
2644 -----------------------------------------
2645  Nested Loop
2646    Join Filter: (t1.id = t2.id)
2647    ->  Tid Scan on t1
2648          TID Cond: (ctid = '(1,1)'::tid)
2649    ->  Tid Scan on t2
2650          TID Cond: (ctid = '(1,1)'::tid)
2651 (6 rows)
2652
2653 /*+NoBitmapScan(t1) NoSeqScan(t2)*/
2654 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2655 LOG:  pg_hint_plan:
2656 used hint:
2657 NoBitmapScan(t1)
2658 NoSeqScan(t2)
2659 not used hint:
2660 duplication hint:
2661 error hint:
2662
2663                QUERY PLAN
2664 -----------------------------------------
2665  Nested Loop
2666    Join Filter: (t1.id = t2.id)
2667    ->  Tid Scan on t1
2668          TID Cond: (ctid = '(1,1)'::tid)
2669    ->  Tid Scan on t2
2670          TID Cond: (ctid = '(1,1)'::tid)
2671 (6 rows)
2672
2673 /*+NoBitmapScan(t1) NoIndexScan(t2)*/
2674 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2675 LOG:  pg_hint_plan:
2676 used hint:
2677 NoBitmapScan(t1)
2678 NoIndexScan(t2)
2679 not used hint:
2680 duplication hint:
2681 error hint:
2682
2683                QUERY PLAN
2684 -----------------------------------------
2685  Nested Loop
2686    Join Filter: (t1.id = t2.id)
2687    ->  Tid Scan on t1
2688          TID Cond: (ctid = '(1,1)'::tid)
2689    ->  Tid Scan on t2
2690          TID Cond: (ctid = '(1,1)'::tid)
2691 (6 rows)
2692
2693 /*+NoBitmapScan(t1) NoBitmapScan(t2)*/
2694 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2695 LOG:  pg_hint_plan:
2696 used hint:
2697 NoBitmapScan(t1)
2698 NoBitmapScan(t2)
2699 not used hint:
2700 duplication hint:
2701 error hint:
2702
2703                QUERY PLAN
2704 -----------------------------------------
2705  Nested Loop
2706    Join Filter: (t1.id = t2.id)
2707    ->  Tid Scan on t1
2708          TID Cond: (ctid = '(1,1)'::tid)
2709    ->  Tid Scan on t2
2710          TID Cond: (ctid = '(1,1)'::tid)
2711 (6 rows)
2712
2713 /*+NoBitmapScan(t1) NoTidScan(t2)*/
2714 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2715 LOG:  pg_hint_plan:
2716 used hint:
2717 NoBitmapScan(t1)
2718 NoTidScan(t2)
2719 not used hint:
2720 duplication hint:
2721 error hint:
2722
2723                QUERY PLAN
2724 -----------------------------------------
2725  Nested Loop
2726    ->  Tid Scan on t1
2727          TID Cond: (ctid = '(1,1)'::tid)
2728    ->  Index Scan using t2_pkey on t2
2729          Index Cond: (id = t1.id)
2730          Filter: (ctid = '(1,1)'::tid)
2731 (6 rows)
2732
2733 /*+NoTidScan(t1)*/
2734 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2735 LOG:  pg_hint_plan:
2736 used hint:
2737 NoTidScan(t1)
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(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(t2)
2757 not used hint:
2758 duplication hint:
2759 error hint:
2760
2761                QUERY PLAN
2762 -----------------------------------------
2763  Nested Loop
2764    ->  Tid Scan on t1
2765          TID Cond: (ctid = '(1,1)'::tid)
2766    ->  Index Scan using t2_pkey on t2
2767          Index Cond: (id = t1.id)
2768          Filter: (ctid = '(1,1)'::tid)
2769 (6 rows)
2770
2771 /*+NoTidScan(t1) SeqScan(t2)*/
2772 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2773 LOG:  pg_hint_plan:
2774 used hint:
2775 NoTidScan(t1)
2776 SeqScan(t2)
2777 not used hint:
2778 duplication hint:
2779 error hint:
2780
2781               QUERY PLAN
2782 ---------------------------------------
2783  Nested Loop
2784    ->  Seq Scan on t2
2785          Filter: (ctid = '(1,1)'::tid)
2786    ->  Index Scan using t1_pkey on t1
2787          Index Cond: (id = t2.id)
2788          Filter: (ctid = '(1,1)'::tid)
2789 (6 rows)
2790
2791 /*+NoTidScan(t1) IndexScan(t2)*/
2792 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2793 LOG:  pg_hint_plan:
2794 used hint:
2795 NoTidScan(t1)
2796 IndexScan(t2)
2797 not used hint:
2798 duplication hint:
2799 error hint:
2800
2801               QUERY PLAN
2802 ---------------------------------------
2803  Nested Loop
2804    ->  Index Scan using t2_pkey on t2
2805          Filter: (ctid = '(1,1)'::tid)
2806    ->  Index Scan using t1_pkey on t1
2807          Index Cond: (id = t2.id)
2808          Filter: (ctid = '(1,1)'::tid)
2809 (6 rows)
2810
2811 /*+NoTidScan(t1) BitmapScan(t2)*/
2812 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2813 LOG:  pg_hint_plan:
2814 used hint:
2815 NoTidScan(t1)
2816 BitmapScan(t2)
2817 not used hint:
2818 duplication hint:
2819 error hint:
2820
2821                 QUERY PLAN
2822 ------------------------------------------
2823  Nested Loop
2824    ->  Seq Scan on t1
2825          Filter: (ctid = '(1,1)'::tid)
2826    ->  Bitmap Heap Scan on t2
2827          Recheck Cond: (id = t1.id)
2828          Filter: (ctid = '(1,1)'::tid)
2829          ->  Bitmap Index Scan on t2_pkey
2830                Index Cond: (id = t1.id)
2831 (8 rows)
2832
2833 /*+NoTidScan(t1) TidScan(t2)*/
2834 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2835 LOG:  pg_hint_plan:
2836 used hint:
2837 NoTidScan(t1)
2838 TidScan(t2)
2839 not used hint:
2840 duplication hint:
2841 error hint:
2842
2843                QUERY PLAN
2844 -----------------------------------------
2845  Nested Loop
2846    ->  Tid Scan on t2
2847          TID Cond: (ctid = '(1,1)'::tid)
2848    ->  Index Scan using t1_pkey on t1
2849          Index Cond: (id = t2.id)
2850          Filter: (ctid = '(1,1)'::tid)
2851 (6 rows)
2852
2853 /*+NoTidScan(t1) NoSeqScan(t2)*/
2854 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2855 LOG:  pg_hint_plan:
2856 used hint:
2857 NoTidScan(t1)
2858 NoSeqScan(t2)
2859 not used hint:
2860 duplication hint:
2861 error hint:
2862
2863                QUERY PLAN
2864 -----------------------------------------
2865  Nested Loop
2866    ->  Tid Scan on t2
2867          TID Cond: (ctid = '(1,1)'::tid)
2868    ->  Index Scan using t1_pkey on t1
2869          Index Cond: (id = t2.id)
2870          Filter: (ctid = '(1,1)'::tid)
2871 (6 rows)
2872
2873 /*+NoTidScan(t1) NoIndexScan(t2)*/
2874 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2875 LOG:  pg_hint_plan:
2876 used hint:
2877 NoTidScan(t1)
2878 NoIndexScan(t2)
2879 not used hint:
2880 duplication hint:
2881 error hint:
2882
2883                QUERY PLAN
2884 -----------------------------------------
2885  Nested Loop
2886    ->  Tid Scan on t2
2887          TID Cond: (ctid = '(1,1)'::tid)
2888    ->  Index Scan using t1_pkey on t1
2889          Index Cond: (id = t2.id)
2890          Filter: (ctid = '(1,1)'::tid)
2891 (6 rows)
2892
2893 /*+NoTidScan(t1) NoBitmapScan(t2)*/
2894 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2895 LOG:  pg_hint_plan:
2896 used hint:
2897 NoTidScan(t1)
2898 NoBitmapScan(t2)
2899 not used hint:
2900 duplication hint:
2901 error hint:
2902
2903                QUERY PLAN
2904 -----------------------------------------
2905  Nested Loop
2906    ->  Tid Scan on t2
2907          TID Cond: (ctid = '(1,1)'::tid)
2908    ->  Index Scan using t1_pkey on t1
2909          Index Cond: (id = t2.id)
2910          Filter: (ctid = '(1,1)'::tid)
2911 (6 rows)
2912
2913 /*+NoTidScan(t1) NoTidScan(t2)*/
2914 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
2915 LOG:  pg_hint_plan:
2916 used hint:
2917 NoTidScan(t1)
2918 NoTidScan(t2)
2919 not used hint:
2920 duplication hint:
2921 error hint:
2922
2923               QUERY PLAN
2924 ---------------------------------------
2925  Nested Loop
2926    ->  Seq Scan on t2
2927          Filter: (ctid = '(1,1)'::tid)
2928    ->  Index Scan using t1_pkey on t1
2929          Index Cond: (id = t2.id)
2930          Filter: (ctid = '(1,1)'::tid)
2931 (6 rows)
2932
2933 -- additional test
2934 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;
2935                QUERY PLAN
2936 -----------------------------------------
2937  Nested Loop
2938    Join Filter: (t1.id = t2.id)
2939    ->  Tid Scan on t1
2940          TID Cond: (ctid = '(1,1)'::tid)
2941          Filter: (id < 10)
2942    ->  Tid Scan on t2
2943          TID Cond: (ctid = '(1,1)'::tid)
2944          Filter: (id < 10)
2945 (8 rows)
2946
2947 /*+BitmapScan(t1) BitmapScan(t2)*/
2948 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;
2949 LOG:  pg_hint_plan:
2950 used hint:
2951 BitmapScan(t1)
2952 BitmapScan(t2)
2953 not used hint:
2954 duplication hint:
2955 error hint:
2956
2957                        QUERY PLAN
2958 --------------------------------------------------------
2959  Nested Loop
2960    ->  Bitmap Heap Scan on t2
2961          Recheck Cond: (id < 10)
2962          Filter: (ctid = '(1,1)'::tid)
2963          ->  Bitmap Index Scan on t2_pkey
2964                Index Cond: (id < 10)
2965    ->  Bitmap Heap Scan on t1
2966          Recheck Cond: ((id = t2.id) AND (id < 10))
2967          Filter: (ctid = '(1,1)'::tid)
2968          ->  Bitmap Index Scan on t1_pkey
2969                Index Cond: ((id = t2.id) AND (id < 10))
2970 (11 rows)
2971
2972 -- outer join test
2973 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
2974           QUERY PLAN
2975 ------------------------------
2976  Hash Full Join
2977    Hash Cond: (t1.id = t2.id)
2978    ->  Seq Scan on t1
2979    ->  Hash
2980          ->  Seq Scan on t2
2981 (5 rows)
2982
2983 /*+MergeJoin(t1 t2)*/
2984 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
2985 LOG:  pg_hint_plan:
2986 used hint:
2987 MergeJoin(t1 t2)
2988 not used hint:
2989 duplication hint:
2990 error hint:
2991
2992               QUERY PLAN
2993 --------------------------------------
2994  Merge Full Join
2995    Merge Cond: (t1.id = t2.id)
2996    ->  Index Scan using t1_pkey on t1
2997    ->  Index Scan using t2_pkey on t2
2998 (4 rows)
2999
3000 /*+NestLoop(t1 t2)*/
3001 EXPLAIN (COSTS false) SELECT * FROM t1 FULL OUTER JOIN  t2 ON (t1.id = t2.id);
3002 LOG:  pg_hint_plan:
3003 used hint:
3004 NestLoop(t1 t2)
3005 not used hint:
3006 duplication hint:
3007 error hint:
3008
3009               QUERY PLAN
3010 --------------------------------------
3011  Merge Full Join
3012    Merge Cond: (t1.id = t2.id)
3013    ->  Index Scan using t1_pkey on t1
3014    ->  Index Scan using t2_pkey on t2
3015 (4 rows)
3016
3017 -- inherite table test
3018 SET constraint_exclusion TO off;
3019 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3020                                  QUERY PLAN
3021 -----------------------------------------------------------------------------
3022  Result
3023    ->  Append
3024          ->  Seq Scan on p1
3025                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3026          ->  Seq Scan on p1_c1 p1
3027                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3028          ->  Seq Scan on p1_c2 p1
3029                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3030          ->  Seq Scan on p1_c3 p1
3031                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3032          ->  Seq Scan on p1_c4 p1
3033                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3034          ->  Seq Scan on p1_c1_c1 p1
3035                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3036          ->  Seq Scan on p1_c1_c2 p1
3037                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3038          ->  Seq Scan on p1_c3_c1 p1
3039                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3040          ->  Seq Scan on p1_c3_c2 p1
3041                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3042 (20 rows)
3043
3044 SET constraint_exclusion TO on;
3045 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3046                                  QUERY PLAN
3047 -----------------------------------------------------------------------------
3048  Result
3049    ->  Append
3050          ->  Seq Scan on p1
3051                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3052          ->  Seq Scan on p1_c1 p1
3053                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3054          ->  Seq Scan on p1_c1_c1 p1
3055                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3056          ->  Seq Scan on p1_c1_c2 p1
3057                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3058 (10 rows)
3059
3060 SET constraint_exclusion TO off;
3061 /*+SeqScan(p1)*/
3062 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3063 LOG:  pg_hint_plan:
3064 used hint:
3065 SeqScan(p1)
3066 not used hint:
3067 duplication hint:
3068 error hint:
3069
3070                                  QUERY PLAN
3071 -----------------------------------------------------------------------------
3072  Result
3073    ->  Append
3074          ->  Seq Scan on p1
3075                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3076          ->  Seq Scan on p1_c1 p1
3077                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3078          ->  Seq Scan on p1_c2 p1
3079                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3080          ->  Seq Scan on p1_c3 p1
3081                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3082          ->  Seq Scan on p1_c4 p1
3083                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3084          ->  Seq Scan on p1_c1_c1 p1
3085                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3086          ->  Seq Scan on p1_c1_c2 p1
3087                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3088          ->  Seq Scan on p1_c3_c1 p1
3089                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3090          ->  Seq Scan on p1_c3_c2 p1
3091                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3092 (20 rows)
3093
3094 /*+IndexScan(p1)*/
3095 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3096 LOG:  pg_hint_plan:
3097 used hint:
3098 IndexScan(p1)
3099 not used hint:
3100 duplication hint:
3101 error hint:
3102
3103                         QUERY PLAN
3104 -----------------------------------------------------------
3105  Result
3106    ->  Append
3107          ->  Index Scan using p1_pkey on p1
3108                Index Cond: ((id >= 50) AND (id <= 51))
3109                Filter: (ctid = '(1,1)'::tid)
3110          ->  Index Scan using p1_c1_pkey on p1_c1 p1
3111                Index Cond: ((id >= 50) AND (id <= 51))
3112                Filter: (ctid = '(1,1)'::tid)
3113          ->  Index Scan using p1_c2_pkey on p1_c2 p1
3114                Index Cond: ((id >= 50) AND (id <= 51))
3115                Filter: (ctid = '(1,1)'::tid)
3116          ->  Index Scan using p1_c3_pkey on p1_c3 p1
3117                Index Cond: ((id >= 50) AND (id <= 51))
3118                Filter: (ctid = '(1,1)'::tid)
3119          ->  Index Scan using p1_c4_pkey on p1_c4 p1
3120                Index Cond: ((id >= 50) AND (id <= 51))
3121                Filter: (ctid = '(1,1)'::tid)
3122          ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1 p1
3123                Index Cond: ((id >= 50) AND (id <= 51))
3124                Filter: (ctid = '(1,1)'::tid)
3125          ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2 p1
3126                Index Cond: ((id >= 50) AND (id <= 51))
3127                Filter: (ctid = '(1,1)'::tid)
3128          ->  Index Scan using p1_c3_c1_pkey on p1_c3_c1 p1
3129                Index Cond: ((id >= 50) AND (id <= 51))
3130                Filter: (ctid = '(1,1)'::tid)
3131          ->  Index Scan using p1_c3_c2_pkey on p1_c3_c2 p1
3132                Index Cond: ((id >= 50) AND (id <= 51))
3133                Filter: (ctid = '(1,1)'::tid)
3134 (29 rows)
3135
3136 /*+BitmapScan(p1)*/
3137 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3138 LOG:  pg_hint_plan:
3139 used hint:
3140 BitmapScan(p1)
3141 not used hint:
3142 duplication hint:
3143 error hint:
3144
3145                          QUERY PLAN
3146 -------------------------------------------------------------
3147  Result
3148    ->  Append
3149          ->  Bitmap Heap Scan on p1
3150                Recheck Cond: ((id >= 50) AND (id <= 51))
3151                Filter: (ctid = '(1,1)'::tid)
3152                ->  Bitmap Index Scan on p1_pkey
3153                      Index Cond: ((id >= 50) AND (id <= 51))
3154          ->  Bitmap Heap Scan on p1_c1 p1
3155                Recheck Cond: ((id >= 50) AND (id <= 51))
3156                Filter: (ctid = '(1,1)'::tid)
3157                ->  Bitmap Index Scan on p1_c1_pkey
3158                      Index Cond: ((id >= 50) AND (id <= 51))
3159          ->  Bitmap Heap Scan on p1_c2 p1
3160                Recheck Cond: ((id >= 50) AND (id <= 51))
3161                Filter: (ctid = '(1,1)'::tid)
3162                ->  Bitmap Index Scan on p1_c2_pkey
3163                      Index Cond: ((id >= 50) AND (id <= 51))
3164          ->  Bitmap Heap Scan on p1_c3 p1
3165                Recheck Cond: ((id >= 50) AND (id <= 51))
3166                Filter: (ctid = '(1,1)'::tid)
3167                ->  Bitmap Index Scan on p1_c3_pkey
3168                      Index Cond: ((id >= 50) AND (id <= 51))
3169          ->  Bitmap Heap Scan on p1_c4 p1
3170                Recheck Cond: ((id >= 50) AND (id <= 51))
3171                Filter: (ctid = '(1,1)'::tid)
3172                ->  Bitmap Index Scan on p1_c4_pkey
3173                      Index Cond: ((id >= 50) AND (id <= 51))
3174          ->  Bitmap Heap Scan on p1_c1_c1 p1
3175                Recheck Cond: ((id >= 50) AND (id <= 51))
3176                Filter: (ctid = '(1,1)'::tid)
3177                ->  Bitmap Index Scan on p1_c1_c1_pkey
3178                      Index Cond: ((id >= 50) AND (id <= 51))
3179          ->  Bitmap Heap Scan on p1_c1_c2 p1
3180                Recheck Cond: ((id >= 50) AND (id <= 51))
3181                Filter: (ctid = '(1,1)'::tid)
3182                ->  Bitmap Index Scan on p1_c1_c2_pkey
3183                      Index Cond: ((id >= 50) AND (id <= 51))
3184          ->  Bitmap Heap Scan on p1_c3_c1 p1
3185                Recheck Cond: ((id >= 50) AND (id <= 51))
3186                Filter: (ctid = '(1,1)'::tid)
3187                ->  Bitmap Index Scan on p1_c3_c1_pkey
3188                      Index Cond: ((id >= 50) AND (id <= 51))
3189          ->  Bitmap Heap Scan on p1_c3_c2 p1
3190                Recheck Cond: ((id >= 50) AND (id <= 51))
3191                Filter: (ctid = '(1,1)'::tid)
3192                ->  Bitmap Index Scan on p1_c3_c2_pkey
3193                      Index Cond: ((id >= 50) AND (id <= 51))
3194 (47 rows)
3195
3196 /*+TidScan(p1)*/
3197 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3198 LOG:  pg_hint_plan:
3199 used hint:
3200 TidScan(p1)
3201 not used hint:
3202 duplication hint:
3203 error hint:
3204
3205                     QUERY PLAN
3206 ---------------------------------------------------
3207  Result
3208    ->  Append
3209          ->  Tid Scan on p1
3210                TID Cond: (ctid = '(1,1)'::tid)
3211                Filter: ((id >= 50) AND (id <= 51))
3212          ->  Tid Scan on p1_c1 p1
3213                TID Cond: (ctid = '(1,1)'::tid)
3214                Filter: ((id >= 50) AND (id <= 51))
3215          ->  Tid Scan on p1_c2 p1
3216                TID Cond: (ctid = '(1,1)'::tid)
3217                Filter: ((id >= 50) AND (id <= 51))
3218          ->  Tid Scan on p1_c3 p1
3219                TID Cond: (ctid = '(1,1)'::tid)
3220                Filter: ((id >= 50) AND (id <= 51))
3221          ->  Tid Scan on p1_c4 p1
3222                TID Cond: (ctid = '(1,1)'::tid)
3223                Filter: ((id >= 50) AND (id <= 51))
3224          ->  Tid Scan on p1_c1_c1 p1
3225                TID Cond: (ctid = '(1,1)'::tid)
3226                Filter: ((id >= 50) AND (id <= 51))
3227          ->  Tid Scan on p1_c1_c2 p1
3228                TID Cond: (ctid = '(1,1)'::tid)
3229                Filter: ((id >= 50) AND (id <= 51))
3230          ->  Tid Scan on p1_c3_c1 p1
3231                TID Cond: (ctid = '(1,1)'::tid)
3232                Filter: ((id >= 50) AND (id <= 51))
3233          ->  Tid Scan on p1_c3_c2 p1
3234                TID Cond: (ctid = '(1,1)'::tid)
3235                Filter: ((id >= 50) AND (id <= 51))
3236 (29 rows)
3237
3238 SET constraint_exclusion TO on;
3239 /*+SeqScan(p1)*/
3240 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3241 LOG:  pg_hint_plan:
3242 used hint:
3243 SeqScan(p1)
3244 not used hint:
3245 duplication hint:
3246 error hint:
3247
3248                                  QUERY PLAN
3249 -----------------------------------------------------------------------------
3250  Result
3251    ->  Append
3252          ->  Seq Scan on p1
3253                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3254          ->  Seq Scan on p1_c1 p1
3255                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3256          ->  Seq Scan on p1_c1_c1 p1
3257                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3258          ->  Seq Scan on p1_c1_c2 p1
3259                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3260 (10 rows)
3261
3262 /*+IndexScan(p1)*/
3263 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3264 LOG:  pg_hint_plan:
3265 used hint:
3266 IndexScan(p1)
3267 not used hint:
3268 duplication hint:
3269 error hint:
3270
3271                         QUERY PLAN
3272 -----------------------------------------------------------
3273  Result
3274    ->  Append
3275          ->  Index Scan using p1_pkey on p1
3276                Index Cond: ((id >= 50) AND (id <= 51))
3277                Filter: (ctid = '(1,1)'::tid)
3278          ->  Index Scan using p1_c1_pkey on p1_c1 p1
3279                Index Cond: ((id >= 50) AND (id <= 51))
3280                Filter: (ctid = '(1,1)'::tid)
3281          ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1 p1
3282                Index Cond: ((id >= 50) AND (id <= 51))
3283                Filter: (ctid = '(1,1)'::tid)
3284          ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2 p1
3285                Index Cond: ((id >= 50) AND (id <= 51))
3286                Filter: (ctid = '(1,1)'::tid)
3287 (14 rows)
3288
3289 /*+BitmapScan(p1)*/
3290 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3291 LOG:  pg_hint_plan:
3292 used hint:
3293 BitmapScan(p1)
3294 not used hint:
3295 duplication hint:
3296 error hint:
3297
3298                          QUERY PLAN
3299 -------------------------------------------------------------
3300  Result
3301    ->  Append
3302          ->  Bitmap Heap Scan on p1
3303                Recheck Cond: ((id >= 50) AND (id <= 51))
3304                Filter: (ctid = '(1,1)'::tid)
3305                ->  Bitmap Index Scan on p1_pkey
3306                      Index Cond: ((id >= 50) AND (id <= 51))
3307          ->  Bitmap Heap Scan on p1_c1 p1
3308                Recheck Cond: ((id >= 50) AND (id <= 51))
3309                Filter: (ctid = '(1,1)'::tid)
3310                ->  Bitmap Index Scan on p1_c1_pkey
3311                      Index Cond: ((id >= 50) AND (id <= 51))
3312          ->  Bitmap Heap Scan on p1_c1_c1 p1
3313                Recheck Cond: ((id >= 50) AND (id <= 51))
3314                Filter: (ctid = '(1,1)'::tid)
3315                ->  Bitmap Index Scan on p1_c1_c1_pkey
3316                      Index Cond: ((id >= 50) AND (id <= 51))
3317          ->  Bitmap Heap Scan on p1_c1_c2 p1
3318                Recheck Cond: ((id >= 50) AND (id <= 51))
3319                Filter: (ctid = '(1,1)'::tid)
3320                ->  Bitmap Index Scan on p1_c1_c2_pkey
3321                      Index Cond: ((id >= 50) AND (id <= 51))
3322 (22 rows)
3323
3324 /*+TidScan(p1)*/
3325 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3326 LOG:  pg_hint_plan:
3327 used hint:
3328 TidScan(p1)
3329 not used hint:
3330 duplication hint:
3331 error hint:
3332
3333                     QUERY PLAN
3334 ---------------------------------------------------
3335  Result
3336    ->  Append
3337          ->  Tid Scan on p1
3338                TID Cond: (ctid = '(1,1)'::tid)
3339                Filter: ((id >= 50) AND (id <= 51))
3340          ->  Tid Scan on p1_c1 p1
3341                TID Cond: (ctid = '(1,1)'::tid)
3342                Filter: ((id >= 50) AND (id <= 51))
3343          ->  Tid Scan on p1_c1_c1 p1
3344                TID Cond: (ctid = '(1,1)'::tid)
3345                Filter: ((id >= 50) AND (id <= 51))
3346          ->  Tid Scan on p1_c1_c2 p1
3347                TID Cond: (ctid = '(1,1)'::tid)
3348                Filter: ((id >= 50) AND (id <= 51))
3349 (14 rows)
3350
3351 SET constraint_exclusion TO off;
3352 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;
3353                                     QUERY PLAN
3354 -----------------------------------------------------------------------------------
3355  Merge Join
3356    Merge Cond: (public.p1.id = t1.id)
3357    ->  Sort
3358          Sort Key: public.p1.id
3359          ->  Append
3360                ->  Seq Scan on p1
3361                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3362                ->  Seq Scan on p1_c1 p1
3363                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3364                ->  Seq Scan on p1_c2 p1
3365                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3366                ->  Seq Scan on p1_c3 p1
3367                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3368                ->  Seq Scan on p1_c4 p1
3369                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3370                ->  Seq Scan on p1_c1_c1 p1
3371                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3372                ->  Seq Scan on p1_c1_c2 p1
3373                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3374                ->  Seq Scan on p1_c3_c1 p1
3375                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3376                ->  Seq Scan on p1_c3_c2 p1
3377                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3378    ->  Index Scan using t1_pkey on t1
3379          Index Cond: (id < 10)
3380 (25 rows)
3381
3382 SET constraint_exclusion TO on;
3383 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;
3384                                     QUERY PLAN
3385 -----------------------------------------------------------------------------------
3386  Merge Join
3387    Merge Cond: (public.p1.id = t1.id)
3388    ->  Sort
3389          Sort Key: public.p1.id
3390          ->  Append
3391                ->  Seq Scan on p1
3392                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3393                ->  Seq Scan on p1_c1 p1
3394                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3395                ->  Seq Scan on p1_c1_c1 p1
3396                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3397                ->  Seq Scan on p1_c1_c2 p1
3398                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3399    ->  Index Scan using t1_pkey on t1
3400          Index Cond: (id < 10)
3401 (15 rows)
3402
3403 SET constraint_exclusion TO off;
3404 /*+SeqScan(p1)*/
3405 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;
3406 LOG:  pg_hint_plan:
3407 used hint:
3408 SeqScan(p1)
3409 not used hint:
3410 duplication hint:
3411 error hint:
3412
3413                                     QUERY PLAN
3414 -----------------------------------------------------------------------------------
3415  Merge Join
3416    Merge Cond: (public.p1.id = t1.id)
3417    ->  Sort
3418          Sort Key: public.p1.id
3419          ->  Append
3420                ->  Seq Scan on p1
3421                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3422                ->  Seq Scan on p1_c1 p1
3423                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3424                ->  Seq Scan on p1_c2 p1
3425                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3426                ->  Seq Scan on p1_c3 p1
3427                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3428                ->  Seq Scan on p1_c4 p1
3429                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3430                ->  Seq Scan on p1_c1_c1 p1
3431                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3432                ->  Seq Scan on p1_c1_c2 p1
3433                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3434                ->  Seq Scan on p1_c3_c1 p1
3435                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3436                ->  Seq Scan on p1_c3_c2 p1
3437                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3438    ->  Index Scan using t1_pkey on t1
3439          Index Cond: (id < 10)
3440 (25 rows)
3441
3442 /*+IndexScan(p1)*/
3443 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;
3444 LOG:  pg_hint_plan:
3445 used hint:
3446 IndexScan(p1)
3447 not used hint:
3448 duplication hint:
3449 error hint:
3450
3451                                     QUERY PLAN
3452 -----------------------------------------------------------------------------------
3453  Merge Join
3454    Merge Cond: (public.p1.id = t1.id)
3455    ->  Sort
3456          Sort Key: public.p1.id
3457          ->  Append
3458                ->  Seq Scan on p1
3459                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3460                ->  Seq Scan on p1_c1 p1
3461                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3462                ->  Seq Scan on p1_c2 p1
3463                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3464                ->  Seq Scan on p1_c3 p1
3465                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3466                ->  Seq Scan on p1_c4 p1
3467                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3468                ->  Seq Scan on p1_c1_c1 p1
3469                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3470                ->  Seq Scan on p1_c1_c2 p1
3471                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3472                ->  Seq Scan on p1_c3_c1 p1
3473                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3474                ->  Seq Scan on p1_c3_c2 p1
3475                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3476    ->  Index Scan using t1_pkey on t1
3477          Index Cond: (id < 10)
3478 (25 rows)
3479
3480 /*+BitmapScan(p1)*/
3481 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;
3482 LOG:  pg_hint_plan:
3483 used hint:
3484 BitmapScan(p1)
3485 not used hint:
3486 duplication hint:
3487 error hint:
3488
3489                                     QUERY PLAN
3490 -----------------------------------------------------------------------------------
3491  Merge Join
3492    Merge Cond: (public.p1.id = t1.id)
3493    ->  Sort
3494          Sort Key: public.p1.id
3495          ->  Append
3496                ->  Seq Scan on p1
3497                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3498                ->  Seq Scan on p1_c1 p1
3499                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3500                ->  Seq Scan on p1_c2 p1
3501                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3502                ->  Seq Scan on p1_c3 p1
3503                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3504                ->  Seq Scan on p1_c4 p1
3505                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3506                ->  Seq Scan on p1_c1_c1 p1
3507                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3508                ->  Seq Scan on p1_c1_c2 p1
3509                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3510                ->  Seq Scan on p1_c3_c1 p1
3511                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3512                ->  Seq Scan on p1_c3_c2 p1
3513                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3514    ->  Index Scan using t1_pkey on t1
3515          Index Cond: (id < 10)
3516 (25 rows)
3517
3518 /*+TidScan(p1)*/
3519 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;
3520 LOG:  pg_hint_plan:
3521 used hint:
3522 TidScan(p1)
3523 not used hint:
3524 duplication hint:
3525 error hint:
3526
3527                                     QUERY PLAN
3528 -----------------------------------------------------------------------------------
3529  Merge Join
3530    Merge Cond: (public.p1.id = t1.id)
3531    ->  Sort
3532          Sort Key: public.p1.id
3533          ->  Append
3534                ->  Seq Scan on p1
3535                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3536                ->  Seq Scan on p1_c1 p1
3537                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3538                ->  Seq Scan on p1_c2 p1
3539                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3540                ->  Seq Scan on p1_c3 p1
3541                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3542                ->  Seq Scan on p1_c4 p1
3543                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3544                ->  Seq Scan on p1_c1_c1 p1
3545                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3546                ->  Seq Scan on p1_c1_c2 p1
3547                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3548                ->  Seq Scan on p1_c3_c1 p1
3549                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3550                ->  Seq Scan on p1_c3_c2 p1
3551                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3552    ->  Index Scan using t1_pkey on t1
3553          Index Cond: (id < 10)
3554 (25 rows)
3555
3556 /*+NestLoop(p1 t1)*/
3557 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;
3558 LOG:  pg_hint_plan:
3559 used hint:
3560 NestLoop(p1 t1)
3561 not used hint:
3562 duplication hint:
3563 error hint:
3564
3565                                  QUERY PLAN
3566 -----------------------------------------------------------------------------
3567  Nested Loop
3568    Join Filter: (public.p1.id = t1.id)
3569    ->  Append
3570          ->  Seq Scan on p1
3571                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3572          ->  Seq Scan on p1_c1 p1
3573                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3574          ->  Seq Scan on p1_c2 p1
3575                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3576          ->  Seq Scan on p1_c3 p1
3577                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3578          ->  Seq Scan on p1_c4 p1
3579                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3580          ->  Seq Scan on p1_c1_c1 p1
3581                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3582          ->  Seq Scan on p1_c1_c2 p1
3583                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3584          ->  Seq Scan on p1_c3_c1 p1
3585                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3586          ->  Seq Scan on p1_c3_c2 p1
3587                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3588    ->  Materialize
3589          ->  Index Scan using t1_pkey on t1
3590                Index Cond: (id < 10)
3591 (24 rows)
3592
3593 /*+MergeJoin(p1 t1)*/
3594 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;
3595 LOG:  pg_hint_plan:
3596 used hint:
3597 MergeJoin(p1 t1)
3598 not used hint:
3599 duplication hint:
3600 error hint:
3601
3602                                     QUERY PLAN
3603 -----------------------------------------------------------------------------------
3604  Merge Join
3605    Merge Cond: (public.p1.id = t1.id)
3606    ->  Sort
3607          Sort Key: public.p1.id
3608          ->  Append
3609                ->  Seq Scan on p1
3610                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3611                ->  Seq Scan on p1_c1 p1
3612                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3613                ->  Seq Scan on p1_c2 p1
3614                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3615                ->  Seq Scan on p1_c3 p1
3616                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3617                ->  Seq Scan on p1_c4 p1
3618                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3619                ->  Seq Scan on p1_c1_c1 p1
3620                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3621                ->  Seq Scan on p1_c1_c2 p1
3622                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3623                ->  Seq Scan on p1_c3_c1 p1
3624                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3625                ->  Seq Scan on p1_c3_c2 p1
3626                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3627    ->  Index Scan using t1_pkey on t1
3628          Index Cond: (id < 10)
3629 (25 rows)
3630
3631 /*+HashJoin(p1 t1)*/
3632 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;
3633 LOG:  pg_hint_plan:
3634 used hint:
3635 HashJoin(p1 t1)
3636 not used hint:
3637 duplication hint:
3638 error hint:
3639
3640                                  QUERY PLAN
3641 -----------------------------------------------------------------------------
3642  Hash Join
3643    Hash Cond: (public.p1.id = t1.id)
3644    ->  Append
3645          ->  Seq Scan on p1
3646                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3647          ->  Seq Scan on p1_c1 p1
3648                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3649          ->  Seq Scan on p1_c2 p1
3650                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3651          ->  Seq Scan on p1_c3 p1
3652                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3653          ->  Seq Scan on p1_c4 p1
3654                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3655          ->  Seq Scan on p1_c1_c1 p1
3656                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3657          ->  Seq Scan on p1_c1_c2 p1
3658                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3659          ->  Seq Scan on p1_c3_c1 p1
3660                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3661          ->  Seq Scan on p1_c3_c2 p1
3662                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3663    ->  Hash
3664          ->  Index Scan using t1_pkey on t1
3665                Index Cond: (id < 10)
3666 (24 rows)
3667
3668 SET constraint_exclusion TO on;
3669 /*+SeqScan(p1)*/
3670 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;
3671 LOG:  pg_hint_plan:
3672 used hint:
3673 SeqScan(p1)
3674 not used hint:
3675 duplication hint:
3676 error hint:
3677
3678                                     QUERY PLAN
3679 -----------------------------------------------------------------------------------
3680  Merge Join
3681    Merge Cond: (public.p1.id = t1.id)
3682    ->  Sort
3683          Sort Key: public.p1.id
3684          ->  Append
3685                ->  Seq Scan on p1
3686                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3687                ->  Seq Scan on p1_c1 p1
3688                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3689                ->  Seq Scan on p1_c1_c1 p1
3690                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3691                ->  Seq Scan on p1_c1_c2 p1
3692                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3693    ->  Index Scan using t1_pkey on t1
3694          Index Cond: (id < 10)
3695 (15 rows)
3696
3697 /*+IndexScan(p1)*/
3698 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;
3699 LOG:  pg_hint_plan:
3700 used hint:
3701 IndexScan(p1)
3702 not used hint:
3703 duplication hint:
3704 error hint:
3705
3706                                     QUERY PLAN
3707 -----------------------------------------------------------------------------------
3708  Merge Join
3709    Merge Cond: (public.p1.id = t1.id)
3710    ->  Sort
3711          Sort Key: public.p1.id
3712          ->  Append
3713                ->  Seq Scan on p1
3714                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3715                ->  Seq Scan on p1_c1 p1
3716                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3717                ->  Seq Scan on p1_c1_c1 p1
3718                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3719                ->  Seq Scan on p1_c1_c2 p1
3720                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3721    ->  Index Scan using t1_pkey on t1
3722          Index Cond: (id < 10)
3723 (15 rows)
3724
3725 /*+BitmapScan(p1)*/
3726 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;
3727 LOG:  pg_hint_plan:
3728 used hint:
3729 BitmapScan(p1)
3730 not used hint:
3731 duplication hint:
3732 error hint:
3733
3734                                     QUERY PLAN
3735 -----------------------------------------------------------------------------------
3736  Merge Join
3737    Merge Cond: (public.p1.id = t1.id)
3738    ->  Sort
3739          Sort Key: public.p1.id
3740          ->  Append
3741                ->  Seq Scan on p1
3742                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3743                ->  Seq Scan on p1_c1 p1
3744                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3745                ->  Seq Scan on p1_c1_c1 p1
3746                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3747                ->  Seq Scan on p1_c1_c2 p1
3748                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3749    ->  Index Scan using t1_pkey on t1
3750          Index Cond: (id < 10)
3751 (15 rows)
3752
3753 /*+TidScan(p1)*/
3754 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;
3755 LOG:  pg_hint_plan:
3756 used hint:
3757 TidScan(p1)
3758 not used hint:
3759 duplication hint:
3760 error hint:
3761
3762                                     QUERY PLAN
3763 -----------------------------------------------------------------------------------
3764  Merge Join
3765    Merge Cond: (public.p1.id = t1.id)
3766    ->  Sort
3767          Sort Key: public.p1.id
3768          ->  Append
3769                ->  Seq Scan on p1
3770                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3771                ->  Seq Scan on p1_c1 p1
3772                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3773                ->  Seq Scan on p1_c1_c1 p1
3774                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3775                ->  Seq Scan on p1_c1_c2 p1
3776                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3777    ->  Index Scan using t1_pkey on t1
3778          Index Cond: (id < 10)
3779 (15 rows)
3780
3781 /*+NestLoop(p1 t1)*/
3782 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;
3783 LOG:  pg_hint_plan:
3784 used hint:
3785 NestLoop(p1 t1)
3786 not used hint:
3787 duplication hint:
3788 error hint:
3789
3790                                     QUERY PLAN
3791 -----------------------------------------------------------------------------------
3792  Nested Loop
3793    Join Filter: (public.p1.id = t1.id)
3794    ->  Index Scan using t1_pkey on t1
3795          Index Cond: (id < 10)
3796    ->  Materialize
3797          ->  Append
3798                ->  Seq Scan on p1
3799                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3800                ->  Seq Scan on p1_c1 p1
3801                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3802                ->  Seq Scan on p1_c1_c1 p1
3803                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3804                ->  Seq Scan on p1_c1_c2 p1
3805                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3806 (14 rows)
3807
3808 /*+MergeJoin(p1 t1)*/
3809 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;
3810 LOG:  pg_hint_plan:
3811 used hint:
3812 MergeJoin(p1 t1)
3813 not used hint:
3814 duplication hint:
3815 error hint:
3816
3817                                     QUERY PLAN
3818 -----------------------------------------------------------------------------------
3819  Merge Join
3820    Merge Cond: (public.p1.id = t1.id)
3821    ->  Sort
3822          Sort Key: public.p1.id
3823          ->  Append
3824                ->  Seq Scan on p1
3825                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3826                ->  Seq Scan on p1_c1 p1
3827                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3828                ->  Seq Scan on p1_c1_c1 p1
3829                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3830                ->  Seq Scan on p1_c1_c2 p1
3831                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3832    ->  Index Scan using t1_pkey on t1
3833          Index Cond: (id < 10)
3834 (15 rows)
3835
3836 /*+HashJoin(p1 t1)*/
3837 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;
3838 LOG:  pg_hint_plan:
3839 used hint:
3840 HashJoin(p1 t1)
3841 not used hint:
3842 duplication hint:
3843 error hint:
3844
3845                                     QUERY PLAN
3846 -----------------------------------------------------------------------------------
3847  Hash Join
3848    Hash Cond: (t1.id = public.p1.id)
3849    ->  Index Scan using t1_pkey on t1
3850          Index Cond: (id < 10)
3851    ->  Hash
3852          ->  Append
3853                ->  Seq Scan on p1
3854                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3855                ->  Seq Scan on p1_c1 p1
3856                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3857                ->  Seq Scan on p1_c1_c1 p1
3858                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3859                ->  Seq Scan on p1_c1_c2 p1
3860                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3861 (14 rows)
3862
3863 SET constraint_exclusion TO off;
3864 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3865                            QUERY PLAN
3866 -----------------------------------------------------------------
3867  Seq Scan on p1
3868    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3869 (2 rows)
3870
3871 SET constraint_exclusion TO on;
3872 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3873                            QUERY PLAN
3874 -----------------------------------------------------------------
3875  Seq Scan on p1
3876    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3877 (2 rows)
3878
3879 SET constraint_exclusion TO off;
3880 /*+SeqScan(p1)*/
3881 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3882 LOG:  pg_hint_plan:
3883 used hint:
3884 SeqScan(p1)
3885 not used hint:
3886 duplication hint:
3887 error hint:
3888
3889                            QUERY PLAN
3890 -----------------------------------------------------------------
3891  Seq Scan on p1
3892    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3893 (2 rows)
3894
3895 /*+IndexScan(p1)*/
3896 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3897 LOG:  pg_hint_plan:
3898 used hint:
3899 IndexScan(p1)
3900 not used hint:
3901 duplication hint:
3902 error hint:
3903
3904                 QUERY PLAN
3905 -------------------------------------------
3906  Index Scan using p1_pkey on p1
3907    Index Cond: ((id >= 50) AND (id <= 51))
3908    Filter: (ctid = '(1,1)'::tid)
3909 (3 rows)
3910
3911 /*+BitmapScan(p1)*/
3912 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3913 LOG:  pg_hint_plan:
3914 used hint:
3915 BitmapScan(p1)
3916 not used hint:
3917 duplication hint:
3918 error hint:
3919
3920                    QUERY PLAN
3921 -------------------------------------------------
3922  Bitmap Heap Scan on p1
3923    Recheck Cond: ((id >= 50) AND (id <= 51))
3924    Filter: (ctid = '(1,1)'::tid)
3925    ->  Bitmap Index Scan on p1_pkey
3926          Index Cond: ((id >= 50) AND (id <= 51))
3927 (5 rows)
3928
3929 /*+TidScan(p1)*/
3930 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3931 LOG:  pg_hint_plan:
3932 used hint:
3933 TidScan(p1)
3934 not used hint:
3935 duplication hint:
3936 error hint:
3937
3938               QUERY PLAN
3939 ---------------------------------------
3940  Tid Scan on p1
3941    TID Cond: (ctid = '(1,1)'::tid)
3942    Filter: ((id >= 50) AND (id <= 51))
3943 (3 rows)
3944
3945 /*+NestLoop(p1 t1)*/
3946 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;
3947 LOG:  pg_hint_plan:
3948 used hint:
3949 NestLoop(p1 t1)
3950 not used hint:
3951 duplication hint:
3952 error hint:
3953
3954                               QUERY PLAN
3955 -----------------------------------------------------------------------
3956  Nested Loop
3957    ->  Seq Scan on p1
3958          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3959    ->  Index Scan using t1_pkey on t1
3960          Index Cond: ((id = p1.id) AND (id < 10))
3961 (5 rows)
3962
3963 /*+MergeJoin(p1 t1)*/
3964 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;
3965 LOG:  pg_hint_plan:
3966 used hint:
3967 MergeJoin(p1 t1)
3968 not used hint:
3969 duplication hint:
3970 error hint:
3971
3972                                  QUERY PLAN
3973 -----------------------------------------------------------------------------
3974  Merge Join
3975    Merge Cond: (p1.id = t1.id)
3976    ->  Sort
3977          Sort Key: p1.id
3978          ->  Seq Scan on p1
3979                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3980    ->  Index Scan using t1_pkey on t1
3981          Index Cond: (id < 10)
3982 (8 rows)
3983
3984 /*+HashJoin(p1 t1)*/
3985 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;
3986 LOG:  pg_hint_plan:
3987 used hint:
3988 HashJoin(p1 t1)
3989 not used hint:
3990 duplication hint:
3991 error hint:
3992
3993                                  QUERY PLAN
3994 -----------------------------------------------------------------------------
3995  Hash Join
3996    Hash Cond: (t1.id = p1.id)
3997    ->  Index Scan using t1_pkey on t1
3998          Index Cond: (id < 10)
3999    ->  Hash
4000          ->  Seq Scan on p1
4001                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4002 (7 rows)
4003
4004 SET constraint_exclusion TO on;
4005 /*+SeqScan(p1)*/
4006 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4007 LOG:  pg_hint_plan:
4008 used hint:
4009 SeqScan(p1)
4010 not used hint:
4011 duplication hint:
4012 error hint:
4013
4014                            QUERY PLAN
4015 -----------------------------------------------------------------
4016  Seq Scan on p1
4017    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4018 (2 rows)
4019
4020 /*+IndexScan(p1)*/
4021 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4022 LOG:  pg_hint_plan:
4023 used hint:
4024 IndexScan(p1)
4025 not used hint:
4026 duplication hint:
4027 error hint:
4028
4029                 QUERY PLAN
4030 -------------------------------------------
4031  Index Scan using p1_pkey on p1
4032    Index Cond: ((id >= 50) AND (id <= 51))
4033    Filter: (ctid = '(1,1)'::tid)
4034 (3 rows)
4035
4036 /*+BitmapScan(p1)*/
4037 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4038 LOG:  pg_hint_plan:
4039 used hint:
4040 BitmapScan(p1)
4041 not used hint:
4042 duplication hint:
4043 error hint:
4044
4045                    QUERY PLAN
4046 -------------------------------------------------
4047  Bitmap Heap Scan on p1
4048    Recheck Cond: ((id >= 50) AND (id <= 51))
4049    Filter: (ctid = '(1,1)'::tid)
4050    ->  Bitmap Index Scan on p1_pkey
4051          Index Cond: ((id >= 50) AND (id <= 51))
4052 (5 rows)
4053
4054 /*+TidScan(p1)*/
4055 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4056 LOG:  pg_hint_plan:
4057 used hint:
4058 TidScan(p1)
4059 not used hint:
4060 duplication hint:
4061 error hint:
4062
4063               QUERY PLAN
4064 ---------------------------------------
4065  Tid Scan on p1
4066    TID Cond: (ctid = '(1,1)'::tid)
4067    Filter: ((id >= 50) AND (id <= 51))
4068 (3 rows)
4069
4070 /*+NestLoop(p1 t1)*/
4071 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;
4072 LOG:  pg_hint_plan:
4073 used hint:
4074 NestLoop(p1 t1)
4075 not used hint:
4076 duplication hint:
4077 error hint:
4078
4079                               QUERY PLAN
4080 -----------------------------------------------------------------------
4081  Nested Loop
4082    ->  Seq Scan on p1
4083          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4084    ->  Index Scan using t1_pkey on t1
4085          Index Cond: ((id = p1.id) AND (id < 10))
4086 (5 rows)
4087
4088 /*+MergeJoin(p1 t1)*/
4089 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;
4090 LOG:  pg_hint_plan:
4091 used hint:
4092 MergeJoin(p1 t1)
4093 not used hint:
4094 duplication hint:
4095 error hint:
4096
4097                                  QUERY PLAN
4098 -----------------------------------------------------------------------------
4099  Merge Join
4100    Merge Cond: (p1.id = t1.id)
4101    ->  Sort
4102          Sort Key: p1.id
4103          ->  Seq Scan on p1
4104                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4105    ->  Index Scan using t1_pkey on t1
4106          Index Cond: (id < 10)
4107 (8 rows)
4108
4109 /*+HashJoin(p1 t1)*/
4110 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;
4111 LOG:  pg_hint_plan:
4112 used hint:
4113 HashJoin(p1 t1)
4114 not used hint:
4115 duplication hint:
4116 error hint:
4117
4118                                  QUERY PLAN
4119 -----------------------------------------------------------------------------
4120  Hash Join
4121    Hash Cond: (t1.id = p1.id)
4122    ->  Index Scan using t1_pkey on t1
4123          Index Cond: (id < 10)
4124    ->  Hash
4125          ->  Seq Scan on p1
4126                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4127 (7 rows)
4128
4129 SET constraint_exclusion TO off;
4130 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;
4131                               QUERY PLAN
4132 -----------------------------------------------------------------------
4133  Nested Loop
4134    ->  Seq Scan on p1
4135          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4136    ->  Index Scan using t1_pkey on t1
4137          Index Cond: ((id = p1.id) AND (id < 10))
4138 (5 rows)
4139
4140 SET constraint_exclusion TO on;
4141 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;
4142                               QUERY PLAN
4143 -----------------------------------------------------------------------
4144  Nested Loop
4145    ->  Seq Scan on p1
4146          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4147    ->  Index Scan using t1_pkey on t1
4148          Index Cond: ((id = p1.id) AND (id < 10))
4149 (5 rows)
4150
4151 SET constraint_exclusion TO off;
4152 /*+SeqScan(p1)*/
4153 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;
4154 LOG:  pg_hint_plan:
4155 used hint:
4156 SeqScan(p1)
4157 not used hint:
4158 duplication hint:
4159 error hint:
4160
4161                               QUERY PLAN
4162 -----------------------------------------------------------------------
4163  Nested Loop
4164    ->  Seq Scan on p1
4165          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4166    ->  Index Scan using t1_pkey on t1
4167          Index Cond: ((id = p1.id) AND (id < 10))
4168 (5 rows)
4169
4170 /*+IndexScan(p1)*/
4171 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;
4172 LOG:  pg_hint_plan:
4173 used hint:
4174 IndexScan(p1)
4175 not used hint:
4176 duplication hint:
4177 error hint:
4178
4179                     QUERY PLAN
4180 --------------------------------------------------
4181  Nested Loop
4182    ->  Index Scan using p1_pkey on p1
4183          Index Cond: ((id >= 50) AND (id <= 51))
4184          Filter: (ctid = '(1,1)'::tid)
4185    ->  Index Scan using t1_pkey on t1
4186          Index Cond: ((id = p1.id) AND (id < 10))
4187 (6 rows)
4188
4189 /*+BitmapScan(p1)*/
4190 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;
4191 LOG:  pg_hint_plan:
4192 used hint:
4193 BitmapScan(p1)
4194 not used hint:
4195 duplication hint:
4196 error hint:
4197
4198                       QUERY PLAN
4199 -------------------------------------------------------
4200  Nested Loop
4201    ->  Bitmap Heap Scan on p1
4202          Recheck Cond: ((id >= 50) AND (id <= 51))
4203          Filter: (ctid = '(1,1)'::tid)
4204          ->  Bitmap Index Scan on p1_pkey
4205                Index Cond: ((id >= 50) AND (id <= 51))
4206    ->  Index Scan using t1_pkey on t1
4207          Index Cond: ((id = p1.id) AND (id < 10))
4208 (8 rows)
4209
4210 /*+TidScan(p1)*/
4211 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;
4212 LOG:  pg_hint_plan:
4213 used hint:
4214 TidScan(p1)
4215 not used hint:
4216 duplication hint:
4217 error hint:
4218
4219                     QUERY PLAN
4220 --------------------------------------------------
4221  Nested Loop
4222    ->  Tid Scan on p1
4223          TID Cond: (ctid = '(1,1)'::tid)
4224          Filter: ((id >= 50) AND (id <= 51))
4225    ->  Index Scan using t1_pkey on t1
4226          Index Cond: ((id = p1.id) AND (id < 10))
4227 (6 rows)
4228
4229 SET constraint_exclusion TO on;
4230 /*+SeqScan(p1)*/
4231 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;
4232 LOG:  pg_hint_plan:
4233 used hint:
4234 SeqScan(p1)
4235 not used hint:
4236 duplication hint:
4237 error hint:
4238
4239                               QUERY PLAN
4240 -----------------------------------------------------------------------
4241  Nested Loop
4242    ->  Seq Scan on p1
4243          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4244    ->  Index Scan using t1_pkey on t1
4245          Index Cond: ((id = p1.id) AND (id < 10))
4246 (5 rows)
4247
4248 /*+IndexScan(p1)*/
4249 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;
4250 LOG:  pg_hint_plan:
4251 used hint:
4252 IndexScan(p1)
4253 not used hint:
4254 duplication hint:
4255 error hint:
4256
4257                     QUERY PLAN
4258 --------------------------------------------------
4259  Nested Loop
4260    ->  Index Scan using p1_pkey on p1
4261          Index Cond: ((id >= 50) AND (id <= 51))
4262          Filter: (ctid = '(1,1)'::tid)
4263    ->  Index Scan using t1_pkey on t1
4264          Index Cond: ((id = p1.id) AND (id < 10))
4265 (6 rows)
4266
4267 /*+BitmapScan(p1)*/
4268 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;
4269 LOG:  pg_hint_plan:
4270 used hint:
4271 BitmapScan(p1)
4272 not used hint:
4273 duplication hint:
4274 error hint:
4275
4276                       QUERY PLAN
4277 -------------------------------------------------------
4278  Nested Loop
4279    ->  Bitmap Heap Scan on p1
4280          Recheck Cond: ((id >= 50) AND (id <= 51))
4281          Filter: (ctid = '(1,1)'::tid)
4282          ->  Bitmap Index Scan on p1_pkey
4283                Index Cond: ((id >= 50) AND (id <= 51))
4284    ->  Index Scan using t1_pkey on t1
4285          Index Cond: ((id = p1.id) AND (id < 10))
4286 (8 rows)
4287
4288 /*+TidScan(p1)*/
4289 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;
4290 LOG:  pg_hint_plan:
4291 used hint:
4292 TidScan(p1)
4293 not used hint:
4294 duplication hint:
4295 error hint:
4296
4297                     QUERY PLAN
4298 --------------------------------------------------
4299  Nested Loop
4300    ->  Tid Scan on p1
4301          TID Cond: (ctid = '(1,1)'::tid)
4302          Filter: ((id >= 50) AND (id <= 51))
4303    ->  Index Scan using t1_pkey on t1
4304          Index Cond: ((id = p1.id) AND (id < 10))
4305 (6 rows)
4306
4307 -- quote test
4308 /*+SeqScan("""t1 )      ")IndexScan("t  2 """)HashJoin("""t1 )  "T3"t   2 """)Leading("""t1 )   "T3"t   2 """)Set(application_name"a    a       a""     a       A")*/
4309 EXPLAIN (COSTS false) SELECT * FROM t1 """t1 )  ", t2 "t        2 """, t3 "T3" WHERE """t1 )    ".id = "t       2 """.id AND """t1 )    ".id = "T3".id;
4310 LOG:  pg_hint_plan:
4311 used hint:
4312 SeqScan("""t1 ) ")
4313 IndexScan("t    2 """)
4314 HashJoin("""t1 )        " T3 "t 2 """)
4315 Leading("""t1 ) " T3 "t 2 """)
4316 Set(application_name "a a       a""     a       A")
4317 not used hint:
4318 duplication hint:
4319 error hint:
4320
4321                        QUERY PLAN
4322 ---------------------------------------------------------
4323  Hash Join
4324    Hash Cond: ("t        2 """.id = """t1 )      ".id)
4325    ->  Index Scan using t2_pkey on t2 "t 2 """
4326    ->  Hash
4327          ->  Hash Join
4328                Hash Cond: ("""t1 )       ".id = "T3".id)
4329                ->  Seq Scan on t1 """t1 )        "
4330                ->  Hash
4331                      ->  Seq Scan on t3 "T3"
4332 (9 rows)
4333
4334 -- duplicate hint test
4335 /*+SeqScan(t1)SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)*/
4336 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
4337 INFO:  hint syntax error at or near "SeqScan(t1)SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4338 DETAIL:  Conflict scan method hint.
4339 INFO:  hint syntax error at or near "IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4340 DETAIL:  Conflict scan method hint.
4341 INFO:  hint syntax error at or near "BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4342 DETAIL:  Conflict scan method hint.
4343 INFO:  hint syntax error at or near "SeqScan(t2)IndexScan(t1)IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4344 DETAIL:  Conflict scan method hint.
4345 INFO:  hint syntax error at or near "IndexScan(t2)BitmapScan(t1)BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4346 DETAIL:  Conflict scan method hint.
4347 INFO:  hint syntax error at or near "BitmapScan(t2)TidScan(t1)TidScan(t2)HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4348 DETAIL:  Conflict scan method hint.
4349 INFO:  hint syntax error at or near "HashJoin(t1 t2)NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4350 DETAIL:  Conflict join method hint.
4351 INFO:  hint syntax error at or near "NestLoop(t2 t1)MergeJoin(t1 t2)Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4352 DETAIL:  Conflict join method hint.
4353 INFO:  hint syntax error at or near "Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4354 DETAIL:  Conflict set hint.
4355 INFO:  hint syntax error at or near "Leading(t1 t2)Leading(t2 t1)Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4356 DETAIL:  Conflict leading hint.
4357 LOG:  pg_hint_plan:
4358 used hint:
4359 TidScan(t1)
4360 TidScan(t2)
4361 MergeJoin(t1 t2)
4362 Leading(t2 t1)
4363 Set(enable_mergejoin on)
4364 Set(enable_seqscan on)
4365 not used hint:
4366 duplication hint:
4367 SeqScan(t1)
4368 IndexScan(t1)
4369 BitmapScan(t1)
4370 SeqScan(t2)
4371 IndexScan(t2)
4372 BitmapScan(t2)
4373 HashJoin(t1 t2)
4374 NestLoop(t1 t2)
4375 Leading(t1 t2)
4376 Set(enable_seqscan off)
4377 error hint:
4378
4379                   QUERY PLAN
4380 -----------------------------------------------
4381  Merge Join
4382    Merge Cond: (t1.id = t2.id)
4383    ->  Sort
4384          Sort Key: t1.id
4385          ->  Tid Scan on t1
4386                TID Cond: (ctid = '(1,1)'::tid)
4387    ->  Sort
4388          Sort Key: t2.id
4389          ->  Tid Scan on t2
4390                TID Cond: (ctid = '(1,1)'::tid)
4391 (10 rows)
4392
4393 -- sub query Leading hint test
4394 SET from_collapse_limit TO 100;
4395 SET geqo_threshold TO 100;
4396 EXPLAIN (COSTS false)
4397 WITH c1_1(id) AS (
4398 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4399 )
4400 SELECT t1_1.id, (
4401 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4402 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4403 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4404 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4405 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4406 );
4407                                   QUERY PLAN
4408 ------------------------------------------------------------------------------
4409  Nested Loop
4410    CTE c1_1
4411      ->  Aggregate
4412            ->  Merge Join
4413                  Merge Cond: (t1_5.id = t3_5.id)
4414                  ->  Merge Join
4415                        Merge Cond: (t1_5.id = t2_5.id)
4416                        ->  Index Only Scan using t1_pkey on t1 t1_5
4417                        ->  Index Only Scan using t2_pkey on t2 t2_5
4418                  ->  Sort
4419                        Sort Key: t3_5.id
4420                        ->  Seq Scan on t3 t3_5
4421    InitPlan 2 (returns $1)
4422      ->  Aggregate
4423            ->  Merge Join
4424                  Merge Cond: (t1_2.id = t3_2.id)
4425                  ->  Merge Join
4426                        Merge Cond: (t1_2.id = t2_2.id)
4427                        ->  Index Only Scan using t1_pkey on t1 t1_2
4428                        ->  Index Only Scan using t2_pkey on t2 t2_2
4429                  ->  Sort
4430                        Sort Key: t3_2.id
4431                        ->  Seq Scan on t3 t3_2
4432    InitPlan 3 (returns $2)
4433      ->  Aggregate
4434            ->  Merge Join
4435                  Merge Cond: (t1_4.id = t3_4.id)
4436                  ->  Merge Join
4437                        Merge Cond: (t1_4.id = t2_4.id)
4438                        ->  Index Only Scan using t1_pkey on t1 t1_4
4439                        ->  Index Only Scan using t2_pkey on t2 t2_4
4440                  ->  Sort
4441                        Sort Key: t3_4.id
4442                        ->  Seq Scan on t3 t3_4
4443    ->  Nested Loop
4444          ->  Nested Loop
4445                ->  Nested Loop
4446                      ->  Nested Loop
4447                            ->  Nested Loop
4448                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4449                                        Index Cond: (id = $2)
4450                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4451                                        Index Cond: (id = $2)
4452                            ->  Seq Scan on t3 t3_1
4453                                  Filter: (id = $2)
4454                      ->  Index Only Scan using t1_pkey on t1 t1_3
4455                            Index Cond: (id = $2)
4456                ->  Index Only Scan using t2_pkey on t2 t2_3
4457                      Index Cond: (id = $2)
4458          ->  Seq Scan on t3 t3_3
4459                Filter: (id = $2)
4460    ->  CTE Scan on c1_1
4461          Filter: (id = $2)
4462 (53 rows)
4463
4464 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)*/
4465 EXPLAIN (COSTS false)
4466 WITH c1_1(id) AS (
4467 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4468 )
4469 SELECT t1_1.id, (
4470 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4471 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4472 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4473 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4474 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4475 );
4476 LOG:  pg_hint_plan:
4477 used hint:
4478 HashJoin(t1_1 t3_1)
4479 NestLoop(t1_2 t2_2)
4480 MergeJoin(t1_3 t3_3)
4481 NestLoop(t1_4 t2_4)
4482 NestLoop(t1_5 t2_5)
4483 not used hint:
4484 duplication hint:
4485 error hint:
4486
4487                                   QUERY PLAN
4488 ------------------------------------------------------------------------------
4489  Nested Loop
4490    CTE c1_1
4491      ->  Aggregate
4492            ->  Merge Join
4493                  Merge Cond: (t1_5.id = t3_5.id)
4494                  ->  Nested Loop
4495                        ->  Index Only Scan using t2_pkey on t2 t2_5
4496                        ->  Index Only Scan using t1_pkey on t1 t1_5
4497                              Index Cond: (id = t2_5.id)
4498                  ->  Sort
4499                        Sort Key: t3_5.id
4500                        ->  Seq Scan on t3 t3_5
4501    InitPlan 2 (returns $3)
4502      ->  Aggregate
4503            ->  Merge Join
4504                  Merge Cond: (t1_2.id = t3_2.id)
4505                  ->  Nested Loop
4506                        ->  Index Only Scan using t2_pkey on t2 t2_2
4507                        ->  Index Only Scan using t1_pkey on t1 t1_2
4508                              Index Cond: (id = t2_2.id)
4509                  ->  Sort
4510                        Sort Key: t3_2.id
4511                        ->  Seq Scan on t3 t3_2
4512    InitPlan 3 (returns $5)
4513      ->  Aggregate
4514            ->  Merge Join
4515                  Merge Cond: (t1_4.id = t3_4.id)
4516                  ->  Nested Loop
4517                        ->  Index Only Scan using t2_pkey on t2 t2_4
4518                        ->  Index Only Scan using t1_pkey on t1 t1_4
4519                              Index Cond: (id = t2_4.id)
4520                  ->  Sort
4521                        Sort Key: t3_4.id
4522                        ->  Seq Scan on t3 t3_4
4523    ->  Nested Loop
4524          ->  Nested Loop
4525                ->  Nested Loop
4526                      ->  Nested Loop
4527                            ->  Nested Loop
4528                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4529                                        Index Cond: (id = $5)
4530                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4531                                        Index Cond: (id = $5)
4532                            ->  Seq Scan on t3 t3_1
4533                                  Filter: (id = $5)
4534                      ->  Index Only Scan using t1_pkey on t1 t1_3
4535                            Index Cond: (id = $5)
4536                ->  Index Only Scan using t2_pkey on t2 t2_3
4537                      Index Cond: (id = $5)
4538          ->  Seq Scan on t3 t3_3
4539                Filter: (id = $5)
4540    ->  CTE Scan on c1_1
4541          Filter: (id = $5)
4542 (53 rows)
4543
4544 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t1_1 t1_2 t1_4 t1_5)*/
4545 EXPLAIN (COSTS false)
4546 WITH c1_1(id) AS (
4547 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4548 )
4549 SELECT t1_1.id, (
4550 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4551 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4552 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4553 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4554 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4555 );
4556 LOG:  pg_hint_plan:
4557 used hint:
4558 HashJoin(t1_1 t3_1)
4559 NestLoop(t1_2 t2_2)
4560 MergeJoin(t1_3 t3_3)
4561 NestLoop(t1_4 t2_4)
4562 NestLoop(t1_5 t2_5)
4563 not used hint:
4564 Leading(a t1_1 t1_2 t1_4 t1_5)
4565 duplication hint:
4566 error hint:
4567
4568                                   QUERY PLAN
4569 ------------------------------------------------------------------------------
4570  Nested Loop
4571    CTE c1_1
4572      ->  Aggregate
4573            ->  Merge Join
4574                  Merge Cond: (t1_5.id = t3_5.id)
4575                  ->  Nested Loop
4576                        ->  Index Only Scan using t2_pkey on t2 t2_5
4577                        ->  Index Only Scan using t1_pkey on t1 t1_5
4578                              Index Cond: (id = t2_5.id)
4579                  ->  Sort
4580                        Sort Key: t3_5.id
4581                        ->  Seq Scan on t3 t3_5
4582    InitPlan 2 (returns $3)
4583      ->  Aggregate
4584            ->  Merge Join
4585                  Merge Cond: (t1_2.id = t3_2.id)
4586                  ->  Nested Loop
4587                        ->  Index Only Scan using t2_pkey on t2 t2_2
4588                        ->  Index Only Scan using t1_pkey on t1 t1_2
4589                              Index Cond: (id = t2_2.id)
4590                  ->  Sort
4591                        Sort Key: t3_2.id
4592                        ->  Seq Scan on t3 t3_2
4593    InitPlan 3 (returns $5)
4594      ->  Aggregate
4595            ->  Merge Join
4596                  Merge Cond: (t1_4.id = t3_4.id)
4597                  ->  Nested Loop
4598                        ->  Index Only Scan using t2_pkey on t2 t2_4
4599                        ->  Index Only Scan using t1_pkey on t1 t1_4
4600                              Index Cond: (id = t2_4.id)
4601                  ->  Sort
4602                        Sort Key: t3_4.id
4603                        ->  Seq Scan on t3 t3_4
4604    ->  Nested Loop
4605          ->  Nested Loop
4606                ->  Nested Loop
4607                      ->  Nested Loop
4608                            ->  Nested Loop
4609                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4610                                        Index Cond: (id = $5)
4611                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4612                                        Index Cond: (id = $5)
4613                            ->  Seq Scan on t3 t3_1
4614                                  Filter: (id = $5)
4615                      ->  Index Only Scan using t1_pkey on t1 t1_3
4616                            Index Cond: (id = $5)
4617                ->  Index Only Scan using t2_pkey on t2 t2_3
4618                      Index Cond: (id = $5)
4619          ->  Seq Scan on t3 t3_3
4620                Filter: (id = $5)
4621    ->  CTE Scan on c1_1
4622          Filter: (id = $5)
4623 (53 rows)
4624
4625 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)*/
4626 EXPLAIN (COSTS false)
4627 WITH c1_1(id) AS (
4628 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4629 )
4630 SELECT t1_1.id, (
4631 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4632 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4633 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4634 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4635 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4636 );
4637 LOG:  pg_hint_plan:
4638 used hint:
4639 HashJoin(t1_1 t3_1)
4640 NestLoop(t1_2 t2_2)
4641 MergeJoin(t1_3 t3_3)
4642 NestLoop(t1_4 t2_4)
4643 NestLoop(t1_5 t2_5)
4644 not used hint:
4645 Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)
4646 duplication hint:
4647 error hint:
4648
4649                                   QUERY PLAN
4650 ------------------------------------------------------------------------------
4651  Nested Loop
4652    CTE c1_1
4653      ->  Aggregate
4654            ->  Merge Join
4655                  Merge Cond: (t1_5.id = t3_5.id)
4656                  ->  Nested Loop
4657                        ->  Index Only Scan using t2_pkey on t2 t2_5
4658                        ->  Index Only Scan using t1_pkey on t1 t1_5
4659                              Index Cond: (id = t2_5.id)
4660                  ->  Sort
4661                        Sort Key: t3_5.id
4662                        ->  Seq Scan on t3 t3_5
4663    InitPlan 2 (returns $3)
4664      ->  Aggregate
4665            ->  Merge Join
4666                  Merge Cond: (t1_2.id = t3_2.id)
4667                  ->  Nested Loop
4668                        ->  Index Only Scan using t2_pkey on t2 t2_2
4669                        ->  Index Only Scan using t1_pkey on t1 t1_2
4670                              Index Cond: (id = t2_2.id)
4671                  ->  Sort
4672                        Sort Key: t3_2.id
4673                        ->  Seq Scan on t3 t3_2
4674    InitPlan 3 (returns $5)
4675      ->  Aggregate
4676            ->  Merge Join
4677                  Merge Cond: (t1_4.id = t3_4.id)
4678                  ->  Nested Loop
4679                        ->  Index Only Scan using t2_pkey on t2 t2_4
4680                        ->  Index Only Scan using t1_pkey on t1 t1_4
4681                              Index Cond: (id = t2_4.id)
4682                  ->  Sort
4683                        Sort Key: t3_4.id
4684                        ->  Seq Scan on t3 t3_4
4685    ->  Nested Loop
4686          ->  Nested Loop
4687                ->  Nested Loop
4688                      ->  Nested Loop
4689                            ->  Nested Loop
4690                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4691                                        Index Cond: (id = $5)
4692                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4693                                        Index Cond: (id = $5)
4694                            ->  Seq Scan on t3 t3_1
4695                                  Filter: (id = $5)
4696                      ->  Index Only Scan using t1_pkey on t1 t1_3
4697                            Index Cond: (id = $5)
4698                ->  Index Only Scan using t2_pkey on t2 t2_3
4699                      Index Cond: (id = $5)
4700          ->  Seq Scan on t3 t3_3
4701                Filter: (id = $5)
4702    ->  CTE Scan on c1_1
4703          Filter: (id = $5)
4704 (53 rows)
4705
4706 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(t3_5 t2_5 t1_5)Leading(t3_2 t2_2 t1_2)Leading(t3_4 t2_4 t1_4)Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)*/
4707 EXPLAIN (COSTS false)
4708 WITH c1_1(id) AS (
4709 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4710 )
4711 SELECT t1_1.id, (
4712 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4713 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4714 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4715 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4716 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4717 );
4718 LOG:  pg_hint_plan:
4719 used hint:
4720 Leading(t3_5 t2_5 t1_5)
4721 Leading(t3_2 t2_2 t1_2)
4722 Leading(t3_4 t2_4 t1_4)
4723 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
4724 not used hint:
4725 HashJoin(t1_1 t3_1)
4726 NestLoop(t1_2 t2_2)
4727 MergeJoin(t1_3 t3_3)
4728 NestLoop(t1_4 t2_4)
4729 NestLoop(t1_5 t2_5)
4730 duplication hint:
4731 error hint:
4732
4733                                QUERY PLAN
4734 ------------------------------------------------------------------------
4735  Nested Loop
4736    CTE c1_1
4737      ->  Aggregate
4738            ->  Merge Join
4739                  Merge Cond: (t2_5.id = t1_5.id)
4740                  ->  Merge Join
4741                        Merge Cond: (t2_5.id = t3_5.id)
4742                        ->  Index Only Scan using t2_pkey on t2 t2_5
4743                        ->  Sort
4744                              Sort Key: t3_5.id
4745                              ->  Seq Scan on t3 t3_5
4746                  ->  Index Only Scan using t1_pkey on t1 t1_5
4747    InitPlan 2 (returns $1)
4748      ->  Aggregate
4749            ->  Merge Join
4750                  Merge Cond: (t2_2.id = t1_2.id)
4751                  ->  Merge Join
4752                        Merge Cond: (t2_2.id = t3_2.id)
4753                        ->  Index Only Scan using t2_pkey on t2 t2_2
4754                        ->  Sort
4755                              Sort Key: t3_2.id
4756                              ->  Seq Scan on t3 t3_2
4757                  ->  Index Only Scan using t1_pkey on t1 t1_2
4758    InitPlan 3 (returns $2)
4759      ->  Aggregate
4760            ->  Merge Join
4761                  Merge Cond: (t2_4.id = t1_4.id)
4762                  ->  Merge Join
4763                        Merge Cond: (t2_4.id = t3_4.id)
4764                        ->  Index Only Scan using t2_pkey on t2 t2_4
4765                        ->  Sort
4766                              Sort Key: t3_4.id
4767                              ->  Seq Scan on t3 t3_4
4768                  ->  Index Only Scan using t1_pkey on t1 t1_4
4769    ->  Nested Loop
4770          ->  Nested Loop
4771                ->  Nested Loop
4772                      ->  Nested Loop
4773                            ->  Nested Loop
4774                                  ->  Seq Scan on t3 t3_3
4775                                        Filter: (id = $2)
4776                                  ->  CTE Scan on c1_1
4777                                        Filter: (id = $2)
4778                            ->  Index Only Scan using t2_pkey on t2 t2_3
4779                                  Index Cond: (id = $2)
4780                      ->  Index Only Scan using t1_pkey on t1 t1_3
4781                            Index Cond: (id = $2)
4782                ->  Seq Scan on t3 t3_1
4783                      Filter: (id = $2)
4784          ->  Index Only Scan using t2_pkey on t2 t2_1
4785                Index Cond: (id = $2)
4786    ->  Index Only Scan using t1_pkey on t1 t1_1
4787          Index Cond: (id = $2)
4788 (53 rows)
4789
4790 SET from_collapse_limit TO 1;
4791 EXPLAIN (COSTS false)
4792 WITH c1_1(id) AS (
4793 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4794 )
4795 SELECT t1_1.id, (
4796 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4797 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4798 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4799 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4800 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4801 );
4802                              QUERY PLAN
4803 --------------------------------------------------------------------
4804  Nested Loop
4805    CTE c1_1
4806      ->  Aggregate
4807            ->  Merge Join
4808                  Merge Cond: (t1_5.id = t3_5.id)
4809                  ->  Merge Join
4810                        Merge Cond: (t1_5.id = t2_5.id)
4811                        ->  Index Only Scan using t1_pkey on t1 t1_5
4812                        ->  Index Only Scan using t2_pkey on t2 t2_5
4813                  ->  Sort
4814                        Sort Key: t3_5.id
4815                        ->  Seq Scan on t3 t3_5
4816    InitPlan 2 (returns $1)
4817      ->  Aggregate
4818            ->  Merge Join
4819                  Merge Cond: (t1_2.id = t3_2.id)
4820                  ->  Merge Join
4821                        Merge Cond: (t1_2.id = t2_2.id)
4822                        ->  Index Only Scan using t1_pkey on t1 t1_2
4823                        ->  Index Only Scan using t2_pkey on t2 t2_2
4824                  ->  Sort
4825                        Sort Key: t3_2.id
4826                        ->  Seq Scan on t3 t3_2
4827    InitPlan 3 (returns $2)
4828      ->  Aggregate
4829            ->  Merge Join
4830                  Merge Cond: (t1_4.id = t3_4.id)
4831                  ->  Merge Join
4832                        Merge Cond: (t1_4.id = t2_4.id)
4833                        ->  Index Only Scan using t1_pkey on t1 t1_4
4834                        ->  Index Only Scan using t2_pkey on t2 t2_4
4835                  ->  Sort
4836                        Sort Key: t3_4.id
4837                        ->  Seq Scan on t3 t3_4
4838    ->  Nested Loop
4839          ->  Nested Loop
4840                ->  Nested Loop
4841                      ->  Index Only Scan using t1_pkey on t1 t1_1
4842                            Index Cond: (id = $2)
4843                      ->  Index Only Scan using t2_pkey on t2 t2_1
4844                            Index Cond: (id = $2)
4845                ->  Seq Scan on t3 t3_1
4846                      Filter: (id = $2)
4847          ->  Nested Loop
4848                ->  Nested Loop
4849                      ->  Index Only Scan using t1_pkey on t1 t1_3
4850                            Index Cond: (id = $2)
4851                      ->  Index Only Scan using t2_pkey on t2 t2_3
4852                            Index Cond: (id = $2)
4853                ->  Seq Scan on t3 t3_3
4854                      Filter: (id = $2)
4855    ->  CTE Scan on c1_1
4856          Filter: (id = $2)
4857 (53 rows)
4858
4859 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)*/
4860 EXPLAIN (COSTS false)
4861 WITH c1_1(id) AS (
4862 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4863 )
4864 SELECT t1_1.id, (
4865 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4866 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4867 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4868 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4869 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4870 );
4871 LOG:  pg_hint_plan:
4872 used hint:
4873 HashJoin(t1_1 t3_1)
4874 NestLoop(t1_2 t2_2)
4875 MergeJoin(t1_3 t3_3)
4876 NestLoop(t1_4 t2_4)
4877 NestLoop(t1_5 t2_5)
4878 not used hint:
4879 duplication hint:
4880 error hint:
4881
4882                              QUERY PLAN
4883 --------------------------------------------------------------------
4884  Nested Loop
4885    CTE c1_1
4886      ->  Aggregate
4887            ->  Merge Join
4888                  Merge Cond: (t1_5.id = t3_5.id)
4889                  ->  Nested Loop
4890                        ->  Index Only Scan using t2_pkey on t2 t2_5
4891                        ->  Index Only Scan using t1_pkey on t1 t1_5
4892                              Index Cond: (id = t2_5.id)
4893                  ->  Sort
4894                        Sort Key: t3_5.id
4895                        ->  Seq Scan on t3 t3_5
4896    InitPlan 2 (returns $3)
4897      ->  Aggregate
4898            ->  Merge Join
4899                  Merge Cond: (t1_2.id = t3_2.id)
4900                  ->  Nested Loop
4901                        ->  Index Only Scan using t2_pkey on t2 t2_2
4902                        ->  Index Only Scan using t1_pkey on t1 t1_2
4903                              Index Cond: (id = t2_2.id)
4904                  ->  Sort
4905                        Sort Key: t3_2.id
4906                        ->  Seq Scan on t3 t3_2
4907    InitPlan 3 (returns $5)
4908      ->  Aggregate
4909            ->  Merge Join
4910                  Merge Cond: (t1_4.id = t3_4.id)
4911                  ->  Nested Loop
4912                        ->  Index Only Scan using t2_pkey on t2 t2_4
4913                        ->  Index Only Scan using t1_pkey on t1 t1_4
4914                              Index Cond: (id = t2_4.id)
4915                  ->  Sort
4916                        Sort Key: t3_4.id
4917                        ->  Seq Scan on t3 t3_4
4918    ->  Nested Loop
4919          ->  Nested Loop
4920                ->  Nested Loop
4921                      ->  Index Only Scan using t1_pkey on t1 t1_1
4922                            Index Cond: (id = $5)
4923                      ->  Index Only Scan using t2_pkey on t2 t2_1
4924                            Index Cond: (id = $5)
4925                ->  Seq Scan on t3 t3_1
4926                      Filter: (id = $5)
4927          ->  Nested Loop
4928                ->  Nested Loop
4929                      ->  Index Only Scan using t1_pkey on t1 t1_3
4930                            Index Cond: (id = $5)
4931                      ->  Index Only Scan using t2_pkey on t2 t2_3
4932                            Index Cond: (id = $5)
4933                ->  Seq Scan on t3 t3_3
4934                      Filter: (id = $5)
4935    ->  CTE Scan on c1_1
4936          Filter: (id = $5)
4937 (53 rows)
4938
4939 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t1_1 t1_2 t1_4 t1_5)*/
4940 EXPLAIN (COSTS false)
4941 WITH c1_1(id) AS (
4942 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
4943 )
4944 SELECT t1_1.id, (
4945 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
4946 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4947 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
4948 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
4949 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
4950 );
4951 LOG:  pg_hint_plan:
4952 used hint:
4953 HashJoin(t1_1 t3_1)
4954 NestLoop(t1_2 t2_2)
4955 MergeJoin(t1_3 t3_3)
4956 NestLoop(t1_4 t2_4)
4957 NestLoop(t1_5 t2_5)
4958 not used hint:
4959 Leading(a t1_1 t1_2 t1_4 t1_5)
4960 duplication hint:
4961 error hint:
4962
4963                              QUERY PLAN
4964 --------------------------------------------------------------------
4965  Nested Loop
4966    CTE c1_1
4967      ->  Aggregate
4968            ->  Merge Join
4969                  Merge Cond: (t1_5.id = t3_5.id)
4970                  ->  Nested Loop
4971                        ->  Index Only Scan using t2_pkey on t2 t2_5
4972                        ->  Index Only Scan using t1_pkey on t1 t1_5
4973                              Index Cond: (id = t2_5.id)
4974                  ->  Sort
4975                        Sort Key: t3_5.id
4976                        ->  Seq Scan on t3 t3_5
4977    InitPlan 2 (returns $3)
4978      ->  Aggregate
4979            ->  Merge Join
4980                  Merge Cond: (t1_2.id = t3_2.id)
4981                  ->  Nested Loop
4982                        ->  Index Only Scan using t2_pkey on t2 t2_2
4983                        ->  Index Only Scan using t1_pkey on t1 t1_2
4984                              Index Cond: (id = t2_2.id)
4985                  ->  Sort
4986                        Sort Key: t3_2.id
4987                        ->  Seq Scan on t3 t3_2
4988    InitPlan 3 (returns $5)
4989      ->  Aggregate
4990            ->  Merge Join
4991                  Merge Cond: (t1_4.id = t3_4.id)
4992                  ->  Nested Loop
4993                        ->  Index Only Scan using t2_pkey on t2 t2_4
4994                        ->  Index Only Scan using t1_pkey on t1 t1_4
4995                              Index Cond: (id = t2_4.id)
4996                  ->  Sort
4997                        Sort Key: t3_4.id
4998                        ->  Seq Scan on t3 t3_4
4999    ->  Nested Loop
5000          ->  Nested Loop
5001                ->  Nested Loop
5002                      ->  Index Only Scan using t1_pkey on t1 t1_1
5003                            Index Cond: (id = $5)
5004                      ->  Index Only Scan using t2_pkey on t2 t2_1
5005                            Index Cond: (id = $5)
5006                ->  Seq Scan on t3 t3_1
5007                      Filter: (id = $5)
5008          ->  Nested Loop
5009                ->  Nested Loop
5010                      ->  Index Only Scan using t1_pkey on t1 t1_3
5011                            Index Cond: (id = $5)
5012                      ->  Index Only Scan using t2_pkey on t2 t2_3
5013                            Index Cond: (id = $5)
5014                ->  Seq Scan on t3 t3_3
5015                      Filter: (id = $5)
5016    ->  CTE Scan on c1_1
5017          Filter: (id = $5)
5018 (53 rows)
5019
5020 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)*/
5021 EXPLAIN (COSTS false)
5022 WITH c1_1(id) AS (
5023 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
5024 )
5025 SELECT t1_1.id, (
5026 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
5027 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5028 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
5029 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
5030 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
5031 );
5032 LOG:  pg_hint_plan:
5033 used hint:
5034 HashJoin(t1_1 t3_1)
5035 NestLoop(t1_2 t2_2)
5036 MergeJoin(t1_3 t3_3)
5037 NestLoop(t1_4 t2_4)
5038 NestLoop(t1_5 t2_5)
5039 not used hint:
5040 Leading(a t3_2 t3_5 t2_2 c1_1 t3_4 t3_3 t2_3 t2_4 t1_3 t2_5 t1_2 t3_1 t1_4 t2_1 t1_5 t1_1)
5041 duplication hint:
5042 error hint:
5043
5044                              QUERY PLAN
5045 --------------------------------------------------------------------
5046  Nested Loop
5047    CTE c1_1
5048      ->  Aggregate
5049            ->  Merge Join
5050                  Merge Cond: (t1_5.id = t3_5.id)
5051                  ->  Nested Loop
5052                        ->  Index Only Scan using t2_pkey on t2 t2_5
5053                        ->  Index Only Scan using t1_pkey on t1 t1_5
5054                              Index Cond: (id = t2_5.id)
5055                  ->  Sort
5056                        Sort Key: t3_5.id
5057                        ->  Seq Scan on t3 t3_5
5058    InitPlan 2 (returns $3)
5059      ->  Aggregate
5060            ->  Merge Join
5061                  Merge Cond: (t1_2.id = t3_2.id)
5062                  ->  Nested Loop
5063                        ->  Index Only Scan using t2_pkey on t2 t2_2
5064                        ->  Index Only Scan using t1_pkey on t1 t1_2
5065                              Index Cond: (id = t2_2.id)
5066                  ->  Sort
5067                        Sort Key: t3_2.id
5068                        ->  Seq Scan on t3 t3_2
5069    InitPlan 3 (returns $5)
5070      ->  Aggregate
5071            ->  Merge Join
5072                  Merge Cond: (t1_4.id = t3_4.id)
5073                  ->  Nested Loop
5074                        ->  Index Only Scan using t2_pkey on t2 t2_4
5075                        ->  Index Only Scan using t1_pkey on t1 t1_4
5076                              Index Cond: (id = t2_4.id)
5077                  ->  Sort
5078                        Sort Key: t3_4.id
5079                        ->  Seq Scan on t3 t3_4
5080    ->  Nested Loop
5081          ->  Nested Loop
5082                ->  Nested Loop
5083                      ->  Index Only Scan using t1_pkey on t1 t1_1
5084                            Index Cond: (id = $5)
5085                      ->  Index Only Scan using t2_pkey on t2 t2_1
5086                            Index Cond: (id = $5)
5087                ->  Seq Scan on t3 t3_1
5088                      Filter: (id = $5)
5089          ->  Nested Loop
5090                ->  Nested Loop
5091                      ->  Index Only Scan using t1_pkey on t1 t1_3
5092                            Index Cond: (id = $5)
5093                      ->  Index Only Scan using t2_pkey on t2 t2_3
5094                            Index Cond: (id = $5)
5095                ->  Seq Scan on t3 t3_3
5096                      Filter: (id = $5)
5097    ->  CTE Scan on c1_1
5098          Filter: (id = $5)
5099 (53 rows)
5100
5101 /*+HashJoin(t1_1 t3_1)MergeJoin(t1_3 t3_3)NestLoop(t1_2 t2_2)NestLoop(t1_4 t2_4)NestLoop(t1_5 t2_5)Leading(t3_5 t2_5 t1_5)Leading(t3_2 t2_2 t1_2)Leading(t3_4 t2_4 t1_4)Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)*/
5102 EXPLAIN (COSTS false)
5103 WITH c1_1(id) AS (
5104 SELECT max(t1_5.id) FROM t1 t1_5, t2 t2_5, t3 t3_5 WHERE t1_5.id = t2_5.id AND t2_5.id = t3_5.id
5105 )
5106 SELECT t1_1.id, (
5107 SELECT max(t1_2.id) FROM t1 t1_2, t2 t2_2, t3 t3_2 WHERE t1_2.id = t2_2.id AND t2_2.id = t3_2.id
5108 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5109 SELECT t1_3.id FROM t1 t1_3, t2 t2_3, t3 t3_3 WHERE t1_3.id = t2_3.id AND t2_3.id = t3_3.id
5110 ) v1_1(id), c1_1 WHERE t1_1.id = t2_1.id AND t2_1.id = t3_1.id AND t2_1.id = v1_1.id AND v1_1.id = c1_1.id AND t1_1.id = (
5111 SELECT max(t1_4.id) FROM t1 t1_4, t2 t2_4, t3 t3_4 WHERE t1_4.id = t2_4.id AND t2_4.id = t3_4.id
5112 );
5113 LOG:  pg_hint_plan:
5114 used hint:
5115 MergeJoin(t1_3 t3_3)
5116 Leading(t3_5 t2_5 t1_5)
5117 Leading(t3_2 t2_2 t1_2)
5118 Leading(t3_4 t2_4 t1_4)
5119 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
5120 not used hint:
5121 HashJoin(t1_1 t3_1)
5122 NestLoop(t1_2 t2_2)
5123 NestLoop(t1_4 t2_4)
5124 NestLoop(t1_5 t2_5)
5125 duplication hint:
5126 error hint:
5127
5128                                   QUERY PLAN
5129 ------------------------------------------------------------------------------
5130  Nested Loop
5131    CTE c1_1
5132      ->  Aggregate
5133            ->  Merge Join
5134                  Merge Cond: (t2_5.id = t1_5.id)
5135                  ->  Merge Join
5136                        Merge Cond: (t2_5.id = t3_5.id)
5137                        ->  Index Only Scan using t2_pkey on t2 t2_5
5138                        ->  Sort
5139                              Sort Key: t3_5.id
5140                              ->  Seq Scan on t3 t3_5
5141                  ->  Index Only Scan using t1_pkey on t1 t1_5
5142    InitPlan 2 (returns $1)
5143      ->  Aggregate
5144            ->  Merge Join
5145                  Merge Cond: (t2_2.id = t1_2.id)
5146                  ->  Merge Join
5147                        Merge Cond: (t2_2.id = t3_2.id)
5148                        ->  Index Only Scan using t2_pkey on t2 t2_2
5149                        ->  Sort
5150                              Sort Key: t3_2.id
5151                              ->  Seq Scan on t3 t3_2
5152                  ->  Index Only Scan using t1_pkey on t1 t1_2
5153    InitPlan 3 (returns $2)
5154      ->  Aggregate
5155            ->  Merge Join
5156                  Merge Cond: (t2_4.id = t1_4.id)
5157                  ->  Merge Join
5158                        Merge Cond: (t2_4.id = t3_4.id)
5159                        ->  Index Only Scan using t2_pkey on t2 t2_4
5160                        ->  Sort
5161                              Sort Key: t3_4.id
5162                              ->  Seq Scan on t3 t3_4
5163                  ->  Index Only Scan using t1_pkey on t1 t1_4
5164    ->  Nested Loop
5165          ->  Nested Loop
5166                ->  Nested Loop
5167                      ->  Nested Loop
5168                            ->  Nested Loop
5169                                  ->  Index Only Scan using t1_pkey on t1 t1_3
5170                                        Index Cond: (id = $2)
5171                                  ->  Index Only Scan using t2_pkey on t2 t2_3
5172                                        Index Cond: (id = $2)
5173                            ->  Seq Scan on t3 t3_3
5174                                  Filter: (id = $2)
5175                      ->  CTE Scan on c1_1
5176                            Filter: (id = $2)
5177                ->  Seq Scan on t3 t3_1
5178                      Filter: (id = $2)
5179          ->  Index Only Scan using t2_pkey on t2 t2_1
5180                Index Cond: (id = $2)
5181    ->  Index Only Scan using t1_pkey on t1 t1_1
5182          Index Cond: (id = $2)
5183 (53 rows)
5184
5185 -- ambigous error
5186 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5187                   QUERY PLAN
5188 -----------------------------------------------
5189  Merge Join
5190    Merge Cond: (public.t1.id = t2.id)
5191    ->  Merge Join
5192          Merge Cond: (public.t1.id = s0.t1.id)
5193          ->  Index Scan using t1_pkey on t1
5194          ->  Index Scan using t1_pkey on t1
5195    ->  Index Scan using t2_pkey on t2
5196 (7 rows)
5197
5198 /*+NestLoop(t1 t2)*/
5199 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5200 INFO:  hint syntax error at or near "NestLoop(t1 t2)"
5201 DETAIL:  Relation name "t1" is ambiguous.
5202 LOG:  pg_hint_plan:
5203 used hint:
5204 not used hint:
5205 duplication hint:
5206 error hint:
5207 NestLoop(t1 t2)
5208
5209                   QUERY PLAN
5210 -----------------------------------------------
5211  Merge Join
5212    Merge Cond: (public.t1.id = t2.id)
5213    ->  Merge Join
5214          Merge Cond: (public.t1.id = s0.t1.id)
5215          ->  Index Scan using t1_pkey on t1
5216          ->  Index Scan using t1_pkey on t1
5217    ->  Index Scan using t2_pkey on t2
5218 (7 rows)
5219
5220 /*+Leading(t1 t2 t1)*/
5221 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5222 INFO:  hint syntax error at or near "Leading(t1 t2 t1)"
5223 DETAIL:  Relation name "t1" is ambiguous.
5224 LOG:  pg_hint_plan:
5225 used hint:
5226 not used hint:
5227 duplication hint:
5228 error hint:
5229 Leading(t1 t2 t1)
5230
5231                   QUERY PLAN
5232 -----------------------------------------------
5233  Merge Join
5234    Merge Cond: (public.t1.id = t2.id)
5235    ->  Merge Join
5236          Merge Cond: (public.t1.id = s0.t1.id)
5237          ->  Index Scan using t1_pkey on t1
5238          ->  Index Scan using t1_pkey on t1
5239    ->  Index Scan using t2_pkey on t2
5240 (7 rows)
5241
5242 -- identifier length test
5243 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5244                                                   QUERY PLAN
5245 --------------------------------------------------------------------------------------------------------------
5246  Merge Join
5247    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5248    ->  Merge Join
5249          Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id)
5250          ->  Index Scan using t1_pkey on t1 "123456789012345678901234567890123456789012345678901234567890123"
5251          ->  Index Scan using t2_pkey on t2
5252    ->  Sort
5253          Sort Key: t3.id
5254          ->  Seq Scan on t3
5255 (9 rows)
5256
5257 /*+
5258 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5259 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5260 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5261 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5262 */
5263 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5264 INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5265 LOG:  pg_hint_plan:
5266 used hint:
5267 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5268 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5269 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5270 not used hint:
5271 duplication hint:
5272 error hint:
5273 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5274
5275                                              QUERY PLAN
5276 ----------------------------------------------------------------------------------------------------
5277  Merge Join
5278    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5279    ->  Merge Join
5280          Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5281          ->  Index Scan using t2_pkey on t2
5282          ->  Sort
5283                Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5284                ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5285    ->  Sort
5286          Sort Key: t3.id
5287          ->  Seq Scan on t3
5288 (11 rows)
5289
5290 /*+
5291 Leading(1234567890123456789012345678901234567890123456789012345678901234 t2 t3)
5292 SeqScan(1234567890123456789012345678901234567890123456789012345678901234)
5293 MergeJoin(1234567890123456789012345678901234567890123456789012345678901234 t2)
5294 Set(1234567890123456789012345678901234567890123456789012345678901234 1)
5295 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5296 */
5297 EXPLAIN (COSTS false) SELECT * FROM t1 "1234567890123456789012345678901234567890123456789012345678901234" JOIN t2 ON ("1234567890123456789012345678901234567890123456789012345678901234".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5298 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5299 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5300 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5301 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5302 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5303 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5304 INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5305 LOG:  pg_hint_plan:
5306 used hint:
5307 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5308 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5309 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5310 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5311 not used hint:
5312 duplication hint:
5313 error hint:
5314 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5315
5316                                              QUERY PLAN
5317 ----------------------------------------------------------------------------------------------------
5318  Merge Join
5319    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5320    ->  Merge Join
5321          Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5322          ->  Index Scan using t2_pkey on t2
5323          ->  Sort
5324                Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5325                ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5326    ->  Sort
5327          Sort Key: t3.id
5328          ->  Seq Scan on t3
5329 (11 rows)
5330
5331 SET "123456789012345678901234567890123456789012345678901234567890123" TO 1;
5332 ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5333 SET "1234567890123456789012345678901234567890123456789012345678901234" TO 1;
5334 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5335 ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5336 SET cursor_tuple_fraction TO 1234567890123456789012345678901234567890123456789012345678901234;
5337 ERROR:  1.23457e+63 is outside the valid range for parameter "cursor_tuple_fraction" (0 .. 1)
5338 -- multi error
5339 /*+ Set(enable_seqscan 100)Set(seq_page_cost on)*/
5340 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
5341 INFO:  parameter "enable_seqscan" requires a Boolean value
5342 INFO:  parameter "seq_page_cost" requires a numeric value
5343 LOG:  pg_hint_plan:
5344 used hint:
5345 not used hint:
5346 duplication hint:
5347 error hint:
5348 Set(enable_seqscan 100)
5349 Set(seq_page_cost on)
5350
5351               QUERY PLAN
5352 --------------------------------------
5353  Merge Join
5354    Merge Cond: (t1.id = t2.id)
5355    ->  Index Scan using t1_pkey on t1
5356    ->  Index Scan using t2_pkey on t2
5357 (4 rows)
5358
5359 -- debug log of candidate index to use IndexScan
5360 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5361                                        QUERY PLAN
5362 ----------------------------------------------------------------------------------------
5363  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
5364    Index Cond: (id = 1)
5365 (2 rows)
5366
5367 /*+IndexScan(t5 t5_id2)*/
5368 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5369 LOG:  available indexes for IndexScan(t5): t5_id2
5370 LOG:  pg_hint_plan:
5371 used hint:
5372 IndexScan(t5 t5_id2)
5373 not used hint:
5374 duplication hint:
5375 error hint:
5376
5377           QUERY PLAN
5378 -------------------------------
5379  Index Scan using t5_id2 on t5
5380    Index Cond: (id = 1)
5381 (2 rows)
5382
5383 /*+IndexScan(t5 no_exist)*/
5384 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5385 LOG:  available indexes for IndexScan(t5):
5386 LOG:  pg_hint_plan:
5387 used hint:
5388 IndexScan(t5 no_exist)
5389 not used hint:
5390 duplication hint:
5391 error hint:
5392
5393      QUERY PLAN
5394 --------------------
5395  Seq Scan on t5
5396    Filter: (id = 1)
5397 (2 rows)
5398
5399 /*+IndexScan(t5 t5_id1 t5_id2)*/
5400 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5401 LOG:  available indexes for IndexScan(t5): t5_id2 t5_id1
5402 LOG:  pg_hint_plan:
5403 used hint:
5404 IndexScan(t5 t5_id1 t5_id2)
5405 not used hint:
5406 duplication hint:
5407 error hint:
5408
5409           QUERY PLAN
5410 -------------------------------
5411  Index Scan using t5_id2 on t5
5412    Index Cond: (id = 1)
5413 (2 rows)
5414
5415 /*+IndexScan(t5 no_exist t5_id2)*/
5416 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5417 LOG:  available indexes for IndexScan(t5): t5_id2
5418 LOG:  pg_hint_plan:
5419 used hint:
5420 IndexScan(t5 no_exist t5_id2)
5421 not used hint:
5422 duplication hint:
5423 error hint:
5424
5425           QUERY PLAN
5426 -------------------------------
5427  Index Scan using t5_id2 on t5
5428    Index Cond: (id = 1)
5429 (2 rows)
5430
5431 /*+IndexScan(t5 no_exist5 no_exist2)*/
5432 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5433 LOG:  available indexes for IndexScan(t5):
5434 LOG:  pg_hint_plan:
5435 used hint:
5436 IndexScan(t5 no_exist5 no_exist2)
5437 not used hint:
5438 duplication hint:
5439 error hint:
5440
5441      QUERY PLAN
5442 --------------------
5443  Seq Scan on t5
5444    Filter: (id = 1)
5445 (2 rows)
5446
5447 -- outer inner
5448 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5449                        QUERY PLAN
5450 --------------------------------------------------------
5451  Hash Join
5452    Hash Cond: (t3.val = t2.val)
5453    ->  Seq Scan on t3
5454    ->  Hash
5455          ->  Hash Join
5456                Hash Cond: (t2.id = t1.id)
5457                ->  Seq Scan on t2
5458                ->  Hash
5459                      ->  Index Scan using t1_pkey on t1
5460                            Index Cond: (id < 10)
5461 (10 rows)
5462
5463 /*+Leading((t1))*/
5464 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5465 INFO:  hint syntax error at or near "Leading((t1))"
5466 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
5467 LOG:  pg_hint_plan:
5468 used hint:
5469 not used hint:
5470 duplication hint:
5471 error hint:
5472 Leading((t1))
5473
5474                        QUERY PLAN
5475 --------------------------------------------------------
5476  Hash Join
5477    Hash Cond: (t3.val = t2.val)
5478    ->  Seq Scan on t3
5479    ->  Hash
5480          ->  Hash Join
5481                Hash Cond: (t2.id = t1.id)
5482                ->  Seq Scan on t2
5483                ->  Hash
5484                      ->  Index Scan using t1_pkey on t1
5485                            Index Cond: (id < 10)
5486 (10 rows)
5487
5488 /*+Leading((t1 t2))*/
5489 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5490 LOG:  pg_hint_plan:
5491 used hint:
5492 Leading((t1 t2))
5493 not used hint:
5494 duplication hint:
5495 error hint:
5496
5497                  QUERY PLAN
5498 --------------------------------------------
5499  Nested Loop
5500    Join Filter: (t2.val = t3.val)
5501    ->  Hash Join
5502          Hash Cond: (t1.id = t2.id)
5503          ->  Index Scan using t1_pkey on t1
5504                Index Cond: (id < 10)
5505          ->  Hash
5506                ->  Seq Scan on t2
5507    ->  Seq Scan on t3
5508 (9 rows)
5509
5510 /*+Leading((t1 t2 t3))*/
5511 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5512 INFO:  hint syntax error at or near "Leading((t1 t2 t3))"
5513 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
5514 LOG:  pg_hint_plan:
5515 used hint:
5516 not used hint:
5517 duplication hint:
5518 error hint:
5519 Leading((t1 t2 t3))
5520
5521                        QUERY PLAN
5522 --------------------------------------------------------
5523  Hash Join
5524    Hash Cond: (t3.val = t2.val)
5525    ->  Seq Scan on t3
5526    ->  Hash
5527          ->  Hash Join
5528                Hash Cond: (t2.id = t1.id)
5529                ->  Seq Scan on t2
5530                ->  Hash
5531                      ->  Index Scan using t1_pkey on t1
5532                            Index Cond: (id < 10)
5533 (10 rows)
5534
5535 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5536                  QUERY PLAN
5537 --------------------------------------------
5538  Hash Join
5539    Hash Cond: (t2.id = t1.id)
5540    ->  Seq Scan on t2
5541    ->  Hash
5542          ->  Index Scan using t1_pkey on t1
5543                Index Cond: (id < 10)
5544 (6 rows)
5545
5546 /*+Leading((t1 t2))*/
5547 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5548 LOG:  pg_hint_plan:
5549 used hint:
5550 Leading((t1 t2))
5551 not used hint:
5552 duplication hint:
5553 error hint:
5554
5555               QUERY PLAN
5556 --------------------------------------
5557  Hash Join
5558    Hash Cond: (t1.id = t2.id)
5559    ->  Index Scan using t1_pkey on t1
5560          Index Cond: (id < 10)
5561    ->  Hash
5562          ->  Seq Scan on t2
5563 (6 rows)
5564
5565 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5566                        QUERY PLAN
5567 --------------------------------------------------------
5568  Hash Join
5569    Hash Cond: (t3.val = t2.val)
5570    ->  Seq Scan on t3
5571    ->  Hash
5572          ->  Hash Join
5573                Hash Cond: (t2.id = t1.id)
5574                ->  Seq Scan on t2
5575                ->  Hash
5576                      ->  Index Scan using t1_pkey on t1
5577                            Index Cond: (id < 10)
5578 (10 rows)
5579
5580 /*+Leading(((t1 t2) t3))*/
5581 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5582 LOG:  pg_hint_plan:
5583 used hint:
5584 Leading(((t1 t2) t3))
5585 not used hint:
5586 duplication hint:
5587 error hint:
5588
5589                  QUERY PLAN
5590 --------------------------------------------
5591  Nested Loop
5592    Join Filter: (t2.val = t3.val)
5593    ->  Hash Join
5594          Hash Cond: (t1.id = t2.id)
5595          ->  Index Scan using t1_pkey on t1
5596                Index Cond: (id < 10)
5597          ->  Hash
5598                ->  Seq Scan on t2
5599    ->  Seq Scan on t3
5600 (9 rows)
5601
5602 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5603                        QUERY PLAN
5604 --------------------------------------------------------
5605  Nested Loop
5606    ->  Merge Join
5607          Merge Cond: (t3.id = t4.id)
5608          ->  Nested Loop
5609                Join Filter: (t1.val = t3.val)
5610                ->  Index Scan using t3_pkey on t3
5611                ->  Materialize
5612                      ->  Index Scan using t1_pkey on t1
5613                            Index Cond: (id < 10)
5614          ->  Sort
5615                Sort Key: t4.id
5616                ->  Seq Scan on t4
5617    ->  Index Scan using t2_pkey on t2
5618          Index Cond: (id = t1.id)
5619 (14 rows)
5620
5621 /*+Leading((((t1 t2) t3) t4))*/
5622 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5623 LOG:  pg_hint_plan:
5624 used hint:
5625 Leading((((t1 t2) t3) t4))
5626 not used hint:
5627 duplication hint:
5628 error hint:
5629
5630                     QUERY PLAN
5631 --------------------------------------------------
5632  Nested Loop
5633    ->  Nested Loop
5634          Join Filter: (t1.val = t3.val)
5635          ->  Hash Join
5636                Hash Cond: (t1.id = t2.id)
5637                ->  Index Scan using t1_pkey on t1
5638                      Index Cond: (id < 10)
5639                ->  Hash
5640                      ->  Seq Scan on t2
5641          ->  Seq Scan on t3
5642    ->  Index Scan using t4_pkey on t4
5643          Index Cond: (id = t3.id)
5644 (12 rows)
5645
5646 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5647                        QUERY PLAN
5648 --------------------------------------------------------
5649  Hash Join
5650    Hash Cond: (t3.val = t2.val)
5651    ->  Seq Scan on t3
5652    ->  Hash
5653          ->  Hash Join
5654                Hash Cond: (t2.id = t1.id)
5655                ->  Seq Scan on t2
5656                ->  Hash
5657                      ->  Index Scan using t1_pkey on t1
5658                            Index Cond: (id < 10)
5659 (10 rows)
5660
5661 /*+Leading(((t1 t2) t3))*/
5662 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5663 LOG:  pg_hint_plan:
5664 used hint:
5665 Leading(((t1 t2) t3))
5666 not used hint:
5667 duplication hint:
5668 error hint:
5669
5670                  QUERY PLAN
5671 --------------------------------------------
5672  Nested Loop
5673    Join Filter: (t2.val = t3.val)
5674    ->  Hash Join
5675          Hash Cond: (t1.id = t2.id)
5676          ->  Index Scan using t1_pkey on t1
5677                Index Cond: (id < 10)
5678          ->  Hash
5679                ->  Seq Scan on t2
5680    ->  Seq Scan on t3
5681 (9 rows)
5682
5683 /*+Leading((t1 (t2 t3)))*/
5684 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5685 LOG:  pg_hint_plan:
5686 used hint:
5687 Leading((t1 (t2 t3)))
5688 not used hint:
5689 duplication hint:
5690 error hint:
5691
5692                  QUERY PLAN
5693 --------------------------------------------
5694  Hash Join
5695    Hash Cond: (t1.id = t2.id)
5696    ->  Index Scan using t1_pkey on t1
5697          Index Cond: (id < 10)
5698    ->  Hash
5699          ->  Hash Join
5700                Hash Cond: (t2.val = t3.val)
5701                ->  Seq Scan on t2
5702                ->  Hash
5703                      ->  Seq Scan on t3
5704 (10 rows)
5705
5706 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5707                        QUERY PLAN
5708 --------------------------------------------------------
5709  Nested Loop
5710    ->  Merge Join
5711          Merge Cond: (t3.id = t4.id)
5712          ->  Nested Loop
5713                Join Filter: (t1.val = t3.val)
5714                ->  Index Scan using t3_pkey on t3
5715                ->  Materialize
5716                      ->  Index Scan using t1_pkey on t1
5717                            Index Cond: (id < 10)
5718          ->  Sort
5719                Sort Key: t4.id
5720                ->  Seq Scan on t4
5721    ->  Index Scan using t2_pkey on t2
5722          Index Cond: (id = t1.id)
5723 (14 rows)
5724
5725 /*+Leading(((t1 t2) (t3 t4)))*/
5726 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5727 LOG:  pg_hint_plan:
5728 used hint:
5729 Leading(((t1 t2) (t3 t4)))
5730 not used hint:
5731 duplication hint:
5732 error hint:
5733
5734                  QUERY PLAN
5735 --------------------------------------------
5736  Nested Loop
5737    Join Filter: (t1.val = t3.val)
5738    ->  Hash Join
5739          Hash Cond: (t1.id = t2.id)
5740          ->  Index Scan using t1_pkey on t1
5741                Index Cond: (id < 10)
5742          ->  Hash
5743                ->  Seq Scan on t2
5744    ->  Merge Join
5745          Merge Cond: (t3.id = t4.id)
5746          ->  Index Scan using t3_pkey on t3
5747          ->  Sort
5748                Sort Key: t4.id
5749                ->  Seq Scan on t4
5750 (14 rows)
5751
5752 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
5753                              QUERY PLAN
5754 --------------------------------------------------------------------
5755  Hash Join
5756    Hash Cond: (t2.val = t3.val)
5757    InitPlan 1 (returns $1)
5758      ->  Limit
5759            ->  Sort
5760                  Sort Key: t1_2.id
5761                  ->  Nested Loop
5762                        ->  Index Scan using t2_val on t2 t2_2
5763                              Index Cond: (val > 100)
5764                        ->  Index Only Scan using t1_pkey on t1 t1_2
5765                              Index Cond: (id = t2_2.id)
5766    ->  Merge Join
5767          Merge Cond: (t1.id = t2.id)
5768          ->  Index Scan using t1_pkey on t1
5769                Index Cond: (id < $1)
5770          ->  Index Scan using t2_pkey on t2
5771    ->  Hash
5772          ->  Seq Scan on t3
5773 (18 rows)
5774
5775 /*+Leading(((t1 t2) t3)) Leading(((t3 t1) t2))*/
5776 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t1.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
5777 INFO:  hint syntax error at or near "Leading(((t1 t2) t3)) Leading(((t3 t1) t2))"
5778 DETAIL:  Conflict leading hint.
5779 LOG:  pg_hint_plan:
5780 used hint:
5781 Leading(((t3 t1) t2))
5782 not used hint:
5783 duplication hint:
5784 Leading(((t1 t2) t3))
5785 error hint:
5786
5787                              QUERY PLAN
5788 --------------------------------------------------------------------
5789  Hash Join
5790    Hash Cond: (t1.id = t2.id)
5791    InitPlan 1 (returns $1)
5792      ->  Limit
5793            ->  Sort
5794                  Sort Key: t1_2.id
5795                  ->  Nested Loop
5796                        ->  Index Scan using t2_val on t2 t2_2
5797                              Index Cond: (val > 100)
5798                        ->  Index Only Scan using t1_pkey on t1 t1_2
5799                              Index Cond: (id = t2_2.id)
5800    ->  Hash Join
5801          Hash Cond: (t3.val = t1.val)
5802          ->  Seq Scan on t3
5803          ->  Hash
5804                ->  Index Scan using t1_pkey on t1
5805                      Index Cond: (id < $1)
5806    ->  Hash
5807          ->  Seq Scan on t2
5808 (19 rows)
5809
5810 /*+Leading(((t1 t2) t3)) Leading((t1_2 t2_2))*/
5811 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
5812 LOG:  pg_hint_plan:
5813 used hint:
5814 Leading(((t1 t2) t3))
5815 Leading((t1_2 t2_2))
5816 not used hint:
5817 duplication hint:
5818 error hint:
5819
5820                           QUERY PLAN
5821 --------------------------------------------------------------
5822  Hash Join
5823    Hash Cond: (t2.val = t3.val)
5824    InitPlan 1 (returns $0)
5825      ->  Limit
5826            ->  Merge Join
5827                  Merge Cond: (t1_2.id = t2_2.id)
5828                  ->  Index Only Scan using t1_pkey on t1 t1_2
5829                  ->  Sort
5830                        Sort Key: t2_2.id
5831                        ->  Index Scan using t2_val on t2 t2_2
5832                              Index Cond: (val > 100)
5833    ->  Merge Join
5834          Merge Cond: (t1.id = t2.id)
5835          ->  Index Scan using t1_pkey on t1
5836                Index Cond: (id < $0)
5837          ->  Index Scan using t2_pkey on t2
5838    ->  Hash
5839          ->  Seq Scan on t3
5840 (18 rows)
5841
5842 /*+Leading(((((t1 t2) t3) t1_2) t2_2))*/
5843 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < ( SELECT t1_2.id FROM t1 t1_2, t2 t2_2 WHERE t1_2.id = t2_2.id AND t2_2.val > 100 ORDER BY t1_2.id LIMIT 1);
5844 LOG:  pg_hint_plan:
5845 used hint:
5846 not used hint:
5847 Leading(((((t1 t2) t3) t1_2) t2_2))
5848 duplication hint:
5849 error hint:
5850
5851                              QUERY PLAN
5852 --------------------------------------------------------------------
5853  Hash Join
5854    Hash Cond: (t2.val = t3.val)
5855    InitPlan 1 (returns $1)
5856      ->  Limit
5857            ->  Sort
5858                  Sort Key: t1_2.id
5859                  ->  Nested Loop
5860                        ->  Index Scan using t2_val on t2 t2_2
5861                              Index Cond: (val > 100)
5862                        ->  Index Only Scan using t1_pkey on t1 t1_2
5863                              Index Cond: (id = t2_2.id)
5864    ->  Merge Join
5865          Merge Cond: (t1.id = t2.id)
5866          ->  Index Scan using t1_pkey on t1
5867                Index Cond: (id < $1)
5868          ->  Index Scan using t2_pkey on t2
5869    ->  Hash
5870          ->  Seq Scan on t3
5871 (18 rows)
5872
5873 -- Specified outer/inner leading hint and join method hint at the same time
5874 /*+Leading(((t1 t2) t3))*/
5875 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5876 LOG:  pg_hint_plan:
5877 used hint:
5878 Leading(((t1 t2) t3))
5879 not used hint:
5880 duplication hint:
5881 error hint:
5882
5883                  QUERY PLAN
5884 --------------------------------------------
5885  Nested Loop
5886    Join Filter: (t2.val = t3.val)
5887    ->  Hash Join
5888          Hash Cond: (t1.id = t2.id)
5889          ->  Index Scan using t1_pkey on t1
5890                Index Cond: (id < 10)
5891          ->  Hash
5892                ->  Seq Scan on t2
5893    ->  Seq Scan on t3
5894 (9 rows)
5895
5896 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2)*/
5897 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5898 LOG:  pg_hint_plan:
5899 used hint:
5900 MergeJoin(t1 t2)
5901 Leading(((t1 t2) t3))
5902 not used hint:
5903 duplication hint:
5904 error hint:
5905
5906                  QUERY PLAN
5907 --------------------------------------------
5908  Nested Loop
5909    Join Filter: (t2.val = t3.val)
5910    ->  Merge Join
5911          Merge Cond: (t1.id = t2.id)
5912          ->  Index Scan using t1_pkey on t1
5913                Index Cond: (id < 10)
5914          ->  Index Scan using t2_pkey on t2
5915    ->  Seq Scan on t3
5916 (8 rows)
5917
5918 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3)*/
5919 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5920 LOG:  pg_hint_plan:
5921 used hint:
5922 MergeJoin(t1 t2 t3)
5923 Leading(((t1 t2) t3))
5924 not used hint:
5925 duplication hint:
5926 error hint:
5927
5928                     QUERY PLAN
5929 --------------------------------------------------
5930  Merge Join
5931    Merge Cond: (t2.val = t3.val)
5932    ->  Sort
5933          Sort Key: t2.val
5934          ->  Hash Join
5935                Hash Cond: (t1.id = t2.id)
5936                ->  Index Scan using t1_pkey on t1
5937                      Index Cond: (id < 10)
5938                ->  Hash
5939                      ->  Seq Scan on t2
5940    ->  Sort
5941          Sort Key: t3.val
5942          ->  Seq Scan on t3
5943 (13 rows)
5944
5945 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t3)*/
5946 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5947 LOG:  pg_hint_plan:
5948 used hint:
5949 Leading(((t1 t2) t3))
5950 not used hint:
5951 MergeJoin(t1 t3)
5952 duplication hint:
5953 error hint:
5954
5955                  QUERY PLAN
5956 --------------------------------------------
5957  Nested Loop
5958    Join Filter: (t2.val = t3.val)
5959    ->  Hash Join
5960          Hash Cond: (t1.id = t2.id)
5961          ->  Index Scan using t1_pkey on t1
5962                Index Cond: (id < 10)
5963          ->  Hash
5964                ->  Seq Scan on t2
5965    ->  Seq Scan on t3
5966 (9 rows)
5967
5968 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5969                        QUERY PLAN
5970 --------------------------------------------------------
5971  Nested Loop
5972    ->  Merge Join
5973          Merge Cond: (t3.id = t4.id)
5974          ->  Nested Loop
5975                Join Filter: (t1.val = t3.val)
5976                ->  Index Scan using t3_pkey on t3
5977                ->  Materialize
5978                      ->  Index Scan using t1_pkey on t1
5979                            Index Cond: (id < 10)
5980          ->  Sort
5981                Sort Key: t4.id
5982                ->  Seq Scan on t4
5983    ->  Index Scan using t2_pkey on t2
5984          Index Cond: (id = t1.id)
5985 (14 rows)
5986
5987 /*+Leading(((t1 t2) t3)) MergeJoin(t3 t4)*/
5988 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
5989 LOG:  pg_hint_plan:
5990 used hint:
5991 Leading(((t1 t2) t3))
5992 not used hint:
5993 MergeJoin(t3 t4)
5994 duplication hint:
5995 error hint:
5996
5997                     QUERY PLAN
5998 --------------------------------------------------
5999  Nested Loop
6000    ->  Nested Loop
6001          Join Filter: (t1.val = t3.val)
6002          ->  Hash Join
6003                Hash Cond: (t1.id = t2.id)
6004                ->  Index Scan using t1_pkey on t1
6005                      Index Cond: (id < 10)
6006                ->  Hash
6007                      ->  Seq Scan on t2
6008          ->  Seq Scan on t3
6009    ->  Index Scan using t4_pkey on t4
6010          Index Cond: (id = t3.id)
6011 (12 rows)
6012
6013 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3 t4)*/
6014 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4 WHERE t1.id = t2.id AND t3.id = t4.id AND t1.val = t3.val AND t1.id < 10;
6015 LOG:  pg_hint_plan:
6016 used hint:
6017 MergeJoin(t1 t2 t3 t4)
6018 Leading(((t1 t2) t3))
6019 not used hint:
6020 duplication hint:
6021 error hint:
6022
6023                        QUERY PLAN
6024 --------------------------------------------------------
6025  Merge Join
6026    Merge Cond: (t3.id = t4.id)
6027    ->  Sort
6028          Sort Key: t3.id
6029          ->  Nested Loop
6030                Join Filter: (t1.val = t3.val)
6031                ->  Hash Join
6032                      Hash Cond: (t1.id = t2.id)
6033                      ->  Index Scan using t1_pkey on t1
6034                            Index Cond: (id < 10)
6035                      ->  Hash
6036                            ->  Seq Scan on t2
6037                ->  Seq Scan on t3
6038    ->  Sort
6039          Sort Key: t4.id
6040          ->  Seq Scan on t4
6041 (16 rows)
6042
6043 /*+ Leading ( ( t1 ( t2 t3 ) ) ) */
6044 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6045 LOG:  pg_hint_plan:
6046 used hint:
6047 Leading((t1 (t2 t3)))
6048 not used hint:
6049 duplication hint:
6050 error hint:
6051
6052                  QUERY PLAN
6053 --------------------------------------------
6054  Hash Join
6055    Hash Cond: (t1.id = t2.id)
6056    ->  Index Scan using t1_pkey on t1
6057          Index Cond: (id < 10)
6058    ->  Hash
6059          ->  Hash Join
6060                Hash Cond: (t2.val = t3.val)
6061                ->  Seq Scan on t2
6062                ->  Hash
6063                      ->  Seq Scan on t3
6064 (10 rows)
6065
6066 /*+Leading((t1(t2 t3)))*/
6067 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6068 LOG:  pg_hint_plan:
6069 used hint:
6070 Leading((t1 (t2 t3)))
6071 not used hint:
6072 duplication hint:
6073 error hint:
6074
6075                  QUERY PLAN
6076 --------------------------------------------
6077  Hash Join
6078    Hash Cond: (t1.id = t2.id)
6079    ->  Index Scan using t1_pkey on t1
6080          Index Cond: (id < 10)
6081    ->  Hash
6082          ->  Hash Join
6083                Hash Cond: (t2.val = t3.val)
6084                ->  Seq Scan on t2
6085                ->  Hash
6086                      ->  Seq Scan on t3
6087 (10 rows)
6088
6089 /*+Leading(("t1(t2" "t3)"))*/
6090 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6091 LOG:  pg_hint_plan:
6092 used hint:
6093 not used hint:
6094 Leading(("t1(t2" "t3)"))
6095 duplication hint:
6096 error hint:
6097
6098                        QUERY PLAN
6099 --------------------------------------------------------
6100  Hash Join
6101    Hash Cond: (t3.val = t2.val)
6102    ->  Seq Scan on t3
6103    ->  Hash
6104          ->  Hash Join
6105                Hash Cond: (t2.id = t1.id)
6106                ->  Seq Scan on t2
6107                ->  Hash
6108                      ->  Index Scan using t1_pkey on t1
6109                            Index Cond: (id < 10)
6110 (10 rows)
6111
6112 /*+ Leading ( ( ( t1 t2 ) t3 ) ) */
6113 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6114 LOG:  pg_hint_plan:
6115 used hint:
6116 Leading(((t1 t2) t3))
6117 not used hint:
6118 duplication hint:
6119 error hint:
6120
6121                  QUERY PLAN
6122 --------------------------------------------
6123  Nested Loop
6124    Join Filter: (t2.val = t3.val)
6125    ->  Hash Join
6126          Hash Cond: (t1.id = t2.id)
6127          ->  Index Scan using t1_pkey on t1
6128                Index Cond: (id < 10)
6129          ->  Hash
6130                ->  Seq Scan on t2
6131    ->  Seq Scan on t3
6132 (9 rows)
6133
6134 /*+Leading(((t1 t2)t3))*/
6135 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6136 LOG:  pg_hint_plan:
6137 used hint:
6138 Leading(((t1 t2) t3))
6139 not used hint:
6140 duplication hint:
6141 error hint:
6142
6143                  QUERY PLAN
6144 --------------------------------------------
6145  Nested Loop
6146    Join Filter: (t2.val = t3.val)
6147    ->  Hash Join
6148          Hash Cond: (t1.id = t2.id)
6149          ->  Index Scan using t1_pkey on t1
6150                Index Cond: (id < 10)
6151          ->  Hash
6152                ->  Seq Scan on t2
6153    ->  Seq Scan on t3
6154 (9 rows)
6155
6156 /*+Leading(("(t1" "t2)t3"))*/
6157 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6158 LOG:  pg_hint_plan:
6159 used hint:
6160 not used hint:
6161 Leading(("(t1" "t2)t3"))
6162 duplication hint:
6163 error hint:
6164
6165                        QUERY PLAN
6166 --------------------------------------------------------
6167  Hash Join
6168    Hash Cond: (t3.val = t2.val)
6169    ->  Seq Scan on t3
6170    ->  Hash
6171          ->  Hash Join
6172                Hash Cond: (t2.id = t1.id)
6173                ->  Seq Scan on t2
6174                ->  Hash
6175                      ->  Index Scan using t1_pkey on t1
6176                            Index Cond: (id < 10)
6177 (10 rows)
6178
6179 /*+Leading((t1(t2(t3(t4 t5)))))*/
6180 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6181 LOG:  pg_hint_plan:
6182 used hint:
6183 Leading((t1 (t2 (t3 (t4 t5)))))
6184 not used hint:
6185 duplication hint:
6186 error hint:
6187
6188                                                             QUERY PLAN
6189 ----------------------------------------------------------------------------------------------------------------------------------
6190  Merge Join
6191    Merge Cond: (t1.id = t2.id)
6192    ->  Index Scan using t1_pkey on t1
6193    ->  Materialize
6194          ->  Merge Join
6195                Merge Cond: (t2.id = t3.id)
6196                ->  Index Scan using t2_pkey on t2
6197                ->  Materialize
6198                      ->  Merge Join
6199                            Merge Cond: (t3.id = t4.id)
6200                            ->  Index Scan using t3_pkey on t3
6201                            ->  Materialize
6202                                  ->  Merge Join
6203                                        Merge Cond: (t4.id = t5.id)
6204                                        ->  Index Scan using t4_pkey on t4
6205                                        ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6206 (16 rows)
6207
6208 /*+Leading((t5(t4(t3(t2 t1)))))*/
6209 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6210 LOG:  pg_hint_plan:
6211 used hint:
6212 Leading((t5 (t4 (t3 (t2 t1)))))
6213 not used hint:
6214 duplication hint:
6215 error hint:
6216
6217                                 QUERY PLAN
6218 --------------------------------------------------------------------------
6219  Hash Join
6220    Hash Cond: (t5.id = t1.id)
6221    ->  Seq Scan on t5
6222    ->  Hash
6223          ->  Merge Join
6224                Merge Cond: (t4.id = t1.id)
6225                ->  Sort
6226                      Sort Key: t4.id
6227                      ->  Seq Scan on t4
6228                ->  Materialize
6229                      ->  Merge Join
6230                            Merge Cond: (t3.id = t1.id)
6231                            ->  Sort
6232                                  Sort Key: t3.id
6233                                  ->  Seq Scan on t3
6234                            ->  Materialize
6235                                  ->  Merge Join
6236                                        Merge Cond: (t2.id = t1.id)
6237                                        ->  Index Scan using t2_pkey on t2
6238                                        ->  Index Scan using t1_pkey on t1
6239 (20 rows)
6240
6241 /*+Leading(((((t1 t2)t3)t4)t5))*/
6242 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6243 LOG:  pg_hint_plan:
6244 used hint:
6245 Leading(((((t1 t2) t3) t4) t5))
6246 not used hint:
6247 duplication hint:
6248 error hint:
6249
6250                                           QUERY PLAN
6251 ----------------------------------------------------------------------------------------------
6252  Nested Loop
6253    ->  Merge Join
6254          Merge Cond: (t1.id = t4.id)
6255          ->  Merge Join
6256                Merge Cond: (t1.id = t3.id)
6257                ->  Merge Join
6258                      Merge Cond: (t1.id = t2.id)
6259                      ->  Index Scan using t1_pkey on t1
6260                      ->  Index Scan using t2_pkey on t2
6261                ->  Index Scan using t3_pkey on t3
6262          ->  Sort
6263                Sort Key: t4.id
6264                ->  Seq Scan on t4
6265    ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6266          Index Cond: (id = t1.id)
6267 (15 rows)
6268
6269 /*+Leading(((((t5 t4)t3)t2)t1))*/
6270 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6271 LOG:  pg_hint_plan:
6272 used hint:
6273 Leading(((((t5 t4) t3) t2) t1))
6274 not used hint:
6275 duplication hint:
6276 error hint:
6277
6278                                                    QUERY PLAN
6279 ----------------------------------------------------------------------------------------------------------------
6280  Nested Loop
6281    Join Filter: (t2.id = t1.id)
6282    ->  Nested Loop
6283          Join Filter: (t3.id = t2.id)
6284          ->  Merge Join
6285                Merge Cond: (t4.id = t3.id)
6286                ->  Merge Join
6287                      Merge Cond: (t5.id = t4.id)
6288                      ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6289                      ->  Sort
6290                            Sort Key: t4.id
6291                            ->  Seq Scan on t4
6292                ->  Index Scan using t3_pkey on t3
6293          ->  Index Scan using t2_pkey on t2
6294                Index Cond: (id = t5.id)
6295    ->  Index Scan using t1_pkey on t1
6296          Index Cond: (id = t5.id)
6297 (17 rows)
6298
6299 /*+Leading(((t1 t2)(t3(t4 t5))))*/
6300 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6301 LOG:  pg_hint_plan:
6302 used hint:
6303 Leading(((t1 t2) (t3 (t4 t5))))
6304 not used hint:
6305 duplication hint:
6306 error hint:
6307
6308                                                       QUERY PLAN
6309 ----------------------------------------------------------------------------------------------------------------------
6310  Merge Join
6311    Merge Cond: (t1.id = t3.id)
6312    ->  Merge Join
6313          Merge Cond: (t1.id = t2.id)
6314          ->  Index Scan using t1_pkey on t1
6315          ->  Index Scan using t2_pkey on t2
6316    ->  Materialize
6317          ->  Merge Join
6318                Merge Cond: (t3.id = t4.id)
6319                ->  Index Scan using t3_pkey on t3
6320                ->  Materialize
6321                      ->  Merge Join
6322                            Merge Cond: (t4.id = t5.id)
6323                            ->  Index Scan using t4_pkey on t4
6324                            ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6325 (15 rows)
6326
6327 /*+Leading(((t5 t4)(t3(t2 t1))))*/
6328 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6329 LOG:  pg_hint_plan:
6330 used hint:
6331 Leading(((t5 t4) (t3 (t2 t1))))
6332 not used hint:
6333 duplication hint:
6334 error hint:
6335
6336                                              QUERY PLAN
6337 ----------------------------------------------------------------------------------------------------
6338  Merge Join
6339    Merge Cond: (t4.id = t1.id)
6340    ->  Merge Join
6341          Merge Cond: (t5.id = t4.id)
6342          ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6343          ->  Sort
6344                Sort Key: t4.id
6345                ->  Seq Scan on t4
6346    ->  Materialize
6347          ->  Merge Join
6348                Merge Cond: (t3.id = t1.id)
6349                ->  Index Scan using t3_pkey on t3
6350                ->  Materialize
6351                      ->  Merge Join
6352                            Merge Cond: (t2.id = t1.id)
6353                            ->  Index Scan using t2_pkey on t2
6354                            ->  Index Scan using t1_pkey on t1
6355 (17 rows)
6356
6357 /*+Leading((((t1 t2)t3)(t4 t5)))*/
6358 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6359 LOG:  pg_hint_plan:
6360 used hint:
6361 Leading((((t1 t2) t3) (t4 t5)))
6362 not used hint:
6363 duplication hint:
6364 error hint:
6365
6366                                                 QUERY PLAN
6367 ----------------------------------------------------------------------------------------------------------
6368  Merge Join
6369    Merge Cond: (t1.id = t4.id)
6370    ->  Merge Join
6371          Merge Cond: (t1.id = t3.id)
6372          ->  Merge Join
6373                Merge Cond: (t1.id = t2.id)
6374                ->  Index Scan using t1_pkey on t1
6375                ->  Index Scan using t2_pkey on t2
6376          ->  Index Scan using t3_pkey on t3
6377    ->  Materialize
6378          ->  Merge Join
6379                Merge Cond: (t4.id = t5.id)
6380                ->  Index Scan using t4_pkey on t4
6381                ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6382 (14 rows)
6383
6384 /*+Leading((((t5 t4)t3)(t2 t1)))*/
6385 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3, t4, t5 WHERE t1.id = t2.id AND t1.id = t3.id AND t1.id = t4.id AND t1.id = t5.id;
6386 LOG:  pg_hint_plan:
6387 used hint:
6388 Leading((((t5 t4) t3) (t2 t1)))
6389 not used hint:
6390 duplication hint:
6391 error hint:
6392
6393                                                 QUERY PLAN
6394 ----------------------------------------------------------------------------------------------------------
6395  Merge Join
6396    Merge Cond: (t3.id = t1.id)
6397    ->  Merge Join
6398          Merge Cond: (t4.id = t3.id)
6399          ->  Merge Join
6400                Merge Cond: (t5.id = t4.id)
6401                ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6402                ->  Sort
6403                      Sort Key: t4.id
6404                      ->  Seq Scan on t4
6405          ->  Index Scan using t3_pkey on t3
6406    ->  Materialize
6407          ->  Merge Join
6408                Merge Cond: (t2.id = t1.id)
6409                ->  Index Scan using t2_pkey on t2
6410                ->  Index Scan using t1_pkey on t1
6411 (16 rows)
6412
6413 -- inherite table test to specify the index's name
6414 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6415                                  QUERY PLAN
6416 -----------------------------------------------------------------------------
6417  Result
6418    ->  Append
6419          ->  Seq Scan on p2
6420                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6421          ->  Seq Scan on p2_c1 p2
6422                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6423          ->  Tid Scan on p2_c1_c1 p2
6424                TID Cond: (ctid = '(1,1)'::tid)
6425                Filter: ((id >= 50) AND (id <= 51))
6426          ->  Tid Scan on p2_c1_c2 p2
6427                TID Cond: (ctid = '(1,1)'::tid)
6428                Filter: ((id >= 50) AND (id <= 51))
6429 (12 rows)
6430
6431 /*+IndexScan(p2 p2_pkey)*/
6432 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6433 LOG:  available indexes for IndexScan(p2): p2_pkey
6434 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6435 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6436 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6437 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6438 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6439 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6440 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6441 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6442 LOG:  pg_hint_plan:
6443 used hint:
6444 IndexScan(p2 p2_pkey)
6445 not used hint:
6446 duplication hint:
6447 error hint:
6448
6449                         QUERY PLAN
6450 -----------------------------------------------------------
6451  Result
6452    ->  Append
6453          ->  Index Scan using p2_pkey on p2
6454                Index Cond: ((id >= 50) AND (id <= 51))
6455                Filter: (ctid = '(1,1)'::tid)
6456          ->  Index Scan using p2_c1_pkey on p2_c1 p2
6457                Index Cond: ((id >= 50) AND (id <= 51))
6458                Filter: (ctid = '(1,1)'::tid)
6459          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6460                Index Cond: ((id >= 50) AND (id <= 51))
6461                Filter: (ctid = '(1,1)'::tid)
6462          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6463                Index Cond: ((id >= 50) AND (id <= 51))
6464                Filter: (ctid = '(1,1)'::tid)
6465 (14 rows)
6466
6467 /*+IndexScan(p2 p2_id_val_idx)*/
6468 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6469 LOG:  available indexes for IndexScan(p2): p2_id_val_idx
6470 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6471 LOG:  available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
6472 LOG:  available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
6473 LOG:  available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
6474 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
6475 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
6476 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
6477 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
6478 LOG:  pg_hint_plan:
6479 used hint:
6480 IndexScan(p2 p2_id_val_idx)
6481 not used hint:
6482 duplication hint:
6483 error hint:
6484
6485                            QUERY PLAN
6486 -----------------------------------------------------------------
6487  Result
6488    ->  Append
6489          ->  Index Scan using p2_id_val_idx on p2
6490                Index Cond: ((id >= 50) AND (id <= 51))
6491                Filter: (ctid = '(1,1)'::tid)
6492          ->  Index Scan using p2_c1_id_val_idx on p2_c1 p2
6493                Index Cond: ((id >= 50) AND (id <= 51))
6494                Filter: (ctid = '(1,1)'::tid)
6495          ->  Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1 p2
6496                Index Cond: ((id >= 50) AND (id <= 51))
6497                Filter: (ctid = '(1,1)'::tid)
6498          ->  Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2 p2
6499                Index Cond: ((id >= 50) AND (id <= 51))
6500                Filter: (ctid = '(1,1)'::tid)
6501 (14 rows)
6502
6503 /*+IndexScan(p2 p2_val_id_idx)*/
6504 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6505 LOG:  available indexes for IndexScan(p2): p2_val_id_idx
6506 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_id_idx
6507 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_id_idx
6508 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_id_idx
6509 LOG:  available indexes for IndexScan(p2_c4):
6510 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_id_idx
6511 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_id_idx
6512 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_id_idx
6513 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_id_idx
6514 LOG:  pg_hint_plan:
6515 used hint:
6516 IndexScan(p2 p2_val_id_idx)
6517 not used hint:
6518 duplication hint:
6519 error hint:
6520
6521                            QUERY PLAN
6522 -----------------------------------------------------------------
6523  Result
6524    ->  Append
6525          ->  Index Scan using p2_val_id_idx on p2
6526                Index Cond: ((id >= 50) AND (id <= 51))
6527                Filter: (ctid = '(1,1)'::tid)
6528          ->  Index Scan using p2_c1_val_id_idx on p2_c1 p2
6529                Index Cond: ((id >= 50) AND (id <= 51))
6530                Filter: (ctid = '(1,1)'::tid)
6531          ->  Index Scan using p2_c1_c1_val_id_idx on p2_c1_c1 p2
6532                Index Cond: ((id >= 50) AND (id <= 51))
6533                Filter: (ctid = '(1,1)'::tid)
6534          ->  Index Scan using p2_c1_c2_val_id_idx on p2_c1_c2 p2
6535                Index Cond: ((id >= 50) AND (id <= 51))
6536                Filter: (ctid = '(1,1)'::tid)
6537 (14 rows)
6538
6539 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6540                                           QUERY PLAN
6541 -----------------------------------------------------------------------------------------------
6542  Result
6543    ->  Append
6544          ->  Seq Scan on p2
6545                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6546          ->  Seq Scan on p2_c1 p2
6547                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6548          ->  Seq Scan on p2_c2 p2
6549                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6550          ->  Seq Scan on p2_c3 p2
6551                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6552          ->  Tid Scan on p2_c4 p2
6553                TID Cond: (ctid = '(1,1)'::tid)
6554                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6555          ->  Tid Scan on p2_c1_c1 p2
6556                TID Cond: (ctid = '(1,1)'::tid)
6557                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6558          ->  Tid Scan on p2_c1_c2 p2
6559                TID Cond: (ctid = '(1,1)'::tid)
6560                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6561          ->  Tid Scan on p2_c3_c1 p2
6562                TID Cond: (ctid = '(1,1)'::tid)
6563                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6564          ->  Tid Scan on p2_c3_c2 p2
6565                TID Cond: (ctid = '(1,1)'::tid)
6566                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6567 (25 rows)
6568
6569 /*+IndexScan(p2 p2_val)*/
6570 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6571 LOG:  available indexes for IndexScan(p2):
6572 LOG:  available indexes for IndexScan(p2_c1):
6573 LOG:  available indexes for IndexScan(p2_c2):
6574 LOG:  available indexes for IndexScan(p2_c3):
6575 LOG:  available indexes for IndexScan(p2_c4):
6576 LOG:  available indexes for IndexScan(p2_c1_c1):
6577 LOG:  available indexes for IndexScan(p2_c1_c2):
6578 LOG:  available indexes for IndexScan(p2_c3_c1):
6579 LOG:  available indexes for IndexScan(p2_c3_c2):
6580 LOG:  pg_hint_plan:
6581 used hint:
6582 IndexScan(p2 p2_val)
6583 not used hint:
6584 duplication hint:
6585 error hint:
6586
6587                                           QUERY PLAN
6588 -----------------------------------------------------------------------------------------------
6589  Result
6590    ->  Append
6591          ->  Seq Scan on p2
6592                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6593          ->  Seq Scan on p2_c1 p2
6594                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6595          ->  Seq Scan on p2_c2 p2
6596                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6597          ->  Seq Scan on p2_c3 p2
6598                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6599          ->  Tid Scan on p2_c4 p2
6600                TID Cond: (ctid = '(1,1)'::tid)
6601                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6602          ->  Tid Scan on p2_c1_c1 p2
6603                TID Cond: (ctid = '(1,1)'::tid)
6604                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6605          ->  Tid Scan on p2_c1_c2 p2
6606                TID Cond: (ctid = '(1,1)'::tid)
6607                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6608          ->  Tid Scan on p2_c3_c1 p2
6609                TID Cond: (ctid = '(1,1)'::tid)
6610                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6611          ->  Tid Scan on p2_c3_c2 p2
6612                TID Cond: (ctid = '(1,1)'::tid)
6613                Filter: ((val >= '50'::text) AND (val <= '51'::text))
6614 (25 rows)
6615
6616 /*+IndexScan(p2 p2_pkey)*/
6617 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6618 LOG:  available indexes for IndexScan(p2): p2_pkey
6619 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6620 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6621 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6622 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6623 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6624 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6625 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6626 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6627 LOG:  pg_hint_plan:
6628 used hint:
6629 IndexScan(p2 p2_pkey)
6630 not used hint:
6631 duplication hint:
6632 error hint:
6633
6634                         QUERY PLAN
6635 -----------------------------------------------------------
6636  Result
6637    ->  Append
6638          ->  Index Scan using p2_pkey on p2
6639                Index Cond: ((id >= 50) AND (id <= 51))
6640                Filter: (ctid = '(1,1)'::tid)
6641          ->  Index Scan using p2_c1_pkey on p2_c1 p2
6642                Index Cond: ((id >= 50) AND (id <= 51))
6643                Filter: (ctid = '(1,1)'::tid)
6644          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6645                Index Cond: ((id >= 50) AND (id <= 51))
6646                Filter: (ctid = '(1,1)'::tid)
6647          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6648                Index Cond: ((id >= 50) AND (id <= 51))
6649                Filter: (ctid = '(1,1)'::tid)
6650 (14 rows)
6651
6652 /*+IndexScan(p2 p2_id2_val)*/
6653 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6654 LOG:  available indexes for IndexScan(p2): p2_id2_val
6655 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id2_val
6656 LOG:  available indexes for IndexScan(p2_c2): p2_c2_id2_val
6657 LOG:  available indexes for IndexScan(p2_c3):
6658 LOG:  available indexes for IndexScan(p2_c4):
6659 LOG:  available indexes for IndexScan(p2_c1_c1):
6660 LOG:  available indexes for IndexScan(p2_c1_c2):
6661 LOG:  available indexes for IndexScan(p2_c3_c1):
6662 LOG:  available indexes for IndexScan(p2_c3_c2):
6663 LOG:  pg_hint_plan:
6664 used hint:
6665 IndexScan(p2 p2_id2_val)
6666 not used hint:
6667 duplication hint:
6668 error hint:
6669
6670                        QUERY PLAN
6671 --------------------------------------------------------
6672  Result
6673    ->  Append
6674          ->  Index Scan using p2_id2_val on p2
6675                Index Cond: ((id >= 50) AND (id <= 51))
6676                Filter: (ctid = '(1,1)'::tid)
6677          ->  Index Scan using p2_c1_id2_val on p2_c1 p2
6678                Index Cond: ((id >= 50) AND (id <= 51))
6679                Filter: (ctid = '(1,1)'::tid)
6680          ->  Tid Scan on p2_c1_c1 p2
6681                TID Cond: (ctid = '(1,1)'::tid)
6682                Filter: ((id >= 50) AND (id <= 51))
6683          ->  Tid Scan on p2_c1_c2 p2
6684                TID Cond: (ctid = '(1,1)'::tid)
6685                Filter: ((id >= 50) AND (id <= 51))
6686 (14 rows)
6687
6688 /*+IndexScan(p2 p2_val2_id)*/
6689 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6690 LOG:  available indexes for IndexScan(p2): p2_val2_id
6691 LOG:  available indexes for IndexScan(p2_c1):
6692 LOG:  available indexes for IndexScan(p2_c2):
6693 LOG:  available indexes for IndexScan(p2_c3):
6694 LOG:  available indexes for IndexScan(p2_c4):
6695 LOG:  available indexes for IndexScan(p2_c1_c1):
6696 LOG:  available indexes for IndexScan(p2_c1_c2):
6697 LOG:  available indexes for IndexScan(p2_c3_c1):
6698 LOG:  available indexes for IndexScan(p2_c3_c2):
6699 LOG:  pg_hint_plan:
6700 used hint:
6701 IndexScan(p2 p2_val2_id)
6702 not used hint:
6703 duplication hint:
6704 error hint:
6705
6706                                  QUERY PLAN
6707 -----------------------------------------------------------------------------
6708  Result
6709    ->  Append
6710          ->  Index Scan using p2_val2_id on p2
6711                Index Cond: ((id >= 50) AND (id <= 51))
6712                Filter: (ctid = '(1,1)'::tid)
6713          ->  Seq Scan on p2_c1 p2
6714                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6715          ->  Tid Scan on p2_c1_c1 p2
6716                TID Cond: (ctid = '(1,1)'::tid)
6717                Filter: ((id >= 50) AND (id <= 51))
6718          ->  Tid Scan on p2_c1_c2 p2
6719                TID Cond: (ctid = '(1,1)'::tid)
6720                Filter: ((id >= 50) AND (id <= 51))
6721 (13 rows)
6722
6723 /*+IndexScan(p2 p2_pkey)*/
6724 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6725 LOG:  available indexes for IndexScan(p2): p2_pkey
6726 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6727 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6728 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6729 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6730 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6731 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6732 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6733 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6734 LOG:  pg_hint_plan:
6735 used hint:
6736 IndexScan(p2 p2_pkey)
6737 not used hint:
6738 duplication hint:
6739 error hint:
6740
6741                         QUERY PLAN
6742 -----------------------------------------------------------
6743  Result
6744    ->  Append
6745          ->  Index Scan using p2_pkey on p2
6746                Index Cond: ((id >= 50) AND (id <= 51))
6747                Filter: (ctid = '(1,1)'::tid)
6748          ->  Index Scan using p2_c1_pkey on p2_c1 p2
6749                Index Cond: ((id >= 50) AND (id <= 51))
6750                Filter: (ctid = '(1,1)'::tid)
6751          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6752                Index Cond: ((id >= 50) AND (id <= 51))
6753                Filter: (ctid = '(1,1)'::tid)
6754          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6755                Index Cond: ((id >= 50) AND (id <= 51))
6756                Filter: (ctid = '(1,1)'::tid)
6757 (14 rows)
6758
6759 /*+IndexScan(p2 p2_c1_id_val_idx)*/
6760 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6761 LOG:  available indexes for IndexScan(p2):
6762 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6763 LOG:  available indexes for IndexScan(p2_c2):
6764 LOG:  available indexes for IndexScan(p2_c3):
6765 LOG:  available indexes for IndexScan(p2_c4):
6766 LOG:  available indexes for IndexScan(p2_c1_c1):
6767 LOG:  available indexes for IndexScan(p2_c1_c2):
6768 LOG:  available indexes for IndexScan(p2_c3_c1):
6769 LOG:  available indexes for IndexScan(p2_c3_c2):
6770 LOG:  pg_hint_plan:
6771 used hint:
6772 IndexScan(p2 p2_c1_id_val_idx)
6773 not used hint:
6774 duplication hint:
6775 error hint:
6776
6777                                  QUERY PLAN
6778 -----------------------------------------------------------------------------
6779  Result
6780    ->  Append
6781          ->  Seq Scan on p2
6782                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6783          ->  Index Scan using p2_c1_id_val_idx on p2_c1 p2
6784                Index Cond: ((id >= 50) AND (id <= 51))
6785                Filter: (ctid = '(1,1)'::tid)
6786          ->  Tid Scan on p2_c1_c1 p2
6787                TID Cond: (ctid = '(1,1)'::tid)
6788                Filter: ((id >= 50) AND (id <= 51))
6789          ->  Tid Scan on p2_c1_c2 p2
6790                TID Cond: (ctid = '(1,1)'::tid)
6791                Filter: ((id >= 50) AND (id <= 51))
6792 (13 rows)
6793
6794 /*+IndexScan(p2 no_exist)*/
6795 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6796 LOG:  available indexes for IndexScan(p2):
6797 LOG:  available indexes for IndexScan(p2_c1):
6798 LOG:  available indexes for IndexScan(p2_c2):
6799 LOG:  available indexes for IndexScan(p2_c3):
6800 LOG:  available indexes for IndexScan(p2_c4):
6801 LOG:  available indexes for IndexScan(p2_c1_c1):
6802 LOG:  available indexes for IndexScan(p2_c1_c2):
6803 LOG:  available indexes for IndexScan(p2_c3_c1):
6804 LOG:  available indexes for IndexScan(p2_c3_c2):
6805 LOG:  pg_hint_plan:
6806 used hint:
6807 IndexScan(p2 no_exist)
6808 not used hint:
6809 duplication hint:
6810 error hint:
6811
6812                                  QUERY PLAN
6813 -----------------------------------------------------------------------------
6814  Result
6815    ->  Append
6816          ->  Seq Scan on p2
6817                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6818          ->  Seq Scan on p2_c1 p2
6819                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6820          ->  Tid Scan on p2_c1_c1 p2
6821                TID Cond: (ctid = '(1,1)'::tid)
6822                Filter: ((id >= 50) AND (id <= 51))
6823          ->  Tid Scan on p2_c1_c2 p2
6824                TID Cond: (ctid = '(1,1)'::tid)
6825                Filter: ((id >= 50) AND (id <= 51))
6826 (12 rows)
6827
6828 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx)*/
6829 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6830 LOG:  available indexes for IndexScan(p2): p2_pkey
6831 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6832 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6833 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6834 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6835 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6836 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6837 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6838 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6839 LOG:  pg_hint_plan:
6840 used hint:
6841 IndexScan(p2 p2_pkey p2_c1_id_val_idx)
6842 not used hint:
6843 duplication hint:
6844 error hint:
6845
6846                         QUERY PLAN
6847 -----------------------------------------------------------
6848  Result
6849    ->  Append
6850          ->  Index Scan using p2_pkey on p2
6851                Index Cond: ((id >= 50) AND (id <= 51))
6852                Filter: (ctid = '(1,1)'::tid)
6853          ->  Index Scan using p2_c1_id_val_idx on p2_c1 p2
6854                Index Cond: ((id >= 50) AND (id <= 51))
6855                Filter: (ctid = '(1,1)'::tid)
6856          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6857                Index Cond: ((id >= 50) AND (id <= 51))
6858                Filter: (ctid = '(1,1)'::tid)
6859          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6860                Index Cond: ((id >= 50) AND (id <= 51))
6861                Filter: (ctid = '(1,1)'::tid)
6862 (14 rows)
6863
6864 /*+IndexScan(p2 p2_pkey no_exist)*/
6865 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6866 LOG:  available indexes for IndexScan(p2): p2_pkey
6867 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6868 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6869 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6870 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6871 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6872 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6873 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6874 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6875 LOG:  pg_hint_plan:
6876 used hint:
6877 IndexScan(p2 p2_pkey no_exist)
6878 not used hint:
6879 duplication hint:
6880 error hint:
6881
6882                         QUERY PLAN
6883 -----------------------------------------------------------
6884  Result
6885    ->  Append
6886          ->  Index Scan using p2_pkey on p2
6887                Index Cond: ((id >= 50) AND (id <= 51))
6888                Filter: (ctid = '(1,1)'::tid)
6889          ->  Index Scan using p2_c1_pkey on p2_c1 p2
6890                Index Cond: ((id >= 50) AND (id <= 51))
6891                Filter: (ctid = '(1,1)'::tid)
6892          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6893                Index Cond: ((id >= 50) AND (id <= 51))
6894                Filter: (ctid = '(1,1)'::tid)
6895          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6896                Index Cond: ((id >= 50) AND (id <= 51))
6897                Filter: (ctid = '(1,1)'::tid)
6898 (14 rows)
6899
6900 /*+IndexScan(p2 p2_c1_id_val_idx no_exist)*/
6901 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6902 LOG:  available indexes for IndexScan(p2):
6903 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6904 LOG:  available indexes for IndexScan(p2_c2):
6905 LOG:  available indexes for IndexScan(p2_c3):
6906 LOG:  available indexes for IndexScan(p2_c4):
6907 LOG:  available indexes for IndexScan(p2_c1_c1):
6908 LOG:  available indexes for IndexScan(p2_c1_c2):
6909 LOG:  available indexes for IndexScan(p2_c3_c1):
6910 LOG:  available indexes for IndexScan(p2_c3_c2):
6911 LOG:  pg_hint_plan:
6912 used hint:
6913 IndexScan(p2 p2_c1_id_val_idx no_exist)
6914 not used hint:
6915 duplication hint:
6916 error hint:
6917
6918                                  QUERY PLAN
6919 -----------------------------------------------------------------------------
6920  Result
6921    ->  Append
6922          ->  Seq Scan on p2
6923                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6924          ->  Index Scan using p2_c1_id_val_idx on p2_c1 p2
6925                Index Cond: ((id >= 50) AND (id <= 51))
6926                Filter: (ctid = '(1,1)'::tid)
6927          ->  Tid Scan on p2_c1_c1 p2
6928                TID Cond: (ctid = '(1,1)'::tid)
6929                Filter: ((id >= 50) AND (id <= 51))
6930          ->  Tid Scan on p2_c1_c2 p2
6931                TID Cond: (ctid = '(1,1)'::tid)
6932                Filter: ((id >= 50) AND (id <= 51))
6933 (13 rows)
6934
6935 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)*/
6936 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6937 LOG:  available indexes for IndexScan(p2): p2_pkey
6938 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6939 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6940 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6941 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6942 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6943 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6944 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6945 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6946 LOG:  pg_hint_plan:
6947 used hint:
6948 IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)
6949 not used hint:
6950 duplication hint:
6951 error hint:
6952
6953                         QUERY PLAN
6954 -----------------------------------------------------------
6955  Result
6956    ->  Append
6957          ->  Index Scan using p2_pkey on p2
6958                Index Cond: ((id >= 50) AND (id <= 51))
6959                Filter: (ctid = '(1,1)'::tid)
6960          ->  Index Scan using p2_c1_id_val_idx on p2_c1 p2
6961                Index Cond: ((id >= 50) AND (id <= 51))
6962                Filter: (ctid = '(1,1)'::tid)
6963          ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1 p2
6964                Index Cond: ((id >= 50) AND (id <= 51))
6965                Filter: (ctid = '(1,1)'::tid)
6966          ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2 p2
6967                Index Cond: ((id >= 50) AND (id <= 51))
6968                Filter: (ctid = '(1,1)'::tid)
6969 (14 rows)
6970
6971 /*+IndexScan(p2 p2_val_idx)*/
6972 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6973 LOG:  available indexes for IndexScan(p2): p2_val_idx
6974 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx
6975 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx
6976 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx
6977 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx
6978 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx
6979 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx
6980 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx
6981 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx
6982 LOG:  pg_hint_plan:
6983 used hint:
6984 IndexScan(p2 p2_val_idx)
6985 not used hint:
6986 duplication hint:
6987 error hint:
6988
6989                                QUERY PLAN
6990 -------------------------------------------------------------------------
6991  Result
6992    ->  Append
6993          ->  Index Scan using p2_val_idx on p2
6994                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6995                Filter: (ctid = '(1,1)'::tid)
6996          ->  Index Scan using p2_c1_val_idx on p2_c1 p2
6997                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6998                Filter: (ctid = '(1,1)'::tid)
6999          ->  Index Scan using p2_c2_val_idx on p2_c2 p2
7000                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7001                Filter: (ctid = '(1,1)'::tid)
7002          ->  Index Scan using p2_c3_val_idx on p2_c3 p2
7003                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7004                Filter: (ctid = '(1,1)'::tid)
7005          ->  Index Scan using p2_c4_val_idx on p2_c4 p2
7006                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7007                Filter: (ctid = '(1,1)'::tid)
7008          ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1 p2
7009                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7010                Filter: (ctid = '(1,1)'::tid)
7011          ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2 p2
7012                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7013                Filter: (ctid = '(1,1)'::tid)
7014          ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1 p2
7015                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7016                Filter: (ctid = '(1,1)'::tid)
7017          ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2 p2
7018                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7019                Filter: (ctid = '(1,1)'::tid)
7020 (29 rows)
7021
7022 /*+IndexScan(p2 p2_expr)*/
7023 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7024 LOG:  available indexes for IndexScan(p2): p2_expr
7025 LOG:  available indexes for IndexScan(p2_c1): p2_c1_expr_idx
7026 LOG:  available indexes for IndexScan(p2_c2): p2_c2_expr_idx
7027 LOG:  available indexes for IndexScan(p2_c3): p2_c3_expr_idx
7028 LOG:  available indexes for IndexScan(p2_c4): p2_c4_expr_idx
7029 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_expr_idx
7030 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_expr_idx
7031 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_expr_idx
7032 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_expr_idx
7033 LOG:  pg_hint_plan:
7034 used hint:
7035 IndexScan(p2 p2_expr)
7036 not used hint:
7037 duplication hint:
7038 error hint:
7039
7040                                           QUERY PLAN
7041 -----------------------------------------------------------------------------------------------
7042  Result
7043    ->  Append
7044          ->  Seq Scan on p2
7045                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7046          ->  Seq Scan on p2_c1 p2
7047                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7048          ->  Seq Scan on p2_c2 p2
7049                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7050          ->  Seq Scan on p2_c3 p2
7051                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7052          ->  Tid Scan on p2_c4 p2
7053                TID Cond: (ctid = '(1,1)'::tid)
7054                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7055          ->  Tid Scan on p2_c1_c1 p2
7056                TID Cond: (ctid = '(1,1)'::tid)
7057                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7058          ->  Tid Scan on p2_c1_c2 p2
7059                TID Cond: (ctid = '(1,1)'::tid)
7060                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7061          ->  Tid Scan on p2_c3_c1 p2
7062                TID Cond: (ctid = '(1,1)'::tid)
7063                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7064          ->  Tid Scan on p2_c3_c2 p2
7065                TID Cond: (ctid = '(1,1)'::tid)
7066                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7067 (25 rows)
7068
7069 /*+IndexScan(p2 p2_val_idx6)*/
7070 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7071 LOG:  available indexes for IndexScan(p2): p2_val_idx6
7072 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6
7073 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6
7074 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6
7075 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6
7076 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6
7077 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6
7078 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6
7079 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6
7080 LOG:  pg_hint_plan:
7081 used hint:
7082 IndexScan(p2 p2_val_idx6)
7083 not used hint:
7084 duplication hint:
7085 error hint:
7086
7087                                           QUERY PLAN
7088 -----------------------------------------------------------------------------------------------
7089  Result
7090    ->  Append
7091          ->  Seq Scan on p2
7092                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7093          ->  Seq Scan on p2_c1 p2
7094                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7095          ->  Seq Scan on p2_c2 p2
7096                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7097          ->  Seq Scan on p2_c3 p2
7098                Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7099          ->  Tid Scan on p2_c4 p2
7100                TID Cond: (ctid = '(1,1)'::tid)
7101                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7102          ->  Tid Scan on p2_c1_c1 p2
7103                TID Cond: (ctid = '(1,1)'::tid)
7104                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7105          ->  Tid Scan on p2_c1_c2 p2
7106                TID Cond: (ctid = '(1,1)'::tid)
7107                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7108          ->  Tid Scan on p2_c3_c1 p2
7109                TID Cond: (ctid = '(1,1)'::tid)
7110                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7111          ->  Tid Scan on p2_c3_c2 p2
7112                TID Cond: (ctid = '(1,1)'::tid)
7113                Filter: ((val >= '50'::text) AND (val <= '51'::text))
7114 (25 rows)
7115
7116 /*+IndexScan(p2 p2_val_idx p2_val_idx6)*/
7117 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7118 LOG:  available indexes for IndexScan(p2): p2_val_idx6 p2_val_idx
7119 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6 p2_c1_val_idx
7120 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6 p2_c2_val_idx
7121 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6 p2_c3_val_idx
7122 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6 p2_c4_val_idx
7123 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6 p2_c1_c1_val_idx
7124 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6 p2_c1_c2_val_idx
7125 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6 p2_c3_c1_val_idx
7126 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6 p2_c3_c2_val_idx
7127 LOG:  pg_hint_plan:
7128 used hint:
7129 IndexScan(p2 p2_val_idx p2_val_idx6)
7130 not used hint:
7131 duplication hint:
7132 error hint:
7133
7134                                QUERY PLAN
7135 -------------------------------------------------------------------------
7136  Result
7137    ->  Append
7138          ->  Index Scan using p2_val_idx on p2
7139                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7140                Filter: (ctid = '(1,1)'::tid)
7141          ->  Index Scan using p2_c1_val_idx on p2_c1 p2
7142                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7143                Filter: (ctid = '(1,1)'::tid)
7144          ->  Index Scan using p2_c2_val_idx on p2_c2 p2
7145                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7146                Filter: (ctid = '(1,1)'::tid)
7147          ->  Index Scan using p2_c3_val_idx on p2_c3 p2
7148                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7149                Filter: (ctid = '(1,1)'::tid)
7150          ->  Index Scan using p2_c4_val_idx on p2_c4 p2
7151                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7152                Filter: (ctid = '(1,1)'::tid)
7153          ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1 p2
7154                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7155                Filter: (ctid = '(1,1)'::tid)
7156          ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2 p2
7157                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7158                Filter: (ctid = '(1,1)'::tid)
7159          ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1 p2
7160                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7161                Filter: (ctid = '(1,1)'::tid)
7162          ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2 p2
7163                Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7164                Filter: (ctid = '(1,1)'::tid)
7165 (29 rows)
7166
7167 -- regular expression
7168 -- ordinary table
7169 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7170                                          QUERY PLAN
7171 ---------------------------------------------------------------------------------------------
7172  Index Only Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
7173    Index Cond: (id = 1)
7174 (2 rows)
7175
7176 /*+ IndexScanRegexp(t5 t5_[^i].*)*/
7177 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7178 LOG:  available indexes for IndexScanRegexp(t5): t5_val t5_pkey
7179 LOG:  pg_hint_plan:
7180 used hint:
7181 IndexScanRegexp(t5 t5_[^i].*)
7182 not used hint:
7183 duplication hint:
7184 error hint:
7185
7186            QUERY PLAN
7187 --------------------------------
7188  Index Scan using t5_pkey on t5
7189    Index Cond: (id = 1)
7190 (2 rows)
7191
7192 /*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
7193 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7194 LOG:  available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
7195 LOG:  pg_hint_plan:
7196 used hint:
7197 IndexScanRegexp(t5 t5_id[0-9].*)
7198 not used hint:
7199 duplication hint:
7200 error hint:
7201
7202           QUERY PLAN
7203 -------------------------------
7204  Index Scan using t5_id3 on t5
7205    Index Cond: (id = 1)
7206 (2 rows)
7207
7208 /*+ IndexScanRegexp(t5 t5[^_].*)*/
7209 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7210 LOG:  available indexes for IndexScanRegexp(t5):
7211 LOG:  pg_hint_plan:
7212 used hint:
7213 IndexScanRegexp(t5 t5[^_].*)
7214 not used hint:
7215 duplication hint:
7216 error hint:
7217
7218      QUERY PLAN
7219 --------------------
7220  Seq Scan on t5
7221    Filter: (id = 1)
7222 (2 rows)
7223
7224 /*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7225 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7226 LOG:  available indexes for IndexScanRegexp(t5):
7227 LOG:  pg_hint_plan:
7228 used hint:
7229 IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7230 not used hint:
7231 duplication hint:
7232 error hint:
7233
7234      QUERY PLAN
7235 --------------------
7236  Seq Scan on t5
7237    Filter: (id = 1)
7238 (2 rows)
7239
7240 /*+ IndexScan(t5 t5_id[0-9].*)*/
7241 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7242 LOG:  available indexes for IndexScan(t5):
7243 LOG:  pg_hint_plan:
7244 used hint:
7245 IndexScan(t5 t5_id[0-9].*)
7246 not used hint:
7247 duplication hint:
7248 error hint:
7249
7250      QUERY PLAN
7251 --------------------
7252  Seq Scan on t5
7253    Filter: (id = 1)
7254 (2 rows)
7255
7256 /*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
7257 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7258 LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_val t5_pkey
7259 LOG:  pg_hint_plan:
7260 used hint:
7261 IndexOnlyScanRegexp(t5 t5_[^i].*)
7262 not used hint:
7263 duplication hint:
7264 error hint:
7265
7266              QUERY PLAN
7267 -------------------------------------
7268  Index Only Scan using t5_pkey on t5
7269    Index Cond: (id = 1)
7270 (2 rows)
7271
7272 /*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
7273 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7274 LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_id3 t5_id2 t5_id1
7275 LOG:  pg_hint_plan:
7276 used hint:
7277 IndexOnlyScanRegexp(t5 t5_id[0-9].*)
7278 not used hint:
7279 duplication hint:
7280 error hint:
7281
7282              QUERY PLAN
7283 ------------------------------------
7284  Index Only Scan using t5_id3 on t5
7285    Index Cond: (id = 1)
7286 (2 rows)
7287
7288 /*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
7289 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7290 LOG:  available indexes for IndexOnlyScanRegexp(t5):
7291 LOG:  pg_hint_plan:
7292 used hint:
7293 IndexOnlyScanRegexp(t5 t5[^_].*)
7294 not used hint:
7295 duplication hint:
7296 error hint:
7297
7298      QUERY PLAN
7299 --------------------
7300  Seq Scan on t5
7301    Filter: (id = 1)
7302 (2 rows)
7303
7304 /*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7305 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7306 LOG:  available indexes for IndexOnlyScanRegexp(t5):
7307 LOG:  pg_hint_plan:
7308 used hint:
7309 IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7310 not used hint:
7311 duplication hint:
7312 error hint:
7313
7314      QUERY PLAN
7315 --------------------
7316  Seq Scan on t5
7317    Filter: (id = 1)
7318 (2 rows)
7319
7320 /*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
7321 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7322 LOG:  available indexes for IndexOnlyScan(t5):
7323 LOG:  pg_hint_plan:
7324 used hint:
7325 IndexOnlyScan(t5 t5_id[0-9].*)
7326 not used hint:
7327 duplication hint:
7328 error hint:
7329
7330      QUERY PLAN
7331 --------------------
7332  Seq Scan on t5
7333    Filter: (id = 1)
7334 (2 rows)
7335
7336 /*+ BitmapScanRegexp(t5 t5_[^i].*)*/
7337 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7338 LOG:  available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
7339 LOG:  pg_hint_plan:
7340 used hint:
7341 BitmapScanRegexp(t5 t5_[^i].*)
7342 not used hint:
7343 duplication hint:
7344 error hint:
7345
7346              QUERY PLAN
7347 ------------------------------------
7348  Bitmap Heap Scan on t5
7349    Recheck Cond: (id = 1)
7350    ->  Bitmap Index Scan on t5_pkey
7351          Index Cond: (id = 1)
7352 (4 rows)
7353
7354 /*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
7355 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7356 LOG:  available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
7357 LOG:  pg_hint_plan:
7358 used hint:
7359 BitmapScanRegexp(t5 t5_id[0-9].*)
7360 not used hint:
7361 duplication hint:
7362 error hint:
7363
7364             QUERY PLAN
7365 -----------------------------------
7366  Bitmap Heap Scan on t5
7367    Recheck Cond: (id = 1)
7368    ->  Bitmap Index Scan on t5_id3
7369          Index Cond: (id = 1)
7370 (4 rows)
7371
7372 /*+ BitmapScanRegexp(t5 t5[^_].*)*/
7373 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7374 LOG:  available indexes for BitmapScanRegexp(t5):
7375 LOG:  pg_hint_plan:
7376 used hint:
7377 BitmapScanRegexp(t5 t5[^_].*)
7378 not used hint:
7379 duplication hint:
7380 error hint:
7381
7382      QUERY PLAN
7383 --------------------
7384  Seq Scan on t5
7385    Filter: (id = 1)
7386 (2 rows)
7387
7388 /*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7389 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7390 LOG:  available indexes for BitmapScanRegexp(t5):
7391 LOG:  pg_hint_plan:
7392 used hint:
7393 BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7394 not used hint:
7395 duplication hint:
7396 error hint:
7397
7398      QUERY PLAN
7399 --------------------
7400  Seq Scan on t5
7401    Filter: (id = 1)
7402 (2 rows)
7403
7404 /*+ BitmapScan(t5 t5_id[0-9].*)*/
7405 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7406 LOG:  available indexes for BitmapScan(t5):
7407 LOG:  pg_hint_plan:
7408 used hint:
7409 BitmapScan(t5 t5_id[0-9].*)
7410 not used hint:
7411 duplication hint:
7412 error hint:
7413
7414      QUERY PLAN
7415 --------------------
7416  Seq Scan on t5
7417    Filter: (id = 1)
7418 (2 rows)
7419
7420 -- Inheritance
7421 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7422              QUERY PLAN
7423 -------------------------------------
7424  Result
7425    ->  Append
7426          ->  Seq Scan on p1
7427                Filter: (val = 1)
7428          ->  Seq Scan on p1_c1 p1
7429                Filter: (val = 1)
7430          ->  Seq Scan on p1_c2 p1
7431                Filter: (val = 1)
7432          ->  Seq Scan on p1_c3 p1
7433                Filter: (val = 1)
7434          ->  Seq Scan on p1_c4 p1
7435                Filter: (val = 1)
7436          ->  Seq Scan on p1_c1_c1 p1
7437                Filter: (val = 1)
7438          ->  Seq Scan on p1_c1_c2 p1
7439                Filter: (val = 1)
7440          ->  Seq Scan on p1_c3_c1 p1
7441                Filter: (val = 1)
7442          ->  Seq Scan on p1_c3_c2 p1
7443                Filter: (val = 1)
7444 (20 rows)
7445
7446 /*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
7447 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7448 LOG:  available indexes for IndexScanRegexp(p1): p1_pkey
7449 LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
7450 LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
7451 LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
7452 LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
7453 LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7454 LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7455 LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7456 LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7457 LOG:  pg_hint_plan:
7458 used hint:
7459 IndexScanRegexp(p1 p1_.*[^0-9]$)
7460 not used hint:
7461 duplication hint:
7462 error hint:
7463
7464              QUERY PLAN
7465 -------------------------------------
7466  Result
7467    ->  Append
7468          ->  Seq Scan on p1
7469                Filter: (val = 1)
7470          ->  Seq Scan on p1_c1 p1
7471                Filter: (val = 1)
7472          ->  Seq Scan on p1_c2 p1
7473                Filter: (val = 1)
7474          ->  Seq Scan on p1_c3 p1
7475                Filter: (val = 1)
7476          ->  Seq Scan on p1_c4 p1
7477                Filter: (val = 1)
7478          ->  Seq Scan on p1_c1_c1 p1
7479                Filter: (val = 1)
7480          ->  Seq Scan on p1_c1_c2 p1
7481                Filter: (val = 1)
7482          ->  Seq Scan on p1_c3_c1 p1
7483                Filter: (val = 1)
7484          ->  Seq Scan on p1_c3_c2 p1
7485                Filter: (val = 1)
7486 (20 rows)
7487
7488 /*+ IndexScanRegexp(p1 p1_.*val2.*)*/
7489 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7490 LOG:  available indexes for IndexScanRegexp(p1): p1_val2
7491 LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
7492 LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
7493 LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
7494 LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
7495 LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
7496 LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
7497 LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
7498 LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
7499 LOG:  pg_hint_plan:
7500 used hint:
7501 IndexScanRegexp(p1 p1_.*val2.*)
7502 not used hint:
7503 duplication hint:
7504 error hint:
7505
7506                         QUERY PLAN
7507 -----------------------------------------------------------
7508  Result
7509    ->  Append
7510          ->  Index Scan using p1_val2 on p1
7511                Index Cond: (val = 1)
7512          ->  Index Scan using p1_c1_val2 on p1_c1 p1
7513                Index Cond: (val = 1)
7514          ->  Index Scan using p1_c2_val2 on p1_c2 p1
7515                Index Cond: (val = 1)
7516          ->  Index Scan using p1_c3_val2 on p1_c3 p1
7517                Index Cond: (val = 1)
7518          ->  Index Scan using p1_c4_val2 on p1_c4 p1
7519                Index Cond: (val = 1)
7520          ->  Index Scan using p1_c1_c1_val2 on p1_c1_c1 p1
7521                Index Cond: (val = 1)
7522          ->  Index Scan using p1_c1_c2_val2 on p1_c1_c2 p1
7523                Index Cond: (val = 1)
7524          ->  Index Scan using p1_c3_c1_val2 on p1_c3_c1 p1
7525                Index Cond: (val = 1)
7526          ->  Index Scan using p1_c3_c2_val2 on p1_c3_c2 p1
7527                Index Cond: (val = 1)
7528 (20 rows)
7529
7530 /*+ IndexScanRegexp(p1 p1[^_].*)*/
7531 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7532 LOG:  available indexes for IndexScanRegexp(p1):
7533 LOG:  available indexes for IndexScanRegexp(p1_c1):
7534 LOG:  available indexes for IndexScanRegexp(p1_c2):
7535 LOG:  available indexes for IndexScanRegexp(p1_c3):
7536 LOG:  available indexes for IndexScanRegexp(p1_c4):
7537 LOG:  available indexes for IndexScanRegexp(p1_c1_c1):
7538 LOG:  available indexes for IndexScanRegexp(p1_c1_c2):
7539 LOG:  available indexes for IndexScanRegexp(p1_c3_c1):
7540 LOG:  available indexes for IndexScanRegexp(p1_c3_c2):
7541 LOG:  pg_hint_plan:
7542 used hint:
7543 IndexScanRegexp(p1 p1[^_].*)
7544 not used hint:
7545 duplication hint:
7546 error hint:
7547
7548              QUERY PLAN
7549 -------------------------------------
7550  Result
7551    ->  Append
7552          ->  Seq Scan on p1
7553                Filter: (val = 1)
7554          ->  Seq Scan on p1_c1 p1
7555                Filter: (val = 1)
7556          ->  Seq Scan on p1_c2 p1
7557                Filter: (val = 1)
7558          ->  Seq Scan on p1_c3 p1
7559                Filter: (val = 1)
7560          ->  Seq Scan on p1_c4 p1
7561                Filter: (val = 1)
7562          ->  Seq Scan on p1_c1_c1 p1
7563                Filter: (val = 1)
7564          ->  Seq Scan on p1_c1_c2 p1
7565                Filter: (val = 1)
7566          ->  Seq Scan on p1_c3_c1 p1
7567                Filter: (val = 1)
7568          ->  Seq Scan on p1_c3_c2 p1
7569                Filter: (val = 1)
7570 (20 rows)
7571
7572 /*+ IndexScan(p1 p1_.*val2.*)*/
7573 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7574 LOG:  available indexes for IndexScan(p1):
7575 LOG:  available indexes for IndexScan(p1_c1):
7576 LOG:  available indexes for IndexScan(p1_c2):
7577 LOG:  available indexes for IndexScan(p1_c3):
7578 LOG:  available indexes for IndexScan(p1_c4):
7579 LOG:  available indexes for IndexScan(p1_c1_c1):
7580 LOG:  available indexes for IndexScan(p1_c1_c2):
7581 LOG:  available indexes for IndexScan(p1_c3_c1):
7582 LOG:  available indexes for IndexScan(p1_c3_c2):
7583 LOG:  pg_hint_plan:
7584 used hint:
7585 IndexScan(p1 p1_.*val2.*)
7586 not used hint:
7587 duplication hint:
7588 error hint:
7589
7590              QUERY PLAN
7591 -------------------------------------
7592  Result
7593    ->  Append
7594          ->  Seq Scan on p1
7595                Filter: (val = 1)
7596          ->  Seq Scan on p1_c1 p1
7597                Filter: (val = 1)
7598          ->  Seq Scan on p1_c2 p1
7599                Filter: (val = 1)
7600          ->  Seq Scan on p1_c3 p1
7601                Filter: (val = 1)
7602          ->  Seq Scan on p1_c4 p1
7603                Filter: (val = 1)
7604          ->  Seq Scan on p1_c1_c1 p1
7605                Filter: (val = 1)
7606          ->  Seq Scan on p1_c1_c2 p1
7607                Filter: (val = 1)
7608          ->  Seq Scan on p1_c3_c1 p1
7609                Filter: (val = 1)
7610          ->  Seq Scan on p1_c3_c2 p1
7611                Filter: (val = 1)
7612 (20 rows)
7613
7614 /*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
7615 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7616 LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_pkey
7617 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_pkey
7618 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_pkey
7619 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_pkey
7620 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_pkey
7621 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7622 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7623 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7624 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7625 LOG:  pg_hint_plan:
7626 used hint:
7627 IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)
7628 not used hint:
7629 duplication hint:
7630 error hint:
7631
7632              QUERY PLAN
7633 -------------------------------------
7634  Result
7635    ->  Append
7636          ->  Seq Scan on p1
7637                Filter: (val = 1)
7638          ->  Seq Scan on p1_c1 p1
7639                Filter: (val = 1)
7640          ->  Seq Scan on p1_c2 p1
7641                Filter: (val = 1)
7642          ->  Seq Scan on p1_c3 p1
7643                Filter: (val = 1)
7644          ->  Seq Scan on p1_c4 p1
7645                Filter: (val = 1)
7646          ->  Seq Scan on p1_c1_c1 p1
7647                Filter: (val = 1)
7648          ->  Seq Scan on p1_c1_c2 p1
7649                Filter: (val = 1)
7650          ->  Seq Scan on p1_c3_c1 p1
7651                Filter: (val = 1)
7652          ->  Seq Scan on p1_c3_c2 p1
7653                Filter: (val = 1)
7654 (20 rows)
7655
7656 /*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
7657 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7658 LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_val2
7659 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_val2
7660 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_val2
7661 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_val2
7662 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_val2
7663 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_val2
7664 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_val2
7665 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_val2
7666 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_val2
7667 LOG:  pg_hint_plan:
7668 used hint:
7669 IndexOnlyScanRegexp(p1 p1_.*val2.*)
7670 not used hint:
7671 duplication hint:
7672 error hint:
7673
7674                            QUERY PLAN
7675 ----------------------------------------------------------------
7676  Result
7677    ->  Append
7678          ->  Index Only Scan using p1_val2 on p1
7679                Index Cond: (val = 1)
7680          ->  Index Only Scan using p1_c1_val2 on p1_c1 p1
7681                Index Cond: (val = 1)
7682          ->  Index Only Scan using p1_c2_val2 on p1_c2 p1
7683                Index Cond: (val = 1)
7684          ->  Index Only Scan using p1_c3_val2 on p1_c3 p1
7685                Index Cond: (val = 1)
7686          ->  Index Only Scan using p1_c4_val2 on p1_c4 p1
7687                Index Cond: (val = 1)
7688          ->  Index Only Scan using p1_c1_c1_val2 on p1_c1_c1 p1
7689                Index Cond: (val = 1)
7690          ->  Index Only Scan using p1_c1_c2_val2 on p1_c1_c2 p1
7691                Index Cond: (val = 1)
7692          ->  Index Only Scan using p1_c3_c1_val2 on p1_c3_c1 p1
7693                Index Cond: (val = 1)
7694          ->  Index Only Scan using p1_c3_c2_val2 on p1_c3_c2 p1
7695                Index Cond: (val = 1)
7696 (20 rows)
7697
7698 /*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
7699 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7700 LOG:  available indexes for IndexOnlyScanRegexp(p1):
7701 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1):
7702 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2):
7703 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3):
7704 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4):
7705 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1):
7706 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2):
7707 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1):
7708 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2):
7709 LOG:  pg_hint_plan:
7710 used hint:
7711 IndexOnlyScanRegexp(p1 p1[^_].*)
7712 not used hint:
7713 duplication hint:
7714 error hint:
7715
7716              QUERY PLAN
7717 -------------------------------------
7718  Result
7719    ->  Append
7720          ->  Seq Scan on p1
7721                Filter: (val = 1)
7722          ->  Seq Scan on p1_c1 p1
7723                Filter: (val = 1)
7724          ->  Seq Scan on p1_c2 p1
7725                Filter: (val = 1)
7726          ->  Seq Scan on p1_c3 p1
7727                Filter: (val = 1)
7728          ->  Seq Scan on p1_c4 p1
7729                Filter: (val = 1)
7730          ->  Seq Scan on p1_c1_c1 p1
7731                Filter: (val = 1)
7732          ->  Seq Scan on p1_c1_c2 p1
7733                Filter: (val = 1)
7734          ->  Seq Scan on p1_c3_c1 p1
7735                Filter: (val = 1)
7736          ->  Seq Scan on p1_c3_c2 p1
7737                Filter: (val = 1)
7738 (20 rows)
7739
7740 /*+ IndexOnlyScan(p1 p1_.*val2.*)*/
7741 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7742 LOG:  available indexes for IndexOnlyScan(p1):
7743 LOG:  available indexes for IndexOnlyScan(p1_c1):
7744 LOG:  available indexes for IndexOnlyScan(p1_c2):
7745 LOG:  available indexes for IndexOnlyScan(p1_c3):
7746 LOG:  available indexes for IndexOnlyScan(p1_c4):
7747 LOG:  available indexes for IndexOnlyScan(p1_c1_c1):
7748 LOG:  available indexes for IndexOnlyScan(p1_c1_c2):
7749 LOG:  available indexes for IndexOnlyScan(p1_c3_c1):
7750 LOG:  available indexes for IndexOnlyScan(p1_c3_c2):
7751 LOG:  pg_hint_plan:
7752 used hint:
7753 IndexOnlyScan(p1 p1_.*val2.*)
7754 not used hint:
7755 duplication hint:
7756 error hint:
7757
7758              QUERY PLAN
7759 -------------------------------------
7760  Result
7761    ->  Append
7762          ->  Seq Scan on p1
7763                Filter: (val = 1)
7764          ->  Seq Scan on p1_c1 p1
7765                Filter: (val = 1)
7766          ->  Seq Scan on p1_c2 p1
7767                Filter: (val = 1)
7768          ->  Seq Scan on p1_c3 p1
7769                Filter: (val = 1)
7770          ->  Seq Scan on p1_c4 p1
7771                Filter: (val = 1)
7772          ->  Seq Scan on p1_c1_c1 p1
7773                Filter: (val = 1)
7774          ->  Seq Scan on p1_c1_c2 p1
7775                Filter: (val = 1)
7776          ->  Seq Scan on p1_c3_c1 p1
7777                Filter: (val = 1)
7778          ->  Seq Scan on p1_c3_c2 p1
7779                Filter: (val = 1)
7780 (20 rows)
7781
7782 /*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
7783 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7784 LOG:  available indexes for BitmapScanRegexp(p1): p1_pkey
7785 LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
7786 LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
7787 LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
7788 LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
7789 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7790 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7791 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7792 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7793 LOG:  pg_hint_plan:
7794 used hint:
7795 BitmapScanRegexp(p1 p1_.*[^0-9]$)
7796 not used hint:
7797 duplication hint:
7798 error hint:
7799
7800              QUERY PLAN
7801 -------------------------------------
7802  Result
7803    ->  Append
7804          ->  Seq Scan on p1
7805                Filter: (val = 1)
7806          ->  Seq Scan on p1_c1 p1
7807                Filter: (val = 1)
7808          ->  Seq Scan on p1_c2 p1
7809                Filter: (val = 1)
7810          ->  Seq Scan on p1_c3 p1
7811                Filter: (val = 1)
7812          ->  Seq Scan on p1_c4 p1
7813                Filter: (val = 1)
7814          ->  Seq Scan on p1_c1_c1 p1
7815                Filter: (val = 1)
7816          ->  Seq Scan on p1_c1_c2 p1
7817                Filter: (val = 1)
7818          ->  Seq Scan on p1_c3_c1 p1
7819                Filter: (val = 1)
7820          ->  Seq Scan on p1_c3_c2 p1
7821                Filter: (val = 1)
7822 (20 rows)
7823
7824 /*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
7825 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7826 LOG:  available indexes for BitmapScanRegexp(p1): p1_val2
7827 LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
7828 LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
7829 LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
7830 LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
7831 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
7832 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
7833 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
7834 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
7835 LOG:  pg_hint_plan:
7836 used hint:
7837 BitmapScanRegexp(p1 p1_.*val2.*)
7838 not used hint:
7839 duplication hint:
7840 error hint:
7841
7842                       QUERY PLAN
7843 ------------------------------------------------------
7844  Result
7845    ->  Append
7846          ->  Bitmap Heap Scan on p1
7847                Recheck Cond: (val = 1)
7848                ->  Bitmap Index Scan on p1_val2
7849                      Index Cond: (val = 1)
7850          ->  Bitmap Heap Scan on p1_c1 p1
7851                Recheck Cond: (val = 1)
7852                ->  Bitmap Index Scan on p1_c1_val2
7853                      Index Cond: (val = 1)
7854          ->  Bitmap Heap Scan on p1_c2 p1
7855                Recheck Cond: (val = 1)
7856                ->  Bitmap Index Scan on p1_c2_val2
7857                      Index Cond: (val = 1)
7858          ->  Bitmap Heap Scan on p1_c3 p1
7859                Recheck Cond: (val = 1)
7860                ->  Bitmap Index Scan on p1_c3_val2
7861                      Index Cond: (val = 1)
7862          ->  Bitmap Heap Scan on p1_c4 p1
7863                Recheck Cond: (val = 1)
7864                ->  Bitmap Index Scan on p1_c4_val2
7865                      Index Cond: (val = 1)
7866          ->  Bitmap Heap Scan on p1_c1_c1 p1
7867                Recheck Cond: (val = 1)
7868                ->  Bitmap Index Scan on p1_c1_c1_val2
7869                      Index Cond: (val = 1)
7870          ->  Bitmap Heap Scan on p1_c1_c2 p1
7871                Recheck Cond: (val = 1)
7872                ->  Bitmap Index Scan on p1_c1_c2_val2
7873                      Index Cond: (val = 1)
7874          ->  Bitmap Heap Scan on p1_c3_c1 p1
7875                Recheck Cond: (val = 1)
7876                ->  Bitmap Index Scan on p1_c3_c1_val2
7877                      Index Cond: (val = 1)
7878          ->  Bitmap Heap Scan on p1_c3_c2 p1
7879                Recheck Cond: (val = 1)
7880                ->  Bitmap Index Scan on p1_c3_c2_val2
7881                      Index Cond: (val = 1)
7882 (38 rows)
7883
7884 /*+ BitmapScanRegexp(p1 p1[^_].*)*/
7885 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7886 LOG:  available indexes for BitmapScanRegexp(p1):
7887 LOG:  available indexes for BitmapScanRegexp(p1_c1):
7888 LOG:  available indexes for BitmapScanRegexp(p1_c2):
7889 LOG:  available indexes for BitmapScanRegexp(p1_c3):
7890 LOG:  available indexes for BitmapScanRegexp(p1_c4):
7891 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1):
7892 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2):
7893 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1):
7894 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2):
7895 LOG:  pg_hint_plan:
7896 used hint:
7897 BitmapScanRegexp(p1 p1[^_].*)
7898 not used hint:
7899 duplication hint:
7900 error hint:
7901
7902              QUERY PLAN
7903 -------------------------------------
7904  Result
7905    ->  Append
7906          ->  Seq Scan on p1
7907                Filter: (val = 1)
7908          ->  Seq Scan on p1_c1 p1
7909                Filter: (val = 1)
7910          ->  Seq Scan on p1_c2 p1
7911                Filter: (val = 1)
7912          ->  Seq Scan on p1_c3 p1
7913                Filter: (val = 1)
7914          ->  Seq Scan on p1_c4 p1
7915                Filter: (val = 1)
7916          ->  Seq Scan on p1_c1_c1 p1
7917                Filter: (val = 1)
7918          ->  Seq Scan on p1_c1_c2 p1
7919                Filter: (val = 1)
7920          ->  Seq Scan on p1_c3_c1 p1
7921                Filter: (val = 1)
7922          ->  Seq Scan on p1_c3_c2 p1
7923                Filter: (val = 1)
7924 (20 rows)
7925
7926 /*+ BitmapScan(p1 p1_.*val2.*)*/
7927 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7928 LOG:  available indexes for BitmapScan(p1):
7929 LOG:  available indexes for BitmapScan(p1_c1):
7930 LOG:  available indexes for BitmapScan(p1_c2):
7931 LOG:  available indexes for BitmapScan(p1_c3):
7932 LOG:  available indexes for BitmapScan(p1_c4):
7933 LOG:  available indexes for BitmapScan(p1_c1_c1):
7934 LOG:  available indexes for BitmapScan(p1_c1_c2):
7935 LOG:  available indexes for BitmapScan(p1_c3_c1):
7936 LOG:  available indexes for BitmapScan(p1_c3_c2):
7937 LOG:  pg_hint_plan:
7938 used hint:
7939 BitmapScan(p1 p1_.*val2.*)
7940 not used hint:
7941 duplication hint:
7942 error hint:
7943
7944              QUERY PLAN
7945 -------------------------------------
7946  Result
7947    ->  Append
7948          ->  Seq Scan on p1
7949                Filter: (val = 1)
7950          ->  Seq Scan on p1_c1 p1
7951                Filter: (val = 1)
7952          ->  Seq Scan on p1_c2 p1
7953                Filter: (val = 1)
7954          ->  Seq Scan on p1_c3 p1
7955                Filter: (val = 1)
7956          ->  Seq Scan on p1_c4 p1
7957                Filter: (val = 1)
7958          ->  Seq Scan on p1_c1_c1 p1
7959                Filter: (val = 1)
7960          ->  Seq Scan on p1_c1_c2 p1
7961                Filter: (val = 1)
7962          ->  Seq Scan on p1_c3_c1 p1
7963                Filter: (val = 1)
7964          ->  Seq Scan on p1_c3_c2 p1
7965                Filter: (val = 1)
7966 (20 rows)
7967
7968 -- search from hint table
7969 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;', '', 'SeqScan(t1)');
7970 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?;', '', 'IndexScan(t1)');
7971 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;', '', 'BitmapScan(t1)');
7972 SELECT * FROM hint_plan.hints ORDER BY id;
7973  id |                    norm_query_string                     | application_name |     hints
7974 ----+----------------------------------------------------------+------------------+----------------
7975   1 | EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;  |                  | SeqScan(t1)
7976   2 | EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?; |                  | IndexScan(t1)
7977   3 | EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;                |                  | BitmapScan(t1)
7978 (3 rows)
7979
7980 SET pg_hint_plan.enable_hint_table = on;
7981 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7982 LOG:  pg_hint_plan:
7983 used hint:
7984 SeqScan(t1)
7985 not used hint:
7986 duplication hint:
7987 error hint:
7988
7989      QUERY PLAN
7990 --------------------
7991  Seq Scan on t1
7992    Filter: (id = 1)
7993 (2 rows)
7994
7995 SET pg_hint_plan.enable_hint_table = off;
7996 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7997            QUERY PLAN
7998 --------------------------------
7999  Index Scan using t1_pkey on t1
8000    Index Cond: (id = 1)
8001 (2 rows)
8002
8003 TRUNCATE hint_plan.hints;
8004 VACUUM ANALYZE hint_plan.hints;
8005 -- plpgsql test
8006 EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = 1;
8007              QUERY PLAN
8008 -------------------------------------
8009  Index Only Scan using t1_pkey on t1
8010    Index Cond: (id = 1)
8011 (2 rows)
8012
8013 DO LANGUAGE plpgsql $$
8014 DECLARE
8015     id integer;
8016 BEGIN
8017         SELECT /*+SeqScan(t1)*/ t1.id INTO id FROM t1 WHERE t1.id = 1;
8018         RETURN;
8019 END;
8020 $$;
8021 LOG:  pg_hint_plan:
8022 used hint:
8023 SeqScan(t1)
8024 not used hint:
8025 duplication hint:
8026 error hint:
8027
8028 CONTEXT:  SQL statement "SELECT /*+SeqScan(t1)*/ t1.id         FROM t1 WHERE t1.id = 1"
8029 PL/pgSQL function inline_code_block line 5 at SQL statement
8030 DROP EXTENSION pg_hint_plan;