expected/pg_hint_plan.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  Append
3023    ->  Seq Scan on p1
3024          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3025    ->  Seq Scan on p1_c1
3026          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3027    ->  Seq Scan on p1_c2
3028          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3029    ->  Seq Scan on p1_c3
3030          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3031    ->  Seq Scan on p1_c4
3032          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3033    ->  Seq Scan on p1_c1_c1
3034          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3035    ->  Seq Scan on p1_c1_c2
3036          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3037    ->  Seq Scan on p1_c3_c1
3038          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3039    ->  Seq Scan on p1_c3_c2
3040          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3041 (19 rows)
3042
3043 SET constraint_exclusion TO on;
3044 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3045                               QUERY PLAN
3046 -----------------------------------------------------------------------
3047  Append
3048    ->  Seq Scan on p1
3049          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3050    ->  Seq Scan on p1_c1
3051          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3052    ->  Seq Scan on p1_c1_c1
3053          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3054    ->  Seq Scan on p1_c1_c2
3055          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3056 (9 rows)
3057
3058 SET constraint_exclusion TO off;
3059 /*+SeqScan(p1)*/
3060 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3061 LOG:  pg_hint_plan:
3062 used hint:
3063 SeqScan(p1)
3064 not used hint:
3065 duplication hint:
3066 error hint:
3067
3068                               QUERY PLAN
3069 -----------------------------------------------------------------------
3070  Append
3071    ->  Seq Scan on p1
3072          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3073    ->  Seq Scan on p1_c1
3074          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3075    ->  Seq Scan on p1_c2
3076          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3077    ->  Seq Scan on p1_c3
3078          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3079    ->  Seq Scan on p1_c4
3080          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3081    ->  Seq Scan on p1_c1_c1
3082          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3083    ->  Seq Scan on p1_c1_c2
3084          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3085    ->  Seq Scan on p1_c3_c1
3086          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3087    ->  Seq Scan on p1_c3_c2
3088          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3089 (19 rows)
3090
3091 /*+IndexScan(p1)*/
3092 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3093 LOG:  pg_hint_plan:
3094 used hint:
3095 IndexScan(p1)
3096 not used hint:
3097 duplication hint:
3098 error hint:
3099
3100                     QUERY PLAN
3101 --------------------------------------------------
3102  Append
3103    ->  Index Scan using p1_pkey on p1
3104          Index Cond: ((id >= 50) AND (id <= 51))
3105          Filter: (ctid = '(1,1)'::tid)
3106    ->  Index Scan using p1_c1_pkey on p1_c1
3107          Index Cond: ((id >= 50) AND (id <= 51))
3108          Filter: (ctid = '(1,1)'::tid)
3109    ->  Index Scan using p1_c2_pkey on p1_c2
3110          Index Cond: ((id >= 50) AND (id <= 51))
3111          Filter: (ctid = '(1,1)'::tid)
3112    ->  Index Scan using p1_c3_pkey on p1_c3
3113          Index Cond: ((id >= 50) AND (id <= 51))
3114          Filter: (ctid = '(1,1)'::tid)
3115    ->  Index Scan using p1_c4_pkey on p1_c4
3116          Index Cond: ((id >= 50) AND (id <= 51))
3117          Filter: (ctid = '(1,1)'::tid)
3118    ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1
3119          Index Cond: ((id >= 50) AND (id <= 51))
3120          Filter: (ctid = '(1,1)'::tid)
3121    ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2
3122          Index Cond: ((id >= 50) AND (id <= 51))
3123          Filter: (ctid = '(1,1)'::tid)
3124    ->  Index Scan using p1_c3_c1_pkey on p1_c3_c1
3125          Index Cond: ((id >= 50) AND (id <= 51))
3126          Filter: (ctid = '(1,1)'::tid)
3127    ->  Index Scan using p1_c3_c2_pkey on p1_c3_c2
3128          Index Cond: ((id >= 50) AND (id <= 51))
3129          Filter: (ctid = '(1,1)'::tid)
3130 (28 rows)
3131
3132 /*+BitmapScan(p1)*/
3133 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3134 LOG:  pg_hint_plan:
3135 used hint:
3136 BitmapScan(p1)
3137 not used hint:
3138 duplication hint:
3139 error hint:
3140
3141                       QUERY PLAN
3142 -------------------------------------------------------
3143  Append
3144    ->  Bitmap Heap Scan on p1
3145          Recheck Cond: ((id >= 50) AND (id <= 51))
3146          Filter: (ctid = '(1,1)'::tid)
3147          ->  Bitmap Index Scan on p1_pkey
3148                Index Cond: ((id >= 50) AND (id <= 51))
3149    ->  Bitmap Heap Scan on p1_c1
3150          Recheck Cond: ((id >= 50) AND (id <= 51))
3151          Filter: (ctid = '(1,1)'::tid)
3152          ->  Bitmap Index Scan on p1_c1_pkey
3153                Index Cond: ((id >= 50) AND (id <= 51))
3154    ->  Bitmap Heap Scan on p1_c2
3155          Recheck Cond: ((id >= 50) AND (id <= 51))
3156          Filter: (ctid = '(1,1)'::tid)
3157          ->  Bitmap Index Scan on p1_c2_pkey
3158                Index Cond: ((id >= 50) AND (id <= 51))
3159    ->  Bitmap Heap Scan on p1_c3
3160          Recheck Cond: ((id >= 50) AND (id <= 51))
3161          Filter: (ctid = '(1,1)'::tid)
3162          ->  Bitmap Index Scan on p1_c3_pkey
3163                Index Cond: ((id >= 50) AND (id <= 51))
3164    ->  Bitmap Heap Scan on p1_c4
3165          Recheck Cond: ((id >= 50) AND (id <= 51))
3166          Filter: (ctid = '(1,1)'::tid)
3167          ->  Bitmap Index Scan on p1_c4_pkey
3168                Index Cond: ((id >= 50) AND (id <= 51))
3169    ->  Bitmap Heap Scan on p1_c1_c1
3170          Recheck Cond: ((id >= 50) AND (id <= 51))
3171          Filter: (ctid = '(1,1)'::tid)
3172          ->  Bitmap Index Scan on p1_c1_c1_pkey
3173                Index Cond: ((id >= 50) AND (id <= 51))
3174    ->  Bitmap Heap Scan on p1_c1_c2
3175          Recheck Cond: ((id >= 50) AND (id <= 51))
3176          Filter: (ctid = '(1,1)'::tid)
3177          ->  Bitmap Index Scan on p1_c1_c2_pkey
3178                Index Cond: ((id >= 50) AND (id <= 51))
3179    ->  Bitmap Heap Scan on p1_c3_c1
3180          Recheck Cond: ((id >= 50) AND (id <= 51))
3181          Filter: (ctid = '(1,1)'::tid)
3182          ->  Bitmap Index Scan on p1_c3_c1_pkey
3183                Index Cond: ((id >= 50) AND (id <= 51))
3184    ->  Bitmap Heap Scan on p1_c3_c2
3185          Recheck Cond: ((id >= 50) AND (id <= 51))
3186          Filter: (ctid = '(1,1)'::tid)
3187          ->  Bitmap Index Scan on p1_c3_c2_pkey
3188                Index Cond: ((id >= 50) AND (id <= 51))
3189 (46 rows)
3190
3191 /*+TidScan(p1)*/
3192 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3193 LOG:  pg_hint_plan:
3194 used hint:
3195 TidScan(p1)
3196 not used hint:
3197 duplication hint:
3198 error hint:
3199
3200                  QUERY PLAN
3201 ---------------------------------------------
3202  Append
3203    ->  Tid Scan on p1
3204          TID Cond: (ctid = '(1,1)'::tid)
3205          Filter: ((id >= 50) AND (id <= 51))
3206    ->  Tid Scan on p1_c1
3207          TID Cond: (ctid = '(1,1)'::tid)
3208          Filter: ((id >= 50) AND (id <= 51))
3209    ->  Tid Scan on p1_c2
3210          TID Cond: (ctid = '(1,1)'::tid)
3211          Filter: ((id >= 50) AND (id <= 51))
3212    ->  Tid Scan on p1_c3
3213          TID Cond: (ctid = '(1,1)'::tid)
3214          Filter: ((id >= 50) AND (id <= 51))
3215    ->  Tid Scan on p1_c4
3216          TID Cond: (ctid = '(1,1)'::tid)
3217          Filter: ((id >= 50) AND (id <= 51))
3218    ->  Tid Scan on p1_c1_c1
3219          TID Cond: (ctid = '(1,1)'::tid)
3220          Filter: ((id >= 50) AND (id <= 51))
3221    ->  Tid Scan on p1_c1_c2
3222          TID Cond: (ctid = '(1,1)'::tid)
3223          Filter: ((id >= 50) AND (id <= 51))
3224    ->  Tid Scan on p1_c3_c1
3225          TID Cond: (ctid = '(1,1)'::tid)
3226          Filter: ((id >= 50) AND (id <= 51))
3227    ->  Tid Scan on p1_c3_c2
3228          TID Cond: (ctid = '(1,1)'::tid)
3229          Filter: ((id >= 50) AND (id <= 51))
3230 (28 rows)
3231
3232 SET constraint_exclusion TO on;
3233 /*+SeqScan(p1)*/
3234 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3235 LOG:  pg_hint_plan:
3236 used hint:
3237 SeqScan(p1)
3238 not used hint:
3239 duplication hint:
3240 error hint:
3241
3242                               QUERY PLAN
3243 -----------------------------------------------------------------------
3244  Append
3245    ->  Seq Scan on p1
3246          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3247    ->  Seq Scan on p1_c1
3248          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3249    ->  Seq Scan on p1_c1_c1
3250          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3251    ->  Seq Scan on p1_c1_c2
3252          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3253 (9 rows)
3254
3255 /*+IndexScan(p1)*/
3256 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3257 LOG:  pg_hint_plan:
3258 used hint:
3259 IndexScan(p1)
3260 not used hint:
3261 duplication hint:
3262 error hint:
3263
3264                     QUERY PLAN
3265 --------------------------------------------------
3266  Append
3267    ->  Index Scan using p1_pkey on p1
3268          Index Cond: ((id >= 50) AND (id <= 51))
3269          Filter: (ctid = '(1,1)'::tid)
3270    ->  Index Scan using p1_c1_pkey on p1_c1
3271          Index Cond: ((id >= 50) AND (id <= 51))
3272          Filter: (ctid = '(1,1)'::tid)
3273    ->  Index Scan using p1_c1_c1_pkey on p1_c1_c1
3274          Index Cond: ((id >= 50) AND (id <= 51))
3275          Filter: (ctid = '(1,1)'::tid)
3276    ->  Index Scan using p1_c1_c2_pkey on p1_c1_c2
3277          Index Cond: ((id >= 50) AND (id <= 51))
3278          Filter: (ctid = '(1,1)'::tid)
3279 (13 rows)
3280
3281 /*+BitmapScan(p1)*/
3282 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3283 LOG:  pg_hint_plan:
3284 used hint:
3285 BitmapScan(p1)
3286 not used hint:
3287 duplication hint:
3288 error hint:
3289
3290                       QUERY PLAN
3291 -------------------------------------------------------
3292  Append
3293    ->  Bitmap Heap Scan on p1
3294          Recheck Cond: ((id >= 50) AND (id <= 51))
3295          Filter: (ctid = '(1,1)'::tid)
3296          ->  Bitmap Index Scan on p1_pkey
3297                Index Cond: ((id >= 50) AND (id <= 51))
3298    ->  Bitmap Heap Scan on p1_c1
3299          Recheck Cond: ((id >= 50) AND (id <= 51))
3300          Filter: (ctid = '(1,1)'::tid)
3301          ->  Bitmap Index Scan on p1_c1_pkey
3302                Index Cond: ((id >= 50) AND (id <= 51))
3303    ->  Bitmap Heap Scan on p1_c1_c1
3304          Recheck Cond: ((id >= 50) AND (id <= 51))
3305          Filter: (ctid = '(1,1)'::tid)
3306          ->  Bitmap Index Scan on p1_c1_c1_pkey
3307                Index Cond: ((id >= 50) AND (id <= 51))
3308    ->  Bitmap Heap Scan on p1_c1_c2
3309          Recheck Cond: ((id >= 50) AND (id <= 51))
3310          Filter: (ctid = '(1,1)'::tid)
3311          ->  Bitmap Index Scan on p1_c1_c2_pkey
3312                Index Cond: ((id >= 50) AND (id <= 51))
3313 (21 rows)
3314
3315 /*+TidScan(p1)*/
3316 EXPLAIN (COSTS false) SELECT * FROM p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3317 LOG:  pg_hint_plan:
3318 used hint:
3319 TidScan(p1)
3320 not used hint:
3321 duplication hint:
3322 error hint:
3323
3324                  QUERY PLAN
3325 ---------------------------------------------
3326  Append
3327    ->  Tid Scan on p1
3328          TID Cond: (ctid = '(1,1)'::tid)
3329          Filter: ((id >= 50) AND (id <= 51))
3330    ->  Tid Scan on p1_c1
3331          TID Cond: (ctid = '(1,1)'::tid)
3332          Filter: ((id >= 50) AND (id <= 51))
3333    ->  Tid Scan on p1_c1_c1
3334          TID Cond: (ctid = '(1,1)'::tid)
3335          Filter: ((id >= 50) AND (id <= 51))
3336    ->  Tid Scan on p1_c1_c2
3337          TID Cond: (ctid = '(1,1)'::tid)
3338          Filter: ((id >= 50) AND (id <= 51))
3339 (13 rows)
3340
3341 SET constraint_exclusion TO off;
3342 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;
3343                                     QUERY PLAN
3344 -----------------------------------------------------------------------------------
3345  Merge Join
3346    Merge Cond: (public.p1.id = t1.id)
3347    ->  Sort
3348          Sort Key: public.p1.id
3349          ->  Append
3350                ->  Seq Scan on p1
3351                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3352                ->  Seq Scan on p1_c1
3353                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3354                ->  Seq Scan on p1_c2
3355                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3356                ->  Seq Scan on p1_c3
3357                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3358                ->  Seq Scan on p1_c4
3359                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3360                ->  Seq Scan on p1_c1_c1
3361                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3362                ->  Seq Scan on p1_c1_c2
3363                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3364                ->  Seq Scan on p1_c3_c1
3365                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3366                ->  Seq Scan on p1_c3_c2
3367                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3368    ->  Index Scan using t1_pkey on t1
3369          Index Cond: (id < 10)
3370 (25 rows)
3371
3372 SET constraint_exclusion TO on;
3373 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;
3374                                     QUERY PLAN
3375 -----------------------------------------------------------------------------------
3376  Merge Join
3377    Merge Cond: (public.p1.id = t1.id)
3378    ->  Sort
3379          Sort Key: public.p1.id
3380          ->  Append
3381                ->  Seq Scan on p1
3382                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3383                ->  Seq Scan on p1_c1
3384                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3385                ->  Seq Scan on p1_c1_c1
3386                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3387                ->  Seq Scan on p1_c1_c2
3388                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3389    ->  Index Scan using t1_pkey on t1
3390          Index Cond: (id < 10)
3391 (15 rows)
3392
3393 SET constraint_exclusion TO off;
3394 /*+SeqScan(p1)*/
3395 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;
3396 LOG:  pg_hint_plan:
3397 used hint:
3398 SeqScan(p1)
3399 not used hint:
3400 duplication hint:
3401 error hint:
3402
3403                                     QUERY PLAN
3404 -----------------------------------------------------------------------------------
3405  Merge Join
3406    Merge Cond: (public.p1.id = t1.id)
3407    ->  Sort
3408          Sort Key: public.p1.id
3409          ->  Append
3410                ->  Seq Scan on p1
3411                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3412                ->  Seq Scan on p1_c1
3413                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3414                ->  Seq Scan on p1_c2
3415                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3416                ->  Seq Scan on p1_c3
3417                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3418                ->  Seq Scan on p1_c4
3419                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3420                ->  Seq Scan on p1_c1_c1
3421                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3422                ->  Seq Scan on p1_c1_c2
3423                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3424                ->  Seq Scan on p1_c3_c1
3425                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3426                ->  Seq Scan on p1_c3_c2
3427                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3428    ->  Index Scan using t1_pkey on t1
3429          Index Cond: (id < 10)
3430 (25 rows)
3431
3432 /*+IndexScan(p1)*/
3433 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;
3434 LOG:  pg_hint_plan:
3435 used hint:
3436 IndexScan(p1)
3437 not used hint:
3438 duplication hint:
3439 error hint:
3440
3441                                     QUERY PLAN
3442 -----------------------------------------------------------------------------------
3443  Merge Join
3444    Merge Cond: (public.p1.id = t1.id)
3445    ->  Sort
3446          Sort Key: public.p1.id
3447          ->  Append
3448                ->  Seq Scan on p1
3449                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3450                ->  Seq Scan on p1_c1
3451                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3452                ->  Seq Scan on p1_c2
3453                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3454                ->  Seq Scan on p1_c3
3455                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3456                ->  Seq Scan on p1_c4
3457                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3458                ->  Seq Scan on p1_c1_c1
3459                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3460                ->  Seq Scan on p1_c1_c2
3461                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3462                ->  Seq Scan on p1_c3_c1
3463                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3464                ->  Seq Scan on p1_c3_c2
3465                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3466    ->  Index Scan using t1_pkey on t1
3467          Index Cond: (id < 10)
3468 (25 rows)
3469
3470 /*+BitmapScan(p1)*/
3471 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;
3472 LOG:  pg_hint_plan:
3473 used hint:
3474 BitmapScan(p1)
3475 not used hint:
3476 duplication hint:
3477 error hint:
3478
3479                                     QUERY PLAN
3480 -----------------------------------------------------------------------------------
3481  Merge Join
3482    Merge Cond: (public.p1.id = t1.id)
3483    ->  Sort
3484          Sort Key: public.p1.id
3485          ->  Append
3486                ->  Seq Scan on p1
3487                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3488                ->  Seq Scan on p1_c1
3489                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3490                ->  Seq Scan on p1_c2
3491                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3492                ->  Seq Scan on p1_c3
3493                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3494                ->  Seq Scan on p1_c4
3495                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3496                ->  Seq Scan on p1_c1_c1
3497                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3498                ->  Seq Scan on p1_c1_c2
3499                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3500                ->  Seq Scan on p1_c3_c1
3501                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3502                ->  Seq Scan on p1_c3_c2
3503                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3504    ->  Index Scan using t1_pkey on t1
3505          Index Cond: (id < 10)
3506 (25 rows)
3507
3508 /*+TidScan(p1)*/
3509 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;
3510 LOG:  pg_hint_plan:
3511 used hint:
3512 TidScan(p1)
3513 not used hint:
3514 duplication hint:
3515 error hint:
3516
3517                                     QUERY PLAN
3518 -----------------------------------------------------------------------------------
3519  Merge Join
3520    Merge Cond: (public.p1.id = t1.id)
3521    ->  Sort
3522          Sort Key: public.p1.id
3523          ->  Append
3524                ->  Seq Scan on p1
3525                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3526                ->  Seq Scan on p1_c1
3527                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3528                ->  Seq Scan on p1_c2
3529                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3530                ->  Seq Scan on p1_c3
3531                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3532                ->  Seq Scan on p1_c4
3533                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3534                ->  Seq Scan on p1_c1_c1
3535                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3536                ->  Seq Scan on p1_c1_c2
3537                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3538                ->  Seq Scan on p1_c3_c1
3539                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3540                ->  Seq Scan on p1_c3_c2
3541                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3542    ->  Index Scan using t1_pkey on t1
3543          Index Cond: (id < 10)
3544 (25 rows)
3545
3546 /*+NestLoop(p1 t1)*/
3547 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;
3548 LOG:  pg_hint_plan:
3549 used hint:
3550 NestLoop(p1 t1)
3551 not used hint:
3552 duplication hint:
3553 error hint:
3554
3555                                  QUERY PLAN
3556 -----------------------------------------------------------------------------
3557  Nested Loop
3558    Join Filter: (public.p1.id = t1.id)
3559    ->  Append
3560          ->  Seq Scan on p1
3561                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3562          ->  Seq Scan on p1_c1
3563                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3564          ->  Seq Scan on p1_c2
3565                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3566          ->  Seq Scan on p1_c3
3567                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3568          ->  Seq Scan on p1_c4
3569                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3570          ->  Seq Scan on p1_c1_c1
3571                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3572          ->  Seq Scan on p1_c1_c2
3573                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3574          ->  Seq Scan on p1_c3_c1
3575                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3576          ->  Seq Scan on p1_c3_c2
3577                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3578    ->  Materialize
3579          ->  Index Scan using t1_pkey on t1
3580                Index Cond: (id < 10)
3581 (24 rows)
3582
3583 /*+MergeJoin(p1 t1)*/
3584 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;
3585 LOG:  pg_hint_plan:
3586 used hint:
3587 MergeJoin(p1 t1)
3588 not used hint:
3589 duplication hint:
3590 error hint:
3591
3592                                     QUERY PLAN
3593 -----------------------------------------------------------------------------------
3594  Merge Join
3595    Merge Cond: (public.p1.id = t1.id)
3596    ->  Sort
3597          Sort Key: public.p1.id
3598          ->  Append
3599                ->  Seq Scan on p1
3600                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3601                ->  Seq Scan on p1_c1
3602                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3603                ->  Seq Scan on p1_c2
3604                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3605                ->  Seq Scan on p1_c3
3606                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3607                ->  Seq Scan on p1_c4
3608                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3609                ->  Seq Scan on p1_c1_c1
3610                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3611                ->  Seq Scan on p1_c1_c2
3612                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3613                ->  Seq Scan on p1_c3_c1
3614                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3615                ->  Seq Scan on p1_c3_c2
3616                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3617    ->  Index Scan using t1_pkey on t1
3618          Index Cond: (id < 10)
3619 (25 rows)
3620
3621 /*+HashJoin(p1 t1)*/
3622 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;
3623 LOG:  pg_hint_plan:
3624 used hint:
3625 HashJoin(p1 t1)
3626 not used hint:
3627 duplication hint:
3628 error hint:
3629
3630                                  QUERY PLAN
3631 -----------------------------------------------------------------------------
3632  Hash Join
3633    Hash Cond: (public.p1.id = t1.id)
3634    ->  Append
3635          ->  Seq Scan on p1
3636                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3637          ->  Seq Scan on p1_c1
3638                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3639          ->  Seq Scan on p1_c2
3640                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3641          ->  Seq Scan on p1_c3
3642                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3643          ->  Seq Scan on p1_c4
3644                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3645          ->  Seq Scan on p1_c1_c1
3646                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3647          ->  Seq Scan on p1_c1_c2
3648                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3649          ->  Seq Scan on p1_c3_c1
3650                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3651          ->  Seq Scan on p1_c3_c2
3652                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3653    ->  Hash
3654          ->  Index Scan using t1_pkey on t1
3655                Index Cond: (id < 10)
3656 (24 rows)
3657
3658 SET constraint_exclusion TO on;
3659 /*+SeqScan(p1)*/
3660 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;
3661 LOG:  pg_hint_plan:
3662 used hint:
3663 SeqScan(p1)
3664 not used hint:
3665 duplication hint:
3666 error hint:
3667
3668                                     QUERY PLAN
3669 -----------------------------------------------------------------------------------
3670  Merge Join
3671    Merge Cond: (public.p1.id = t1.id)
3672    ->  Sort
3673          Sort Key: public.p1.id
3674          ->  Append
3675                ->  Seq Scan on p1
3676                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3677                ->  Seq Scan on p1_c1
3678                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3679                ->  Seq Scan on p1_c1_c1
3680                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3681                ->  Seq Scan on p1_c1_c2
3682                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3683    ->  Index Scan using t1_pkey on t1
3684          Index Cond: (id < 10)
3685 (15 rows)
3686
3687 /*+IndexScan(p1)*/
3688 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;
3689 LOG:  pg_hint_plan:
3690 used hint:
3691 IndexScan(p1)
3692 not used hint:
3693 duplication hint:
3694 error hint:
3695
3696                                     QUERY PLAN
3697 -----------------------------------------------------------------------------------
3698  Merge Join
3699    Merge Cond: (public.p1.id = t1.id)
3700    ->  Sort
3701          Sort Key: public.p1.id
3702          ->  Append
3703                ->  Seq Scan on p1
3704                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3705                ->  Seq Scan on p1_c1
3706                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3707                ->  Seq Scan on p1_c1_c1
3708                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3709                ->  Seq Scan on p1_c1_c2
3710                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3711    ->  Index Scan using t1_pkey on t1
3712          Index Cond: (id < 10)
3713 (15 rows)
3714
3715 /*+BitmapScan(p1)*/
3716 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;
3717 LOG:  pg_hint_plan:
3718 used hint:
3719 BitmapScan(p1)
3720 not used hint:
3721 duplication hint:
3722 error hint:
3723
3724                                     QUERY PLAN
3725 -----------------------------------------------------------------------------------
3726  Merge Join
3727    Merge Cond: (public.p1.id = t1.id)
3728    ->  Sort
3729          Sort Key: public.p1.id
3730          ->  Append
3731                ->  Seq Scan on p1
3732                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3733                ->  Seq Scan on p1_c1
3734                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3735                ->  Seq Scan on p1_c1_c1
3736                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3737                ->  Seq Scan on p1_c1_c2
3738                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3739    ->  Index Scan using t1_pkey on t1
3740          Index Cond: (id < 10)
3741 (15 rows)
3742
3743 /*+TidScan(p1)*/
3744 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;
3745 LOG:  pg_hint_plan:
3746 used hint:
3747 TidScan(p1)
3748 not used hint:
3749 duplication hint:
3750 error hint:
3751
3752                                     QUERY PLAN
3753 -----------------------------------------------------------------------------------
3754  Merge Join
3755    Merge Cond: (public.p1.id = t1.id)
3756    ->  Sort
3757          Sort Key: public.p1.id
3758          ->  Append
3759                ->  Seq Scan on p1
3760                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3761                ->  Seq Scan on p1_c1
3762                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3763                ->  Seq Scan on p1_c1_c1
3764                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3765                ->  Seq Scan on p1_c1_c2
3766                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3767    ->  Index Scan using t1_pkey on t1
3768          Index Cond: (id < 10)
3769 (15 rows)
3770
3771 /*+NestLoop(p1 t1)*/
3772 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;
3773 LOG:  pg_hint_plan:
3774 used hint:
3775 NestLoop(p1 t1)
3776 not used hint:
3777 duplication hint:
3778 error hint:
3779
3780                                     QUERY PLAN
3781 -----------------------------------------------------------------------------------
3782  Nested Loop
3783    Join Filter: (public.p1.id = t1.id)
3784    ->  Index Scan using t1_pkey on t1
3785          Index Cond: (id < 10)
3786    ->  Materialize
3787          ->  Append
3788                ->  Seq Scan on p1
3789                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3790                ->  Seq Scan on p1_c1
3791                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3792                ->  Seq Scan on p1_c1_c1
3793                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3794                ->  Seq Scan on p1_c1_c2
3795                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3796 (14 rows)
3797
3798 /*+MergeJoin(p1 t1)*/
3799 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;
3800 LOG:  pg_hint_plan:
3801 used hint:
3802 MergeJoin(p1 t1)
3803 not used hint:
3804 duplication hint:
3805 error hint:
3806
3807                                     QUERY PLAN
3808 -----------------------------------------------------------------------------------
3809  Merge Join
3810    Merge Cond: (public.p1.id = t1.id)
3811    ->  Sort
3812          Sort Key: public.p1.id
3813          ->  Append
3814                ->  Seq Scan on p1
3815                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3816                ->  Seq Scan on p1_c1
3817                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3818                ->  Seq Scan on p1_c1_c1
3819                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3820                ->  Seq Scan on p1_c1_c2
3821                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3822    ->  Index Scan using t1_pkey on t1
3823          Index Cond: (id < 10)
3824 (15 rows)
3825
3826 /*+HashJoin(p1 t1)*/
3827 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;
3828 LOG:  pg_hint_plan:
3829 used hint:
3830 HashJoin(p1 t1)
3831 not used hint:
3832 duplication hint:
3833 error hint:
3834
3835                                     QUERY PLAN
3836 -----------------------------------------------------------------------------------
3837  Hash Join
3838    Hash Cond: (t1.id = public.p1.id)
3839    ->  Index Scan using t1_pkey on t1
3840          Index Cond: (id < 10)
3841    ->  Hash
3842          ->  Append
3843                ->  Seq Scan on p1
3844                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3845                ->  Seq Scan on p1_c1
3846                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3847                ->  Seq Scan on p1_c1_c1
3848                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3849                ->  Seq Scan on p1_c1_c2
3850                      Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3851 (14 rows)
3852
3853 SET constraint_exclusion TO off;
3854 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3855                            QUERY PLAN
3856 -----------------------------------------------------------------
3857  Seq Scan on p1
3858    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3859 (2 rows)
3860
3861 SET constraint_exclusion TO on;
3862 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3863                            QUERY PLAN
3864 -----------------------------------------------------------------
3865  Seq Scan on p1
3866    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3867 (2 rows)
3868
3869 SET constraint_exclusion TO off;
3870 /*+SeqScan(p1)*/
3871 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3872 LOG:  pg_hint_plan:
3873 used hint:
3874 SeqScan(p1)
3875 not used hint:
3876 duplication hint:
3877 error hint:
3878
3879                            QUERY PLAN
3880 -----------------------------------------------------------------
3881  Seq Scan on p1
3882    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3883 (2 rows)
3884
3885 /*+IndexScan(p1)*/
3886 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3887 LOG:  pg_hint_plan:
3888 used hint:
3889 IndexScan(p1)
3890 not used hint:
3891 duplication hint:
3892 error hint:
3893
3894                 QUERY PLAN
3895 -------------------------------------------
3896  Index Scan using p1_pkey on p1
3897    Index Cond: ((id >= 50) AND (id <= 51))
3898    Filter: (ctid = '(1,1)'::tid)
3899 (3 rows)
3900
3901 /*+BitmapScan(p1)*/
3902 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3903 LOG:  pg_hint_plan:
3904 used hint:
3905 BitmapScan(p1)
3906 not used hint:
3907 duplication hint:
3908 error hint:
3909
3910                    QUERY PLAN
3911 -------------------------------------------------
3912  Bitmap Heap Scan on p1
3913    Recheck Cond: ((id >= 50) AND (id <= 51))
3914    Filter: (ctid = '(1,1)'::tid)
3915    ->  Bitmap Index Scan on p1_pkey
3916          Index Cond: ((id >= 50) AND (id <= 51))
3917 (5 rows)
3918
3919 /*+TidScan(p1)*/
3920 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3921 LOG:  pg_hint_plan:
3922 used hint:
3923 TidScan(p1)
3924 not used hint:
3925 duplication hint:
3926 error hint:
3927
3928               QUERY PLAN
3929 ---------------------------------------
3930  Tid Scan on p1
3931    TID Cond: (ctid = '(1,1)'::tid)
3932    Filter: ((id >= 50) AND (id <= 51))
3933 (3 rows)
3934
3935 /*+NestLoop(p1 t1)*/
3936 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;
3937 LOG:  pg_hint_plan:
3938 used hint:
3939 NestLoop(p1 t1)
3940 not used hint:
3941 duplication hint:
3942 error hint:
3943
3944                               QUERY PLAN
3945 -----------------------------------------------------------------------
3946  Nested Loop
3947    ->  Seq Scan on p1
3948          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3949    ->  Index Scan using t1_pkey on t1
3950          Index Cond: ((id = p1.id) AND (id < 10))
3951 (5 rows)
3952
3953 /*+MergeJoin(p1 t1)*/
3954 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;
3955 LOG:  pg_hint_plan:
3956 used hint:
3957 MergeJoin(p1 t1)
3958 not used hint:
3959 duplication hint:
3960 error hint:
3961
3962                                  QUERY PLAN
3963 -----------------------------------------------------------------------------
3964  Merge Join
3965    Merge Cond: (p1.id = t1.id)
3966    ->  Sort
3967          Sort Key: p1.id
3968          ->  Seq Scan on p1
3969                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3970    ->  Index Scan using t1_pkey on t1
3971          Index Cond: (id < 10)
3972 (8 rows)
3973
3974 /*+HashJoin(p1 t1)*/
3975 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;
3976 LOG:  pg_hint_plan:
3977 used hint:
3978 HashJoin(p1 t1)
3979 not used hint:
3980 duplication hint:
3981 error hint:
3982
3983                                  QUERY PLAN
3984 -----------------------------------------------------------------------------
3985  Hash Join
3986    Hash Cond: (t1.id = p1.id)
3987    ->  Index Scan using t1_pkey on t1
3988          Index Cond: (id < 10)
3989    ->  Hash
3990          ->  Seq Scan on p1
3991                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
3992 (7 rows)
3993
3994 SET constraint_exclusion TO on;
3995 /*+SeqScan(p1)*/
3996 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
3997 LOG:  pg_hint_plan:
3998 used hint:
3999 SeqScan(p1)
4000 not used hint:
4001 duplication hint:
4002 error hint:
4003
4004                            QUERY PLAN
4005 -----------------------------------------------------------------
4006  Seq Scan on p1
4007    Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4008 (2 rows)
4009
4010 /*+IndexScan(p1)*/
4011 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4012 LOG:  pg_hint_plan:
4013 used hint:
4014 IndexScan(p1)
4015 not used hint:
4016 duplication hint:
4017 error hint:
4018
4019                 QUERY PLAN
4020 -------------------------------------------
4021  Index Scan using p1_pkey on p1
4022    Index Cond: ((id >= 50) AND (id <= 51))
4023    Filter: (ctid = '(1,1)'::tid)
4024 (3 rows)
4025
4026 /*+BitmapScan(p1)*/
4027 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4028 LOG:  pg_hint_plan:
4029 used hint:
4030 BitmapScan(p1)
4031 not used hint:
4032 duplication hint:
4033 error hint:
4034
4035                    QUERY PLAN
4036 -------------------------------------------------
4037  Bitmap Heap Scan on p1
4038    Recheck Cond: ((id >= 50) AND (id <= 51))
4039    Filter: (ctid = '(1,1)'::tid)
4040    ->  Bitmap Index Scan on p1_pkey
4041          Index Cond: ((id >= 50) AND (id <= 51))
4042 (5 rows)
4043
4044 /*+TidScan(p1)*/
4045 EXPLAIN (COSTS false) SELECT * FROM ONLY p1 WHERE id >= 50 AND id <= 51 AND p1.ctid = '(1,1)';
4046 LOG:  pg_hint_plan:
4047 used hint:
4048 TidScan(p1)
4049 not used hint:
4050 duplication hint:
4051 error hint:
4052
4053               QUERY PLAN
4054 ---------------------------------------
4055  Tid Scan on p1
4056    TID Cond: (ctid = '(1,1)'::tid)
4057    Filter: ((id >= 50) AND (id <= 51))
4058 (3 rows)
4059
4060 /*+NestLoop(p1 t1)*/
4061 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;
4062 LOG:  pg_hint_plan:
4063 used hint:
4064 NestLoop(p1 t1)
4065 not used hint:
4066 duplication hint:
4067 error hint:
4068
4069                               QUERY PLAN
4070 -----------------------------------------------------------------------
4071  Nested Loop
4072    ->  Seq Scan on p1
4073          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4074    ->  Index Scan using t1_pkey on t1
4075          Index Cond: ((id = p1.id) AND (id < 10))
4076 (5 rows)
4077
4078 /*+MergeJoin(p1 t1)*/
4079 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;
4080 LOG:  pg_hint_plan:
4081 used hint:
4082 MergeJoin(p1 t1)
4083 not used hint:
4084 duplication hint:
4085 error hint:
4086
4087                                  QUERY PLAN
4088 -----------------------------------------------------------------------------
4089  Merge Join
4090    Merge Cond: (p1.id = t1.id)
4091    ->  Sort
4092          Sort Key: p1.id
4093          ->  Seq Scan on p1
4094                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4095    ->  Index Scan using t1_pkey on t1
4096          Index Cond: (id < 10)
4097 (8 rows)
4098
4099 /*+HashJoin(p1 t1)*/
4100 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;
4101 LOG:  pg_hint_plan:
4102 used hint:
4103 HashJoin(p1 t1)
4104 not used hint:
4105 duplication hint:
4106 error hint:
4107
4108                                  QUERY PLAN
4109 -----------------------------------------------------------------------------
4110  Hash Join
4111    Hash Cond: (t1.id = p1.id)
4112    ->  Index Scan using t1_pkey on t1
4113          Index Cond: (id < 10)
4114    ->  Hash
4115          ->  Seq Scan on p1
4116                Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4117 (7 rows)
4118
4119 SET constraint_exclusion TO off;
4120 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;
4121                               QUERY PLAN
4122 -----------------------------------------------------------------------
4123  Nested Loop
4124    ->  Seq Scan on p1
4125          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4126    ->  Index Scan using t1_pkey on t1
4127          Index Cond: ((id = p1.id) AND (id < 10))
4128 (5 rows)
4129
4130 SET constraint_exclusion TO on;
4131 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;
4132                               QUERY PLAN
4133 -----------------------------------------------------------------------
4134  Nested Loop
4135    ->  Seq Scan on p1
4136          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4137    ->  Index Scan using t1_pkey on t1
4138          Index Cond: ((id = p1.id) AND (id < 10))
4139 (5 rows)
4140
4141 SET constraint_exclusion TO off;
4142 /*+SeqScan(p1)*/
4143 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;
4144 LOG:  pg_hint_plan:
4145 used hint:
4146 SeqScan(p1)
4147 not used hint:
4148 duplication hint:
4149 error hint:
4150
4151                               QUERY PLAN
4152 -----------------------------------------------------------------------
4153  Nested Loop
4154    ->  Seq Scan on p1
4155          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4156    ->  Index Scan using t1_pkey on t1
4157          Index Cond: ((id = p1.id) AND (id < 10))
4158 (5 rows)
4159
4160 /*+IndexScan(p1)*/
4161 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;
4162 LOG:  pg_hint_plan:
4163 used hint:
4164 IndexScan(p1)
4165 not used hint:
4166 duplication hint:
4167 error hint:
4168
4169                     QUERY PLAN
4170 --------------------------------------------------
4171  Nested Loop
4172    ->  Index Scan using p1_pkey on p1
4173          Index Cond: ((id >= 50) AND (id <= 51))
4174          Filter: (ctid = '(1,1)'::tid)
4175    ->  Index Scan using t1_pkey on t1
4176          Index Cond: ((id = p1.id) AND (id < 10))
4177 (6 rows)
4178
4179 /*+BitmapScan(p1)*/
4180 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;
4181 LOG:  pg_hint_plan:
4182 used hint:
4183 BitmapScan(p1)
4184 not used hint:
4185 duplication hint:
4186 error hint:
4187
4188                       QUERY PLAN
4189 -------------------------------------------------------
4190  Nested Loop
4191    ->  Bitmap Heap Scan on p1
4192          Recheck Cond: ((id >= 50) AND (id <= 51))
4193          Filter: (ctid = '(1,1)'::tid)
4194          ->  Bitmap Index Scan on p1_pkey
4195                Index Cond: ((id >= 50) AND (id <= 51))
4196    ->  Index Scan using t1_pkey on t1
4197          Index Cond: ((id = p1.id) AND (id < 10))
4198 (8 rows)
4199
4200 /*+TidScan(p1)*/
4201 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;
4202 LOG:  pg_hint_plan:
4203 used hint:
4204 TidScan(p1)
4205 not used hint:
4206 duplication hint:
4207 error hint:
4208
4209                     QUERY PLAN
4210 --------------------------------------------------
4211  Nested Loop
4212    ->  Tid Scan on p1
4213          TID Cond: (ctid = '(1,1)'::tid)
4214          Filter: ((id >= 50) AND (id <= 51))
4215    ->  Index Scan using t1_pkey on t1
4216          Index Cond: ((id = p1.id) AND (id < 10))
4217 (6 rows)
4218
4219 SET constraint_exclusion TO on;
4220 /*+SeqScan(p1)*/
4221 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;
4222 LOG:  pg_hint_plan:
4223 used hint:
4224 SeqScan(p1)
4225 not used hint:
4226 duplication hint:
4227 error hint:
4228
4229                               QUERY PLAN
4230 -----------------------------------------------------------------------
4231  Nested Loop
4232    ->  Seq Scan on p1
4233          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
4234    ->  Index Scan using t1_pkey on t1
4235          Index Cond: ((id = p1.id) AND (id < 10))
4236 (5 rows)
4237
4238 /*+IndexScan(p1)*/
4239 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;
4240 LOG:  pg_hint_plan:
4241 used hint:
4242 IndexScan(p1)
4243 not used hint:
4244 duplication hint:
4245 error hint:
4246
4247                     QUERY PLAN
4248 --------------------------------------------------
4249  Nested Loop
4250    ->  Index Scan using p1_pkey on p1
4251          Index Cond: ((id >= 50) AND (id <= 51))
4252          Filter: (ctid = '(1,1)'::tid)
4253    ->  Index Scan using t1_pkey on t1
4254          Index Cond: ((id = p1.id) AND (id < 10))
4255 (6 rows)
4256
4257 /*+BitmapScan(p1)*/
4258 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;
4259 LOG:  pg_hint_plan:
4260 used hint:
4261 BitmapScan(p1)
4262 not used hint:
4263 duplication hint:
4264 error hint:
4265
4266                       QUERY PLAN
4267 -------------------------------------------------------
4268  Nested Loop
4269    ->  Bitmap Heap Scan on p1
4270          Recheck Cond: ((id >= 50) AND (id <= 51))
4271          Filter: (ctid = '(1,1)'::tid)
4272          ->  Bitmap Index Scan on p1_pkey
4273                Index Cond: ((id >= 50) AND (id <= 51))
4274    ->  Index Scan using t1_pkey on t1
4275          Index Cond: ((id = p1.id) AND (id < 10))
4276 (8 rows)
4277
4278 /*+TidScan(p1)*/
4279 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;
4280 LOG:  pg_hint_plan:
4281 used hint:
4282 TidScan(p1)
4283 not used hint:
4284 duplication hint:
4285 error hint:
4286
4287                     QUERY PLAN
4288 --------------------------------------------------
4289  Nested Loop
4290    ->  Tid Scan on p1
4291          TID Cond: (ctid = '(1,1)'::tid)
4292          Filter: ((id >= 50) AND (id <= 51))
4293    ->  Index Scan using t1_pkey on t1
4294          Index Cond: ((id = p1.id) AND (id < 10))
4295 (6 rows)
4296
4297 -- quote test
4298 /*+SeqScan("""t1 )      ")IndexScan("t  2 """)HashJoin("""t1 )  "T3"t   2 """)Leading("""t1 )   "T3"t   2 """)Set(application_name"a    a       a""     a       A")*/
4299 EXPLAIN (COSTS false) SELECT * FROM t1 """t1 )  ", t2 "t        2 """, t3 "T3" WHERE """t1 )    ".id = "t       2 """.id AND """t1 )    ".id = "T3".id;
4300 LOG:  pg_hint_plan:
4301 used hint:
4302 SeqScan("""t1 ) ")
4303 IndexScan("t    2 """)
4304 HashJoin("""t1 )        " T3 "t 2 """)
4305 Leading("""t1 ) " T3 "t 2 """)
4306 Set(application_name "a a       a""     a       A")
4307 not used hint:
4308 duplication hint:
4309 error hint:
4310
4311                        QUERY PLAN
4312 ---------------------------------------------------------
4313  Hash Join
4314    Hash Cond: ("t        2 """.id = """t1 )      ".id)
4315    ->  Index Scan using t2_pkey on t2 "t 2 """
4316    ->  Hash
4317          ->  Hash Join
4318                Hash Cond: ("""t1 )       ".id = "T3".id)
4319                ->  Seq Scan on t1 """t1 )        "
4320                ->  Hash
4321                      ->  Seq Scan on t3 "T3"
4322 (9 rows)
4323
4324 -- duplicate hint test
4325 /*+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)*/
4326 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.ctid = '(1,1)' AND t2.ctid = '(1,1)';
4327 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)"
4328 DETAIL:  Conflict scan method hint.
4329 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)"
4330 DETAIL:  Conflict scan method hint.
4331 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)"
4332 DETAIL:  Conflict scan method hint.
4333 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)"
4334 DETAIL:  Conflict scan method hint.
4335 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)"
4336 DETAIL:  Conflict scan method hint.
4337 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)"
4338 DETAIL:  Conflict scan method hint.
4339 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)"
4340 DETAIL:  Conflict join method hint.
4341 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)"
4342 DETAIL:  Conflict join method hint.
4343 INFO:  hint syntax error at or near "Set(enable_seqscan off)Set(enable_mergejoin on)Set(enable_seqscan on)"
4344 DETAIL:  Conflict set hint.
4345 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)"
4346 DETAIL:  Conflict leading hint.
4347 LOG:  pg_hint_plan:
4348 used hint:
4349 TidScan(t1)
4350 TidScan(t2)
4351 MergeJoin(t1 t2)
4352 Leading(t2 t1)
4353 Set(enable_mergejoin on)
4354 Set(enable_seqscan on)
4355 not used hint:
4356 duplication hint:
4357 SeqScan(t1)
4358 IndexScan(t1)
4359 BitmapScan(t1)
4360 SeqScan(t2)
4361 IndexScan(t2)
4362 BitmapScan(t2)
4363 HashJoin(t1 t2)
4364 NestLoop(t1 t2)
4365 Leading(t1 t2)
4366 Set(enable_seqscan off)
4367 error hint:
4368
4369                   QUERY PLAN
4370 -----------------------------------------------
4371  Merge Join
4372    Merge Cond: (t1.id = t2.id)
4373    ->  Sort
4374          Sort Key: t1.id
4375          ->  Tid Scan on t1
4376                TID Cond: (ctid = '(1,1)'::tid)
4377    ->  Sort
4378          Sort Key: t2.id
4379          ->  Tid Scan on t2
4380                TID Cond: (ctid = '(1,1)'::tid)
4381 (10 rows)
4382
4383 -- sub query Leading hint test
4384 SET from_collapse_limit TO 100;
4385 SET geqo_threshold TO 100;
4386 EXPLAIN (COSTS false)
4387 WITH c1_1(id) AS (
4388 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
4389 )
4390 SELECT t1_1.id, (
4391 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
4392 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4393 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
4394 ) 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 = (
4395 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
4396 );
4397                                   QUERY PLAN
4398 ------------------------------------------------------------------------------
4399  Nested Loop
4400    CTE c1_1
4401      ->  Aggregate
4402            ->  Merge Join
4403                  Merge Cond: (t1_5.id = t3_5.id)
4404                  ->  Merge Join
4405                        Merge Cond: (t1_5.id = t2_5.id)
4406                        ->  Index Only Scan using t1_pkey on t1 t1_5
4407                        ->  Index Only Scan using t2_pkey on t2 t2_5
4408                  ->  Sort
4409                        Sort Key: t3_5.id
4410                        ->  Seq Scan on t3 t3_5
4411    InitPlan 2 (returns $1)
4412      ->  Aggregate
4413            ->  Merge Join
4414                  Merge Cond: (t1_2.id = t3_2.id)
4415                  ->  Merge Join
4416                        Merge Cond: (t1_2.id = t2_2.id)
4417                        ->  Index Only Scan using t1_pkey on t1 t1_2
4418                        ->  Index Only Scan using t2_pkey on t2 t2_2
4419                  ->  Sort
4420                        Sort Key: t3_2.id
4421                        ->  Seq Scan on t3 t3_2
4422    InitPlan 3 (returns $2)
4423      ->  Aggregate
4424            ->  Merge Join
4425                  Merge Cond: (t1_4.id = t3_4.id)
4426                  ->  Merge Join
4427                        Merge Cond: (t1_4.id = t2_4.id)
4428                        ->  Index Only Scan using t1_pkey on t1 t1_4
4429                        ->  Index Only Scan using t2_pkey on t2 t2_4
4430                  ->  Sort
4431                        Sort Key: t3_4.id
4432                        ->  Seq Scan on t3 t3_4
4433    ->  Nested Loop
4434          ->  Nested Loop
4435                ->  Nested Loop
4436                      ->  Nested Loop
4437                            ->  Nested Loop
4438                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4439                                        Index Cond: (id = $2)
4440                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4441                                        Index Cond: (id = $2)
4442                            ->  Seq Scan on t3 t3_1
4443                                  Filter: (id = $2)
4444                      ->  Index Only Scan using t1_pkey on t1 t1_3
4445                            Index Cond: (id = $2)
4446                ->  Index Only Scan using t2_pkey on t2 t2_3
4447                      Index Cond: (id = $2)
4448          ->  Seq Scan on t3 t3_3
4449                Filter: (id = $2)
4450    ->  CTE Scan on c1_1
4451          Filter: (id = $2)
4452 (53 rows)
4453
4454 /*+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)*/
4455 EXPLAIN (COSTS false)
4456 WITH c1_1(id) AS (
4457 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
4458 )
4459 SELECT t1_1.id, (
4460 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
4461 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4462 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
4463 ) 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 = (
4464 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
4465 );
4466 LOG:  pg_hint_plan:
4467 used hint:
4468 HashJoin(t1_1 t3_1)
4469 NestLoop(t1_2 t2_2)
4470 MergeJoin(t1_3 t3_3)
4471 NestLoop(t1_4 t2_4)
4472 NestLoop(t1_5 t2_5)
4473 not used hint:
4474 duplication hint:
4475 error hint:
4476
4477                                   QUERY PLAN
4478 ------------------------------------------------------------------------------
4479  Nested Loop
4480    CTE c1_1
4481      ->  Aggregate
4482            ->  Merge Join
4483                  Merge Cond: (t1_5.id = t3_5.id)
4484                  ->  Nested Loop
4485                        ->  Index Only Scan using t2_pkey on t2 t2_5
4486                        ->  Index Only Scan using t1_pkey on t1 t1_5
4487                              Index Cond: (id = t2_5.id)
4488                  ->  Sort
4489                        Sort Key: t3_5.id
4490                        ->  Seq Scan on t3 t3_5
4491    InitPlan 2 (returns $3)
4492      ->  Aggregate
4493            ->  Merge Join
4494                  Merge Cond: (t1_2.id = t3_2.id)
4495                  ->  Nested Loop
4496                        ->  Index Only Scan using t2_pkey on t2 t2_2
4497                        ->  Index Only Scan using t1_pkey on t1 t1_2
4498                              Index Cond: (id = t2_2.id)
4499                  ->  Sort
4500                        Sort Key: t3_2.id
4501                        ->  Seq Scan on t3 t3_2
4502    InitPlan 3 (returns $5)
4503      ->  Aggregate
4504            ->  Merge Join
4505                  Merge Cond: (t1_4.id = t3_4.id)
4506                  ->  Nested Loop
4507                        ->  Index Only Scan using t2_pkey on t2 t2_4
4508                        ->  Index Only Scan using t1_pkey on t1 t1_4
4509                              Index Cond: (id = t2_4.id)
4510                  ->  Sort
4511                        Sort Key: t3_4.id
4512                        ->  Seq Scan on t3 t3_4
4513    ->  Nested Loop
4514          ->  Nested Loop
4515                ->  Nested Loop
4516                      ->  Nested Loop
4517                            ->  Nested Loop
4518                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4519                                        Index Cond: (id = $5)
4520                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4521                                        Index Cond: (id = $5)
4522                            ->  Seq Scan on t3 t3_1
4523                                  Filter: (id = $5)
4524                      ->  Index Only Scan using t1_pkey on t1 t1_3
4525                            Index Cond: (id = $5)
4526                ->  Index Only Scan using t2_pkey on t2 t2_3
4527                      Index Cond: (id = $5)
4528          ->  Seq Scan on t3 t3_3
4529                Filter: (id = $5)
4530    ->  CTE Scan on c1_1
4531          Filter: (id = $5)
4532 (53 rows)
4533
4534 /*+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)*/
4535 EXPLAIN (COSTS false)
4536 WITH c1_1(id) AS (
4537 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
4538 )
4539 SELECT t1_1.id, (
4540 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
4541 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4542 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
4543 ) 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 = (
4544 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
4545 );
4546 LOG:  pg_hint_plan:
4547 used hint:
4548 HashJoin(t1_1 t3_1)
4549 NestLoop(t1_2 t2_2)
4550 MergeJoin(t1_3 t3_3)
4551 NestLoop(t1_4 t2_4)
4552 NestLoop(t1_5 t2_5)
4553 not used hint:
4554 Leading(a t1_1 t1_2 t1_4 t1_5)
4555 duplication hint:
4556 error hint:
4557
4558                                   QUERY PLAN
4559 ------------------------------------------------------------------------------
4560  Nested Loop
4561    CTE c1_1
4562      ->  Aggregate
4563            ->  Merge Join
4564                  Merge Cond: (t1_5.id = t3_5.id)
4565                  ->  Nested Loop
4566                        ->  Index Only Scan using t2_pkey on t2 t2_5
4567                        ->  Index Only Scan using t1_pkey on t1 t1_5
4568                              Index Cond: (id = t2_5.id)
4569                  ->  Sort
4570                        Sort Key: t3_5.id
4571                        ->  Seq Scan on t3 t3_5
4572    InitPlan 2 (returns $3)
4573      ->  Aggregate
4574            ->  Merge Join
4575                  Merge Cond: (t1_2.id = t3_2.id)
4576                  ->  Nested Loop
4577                        ->  Index Only Scan using t2_pkey on t2 t2_2
4578                        ->  Index Only Scan using t1_pkey on t1 t1_2
4579                              Index Cond: (id = t2_2.id)
4580                  ->  Sort
4581                        Sort Key: t3_2.id
4582                        ->  Seq Scan on t3 t3_2
4583    InitPlan 3 (returns $5)
4584      ->  Aggregate
4585            ->  Merge Join
4586                  Merge Cond: (t1_4.id = t3_4.id)
4587                  ->  Nested Loop
4588                        ->  Index Only Scan using t2_pkey on t2 t2_4
4589                        ->  Index Only Scan using t1_pkey on t1 t1_4
4590                              Index Cond: (id = t2_4.id)
4591                  ->  Sort
4592                        Sort Key: t3_4.id
4593                        ->  Seq Scan on t3 t3_4
4594    ->  Nested Loop
4595          ->  Nested Loop
4596                ->  Nested Loop
4597                      ->  Nested Loop
4598                            ->  Nested Loop
4599                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4600                                        Index Cond: (id = $5)
4601                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4602                                        Index Cond: (id = $5)
4603                            ->  Seq Scan on t3 t3_1
4604                                  Filter: (id = $5)
4605                      ->  Index Only Scan using t1_pkey on t1 t1_3
4606                            Index Cond: (id = $5)
4607                ->  Index Only Scan using t2_pkey on t2 t2_3
4608                      Index Cond: (id = $5)
4609          ->  Seq Scan on t3 t3_3
4610                Filter: (id = $5)
4611    ->  CTE Scan on c1_1
4612          Filter: (id = $5)
4613 (53 rows)
4614
4615 /*+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)*/
4616 EXPLAIN (COSTS false)
4617 WITH c1_1(id) AS (
4618 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
4619 )
4620 SELECT t1_1.id, (
4621 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
4622 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4623 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
4624 ) 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 = (
4625 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
4626 );
4627 LOG:  pg_hint_plan:
4628 used hint:
4629 HashJoin(t1_1 t3_1)
4630 NestLoop(t1_2 t2_2)
4631 MergeJoin(t1_3 t3_3)
4632 NestLoop(t1_4 t2_4)
4633 NestLoop(t1_5 t2_5)
4634 not used hint:
4635 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)
4636 duplication hint:
4637 error hint:
4638
4639                                   QUERY PLAN
4640 ------------------------------------------------------------------------------
4641  Nested Loop
4642    CTE c1_1
4643      ->  Aggregate
4644            ->  Merge Join
4645                  Merge Cond: (t1_5.id = t3_5.id)
4646                  ->  Nested Loop
4647                        ->  Index Only Scan using t2_pkey on t2 t2_5
4648                        ->  Index Only Scan using t1_pkey on t1 t1_5
4649                              Index Cond: (id = t2_5.id)
4650                  ->  Sort
4651                        Sort Key: t3_5.id
4652                        ->  Seq Scan on t3 t3_5
4653    InitPlan 2 (returns $3)
4654      ->  Aggregate
4655            ->  Merge Join
4656                  Merge Cond: (t1_2.id = t3_2.id)
4657                  ->  Nested Loop
4658                        ->  Index Only Scan using t2_pkey on t2 t2_2
4659                        ->  Index Only Scan using t1_pkey on t1 t1_2
4660                              Index Cond: (id = t2_2.id)
4661                  ->  Sort
4662                        Sort Key: t3_2.id
4663                        ->  Seq Scan on t3 t3_2
4664    InitPlan 3 (returns $5)
4665      ->  Aggregate
4666            ->  Merge Join
4667                  Merge Cond: (t1_4.id = t3_4.id)
4668                  ->  Nested Loop
4669                        ->  Index Only Scan using t2_pkey on t2 t2_4
4670                        ->  Index Only Scan using t1_pkey on t1 t1_4
4671                              Index Cond: (id = t2_4.id)
4672                  ->  Sort
4673                        Sort Key: t3_4.id
4674                        ->  Seq Scan on t3 t3_4
4675    ->  Nested Loop
4676          ->  Nested Loop
4677                ->  Nested Loop
4678                      ->  Nested Loop
4679                            ->  Nested Loop
4680                                  ->  Index Only Scan using t1_pkey on t1 t1_1
4681                                        Index Cond: (id = $5)
4682                                  ->  Index Only Scan using t2_pkey on t2 t2_1
4683                                        Index Cond: (id = $5)
4684                            ->  Seq Scan on t3 t3_1
4685                                  Filter: (id = $5)
4686                      ->  Index Only Scan using t1_pkey on t1 t1_3
4687                            Index Cond: (id = $5)
4688                ->  Index Only Scan using t2_pkey on t2 t2_3
4689                      Index Cond: (id = $5)
4690          ->  Seq Scan on t3 t3_3
4691                Filter: (id = $5)
4692    ->  CTE Scan on c1_1
4693          Filter: (id = $5)
4694 (53 rows)
4695
4696 /*+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)*/
4697 EXPLAIN (COSTS false)
4698 WITH c1_1(id) AS (
4699 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
4700 )
4701 SELECT t1_1.id, (
4702 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
4703 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4704 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
4705 ) 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 = (
4706 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
4707 );
4708 LOG:  pg_hint_plan:
4709 used hint:
4710 Leading(t3_5 t2_5 t1_5)
4711 Leading(t3_2 t2_2 t1_2)
4712 Leading(t3_4 t2_4 t1_4)
4713 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
4714 not used hint:
4715 HashJoin(t1_1 t3_1)
4716 NestLoop(t1_2 t2_2)
4717 MergeJoin(t1_3 t3_3)
4718 NestLoop(t1_4 t2_4)
4719 NestLoop(t1_5 t2_5)
4720 duplication hint:
4721 error hint:
4722
4723                                QUERY PLAN
4724 ------------------------------------------------------------------------
4725  Nested Loop
4726    CTE c1_1
4727      ->  Aggregate
4728            ->  Merge Join
4729                  Merge Cond: (t2_5.id = t1_5.id)
4730                  ->  Merge Join
4731                        Merge Cond: (t2_5.id = t3_5.id)
4732                        ->  Index Only Scan using t2_pkey on t2 t2_5
4733                        ->  Sort
4734                              Sort Key: t3_5.id
4735                              ->  Seq Scan on t3 t3_5
4736                  ->  Index Only Scan using t1_pkey on t1 t1_5
4737    InitPlan 2 (returns $1)
4738      ->  Aggregate
4739            ->  Merge Join
4740                  Merge Cond: (t2_2.id = t1_2.id)
4741                  ->  Merge Join
4742                        Merge Cond: (t2_2.id = t3_2.id)
4743                        ->  Index Only Scan using t2_pkey on t2 t2_2
4744                        ->  Sort
4745                              Sort Key: t3_2.id
4746                              ->  Seq Scan on t3 t3_2
4747                  ->  Index Only Scan using t1_pkey on t1 t1_2
4748    InitPlan 3 (returns $2)
4749      ->  Aggregate
4750            ->  Merge Join
4751                  Merge Cond: (t2_4.id = t1_4.id)
4752                  ->  Merge Join
4753                        Merge Cond: (t2_4.id = t3_4.id)
4754                        ->  Index Only Scan using t2_pkey on t2 t2_4
4755                        ->  Sort
4756                              Sort Key: t3_4.id
4757                              ->  Seq Scan on t3 t3_4
4758                  ->  Index Only Scan using t1_pkey on t1 t1_4
4759    ->  Nested Loop
4760          ->  Nested Loop
4761                ->  Nested Loop
4762                      ->  Nested Loop
4763                            ->  Nested Loop
4764                                  ->  Seq Scan on t3 t3_3
4765                                        Filter: (id = $2)
4766                                  ->  CTE Scan on c1_1
4767                                        Filter: (id = $2)
4768                            ->  Index Only Scan using t2_pkey on t2 t2_3
4769                                  Index Cond: (id = $2)
4770                      ->  Index Only Scan using t1_pkey on t1 t1_3
4771                            Index Cond: (id = $2)
4772                ->  Seq Scan on t3 t3_1
4773                      Filter: (id = $2)
4774          ->  Index Only Scan using t2_pkey on t2 t2_1
4775                Index Cond: (id = $2)
4776    ->  Index Only Scan using t1_pkey on t1 t1_1
4777          Index Cond: (id = $2)
4778 (53 rows)
4779
4780 SET from_collapse_limit TO 1;
4781 EXPLAIN (COSTS false)
4782 WITH c1_1(id) AS (
4783 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
4784 )
4785 SELECT t1_1.id, (
4786 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
4787 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4788 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
4789 ) 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 = (
4790 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
4791 );
4792                              QUERY PLAN
4793 --------------------------------------------------------------------
4794  Nested Loop
4795    CTE c1_1
4796      ->  Aggregate
4797            ->  Merge Join
4798                  Merge Cond: (t1_5.id = t3_5.id)
4799                  ->  Merge Join
4800                        Merge Cond: (t1_5.id = t2_5.id)
4801                        ->  Index Only Scan using t1_pkey on t1 t1_5
4802                        ->  Index Only Scan using t2_pkey on t2 t2_5
4803                  ->  Sort
4804                        Sort Key: t3_5.id
4805                        ->  Seq Scan on t3 t3_5
4806    InitPlan 2 (returns $1)
4807      ->  Aggregate
4808            ->  Merge Join
4809                  Merge Cond: (t1_2.id = t3_2.id)
4810                  ->  Merge Join
4811                        Merge Cond: (t1_2.id = t2_2.id)
4812                        ->  Index Only Scan using t1_pkey on t1 t1_2
4813                        ->  Index Only Scan using t2_pkey on t2 t2_2
4814                  ->  Sort
4815                        Sort Key: t3_2.id
4816                        ->  Seq Scan on t3 t3_2
4817    InitPlan 3 (returns $2)
4818      ->  Aggregate
4819            ->  Merge Join
4820                  Merge Cond: (t1_4.id = t3_4.id)
4821                  ->  Merge Join
4822                        Merge Cond: (t1_4.id = t2_4.id)
4823                        ->  Index Only Scan using t1_pkey on t1 t1_4
4824                        ->  Index Only Scan using t2_pkey on t2 t2_4
4825                  ->  Sort
4826                        Sort Key: t3_4.id
4827                        ->  Seq Scan on t3 t3_4
4828    ->  Nested Loop
4829          ->  Nested Loop
4830                ->  Nested Loop
4831                      ->  Index Only Scan using t1_pkey on t1 t1_1
4832                            Index Cond: (id = $2)
4833                      ->  Index Only Scan using t2_pkey on t2 t2_1
4834                            Index Cond: (id = $2)
4835                ->  Seq Scan on t3 t3_1
4836                      Filter: (id = $2)
4837          ->  Nested Loop
4838                ->  Nested Loop
4839                      ->  Index Only Scan using t1_pkey on t1 t1_3
4840                            Index Cond: (id = $2)
4841                      ->  Index Only Scan using t2_pkey on t2 t2_3
4842                            Index Cond: (id = $2)
4843                ->  Seq Scan on t3 t3_3
4844                      Filter: (id = $2)
4845    ->  CTE Scan on c1_1
4846          Filter: (id = $2)
4847 (53 rows)
4848
4849 /*+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)*/
4850 EXPLAIN (COSTS false)
4851 WITH c1_1(id) AS (
4852 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
4853 )
4854 SELECT t1_1.id, (
4855 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
4856 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4857 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
4858 ) 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 = (
4859 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
4860 );
4861 LOG:  pg_hint_plan:
4862 used hint:
4863 HashJoin(t1_1 t3_1)
4864 NestLoop(t1_2 t2_2)
4865 MergeJoin(t1_3 t3_3)
4866 NestLoop(t1_4 t2_4)
4867 NestLoop(t1_5 t2_5)
4868 not used hint:
4869 duplication hint:
4870 error hint:
4871
4872                              QUERY PLAN
4873 --------------------------------------------------------------------
4874  Nested Loop
4875    CTE c1_1
4876      ->  Aggregate
4877            ->  Merge Join
4878                  Merge Cond: (t1_5.id = t3_5.id)
4879                  ->  Nested Loop
4880                        ->  Index Only Scan using t2_pkey on t2 t2_5
4881                        ->  Index Only Scan using t1_pkey on t1 t1_5
4882                              Index Cond: (id = t2_5.id)
4883                  ->  Sort
4884                        Sort Key: t3_5.id
4885                        ->  Seq Scan on t3 t3_5
4886    InitPlan 2 (returns $3)
4887      ->  Aggregate
4888            ->  Merge Join
4889                  Merge Cond: (t1_2.id = t3_2.id)
4890                  ->  Nested Loop
4891                        ->  Index Only Scan using t2_pkey on t2 t2_2
4892                        ->  Index Only Scan using t1_pkey on t1 t1_2
4893                              Index Cond: (id = t2_2.id)
4894                  ->  Sort
4895                        Sort Key: t3_2.id
4896                        ->  Seq Scan on t3 t3_2
4897    InitPlan 3 (returns $5)
4898      ->  Aggregate
4899            ->  Merge Join
4900                  Merge Cond: (t1_4.id = t3_4.id)
4901                  ->  Nested Loop
4902                        ->  Index Only Scan using t2_pkey on t2 t2_4
4903                        ->  Index Only Scan using t1_pkey on t1 t1_4
4904                              Index Cond: (id = t2_4.id)
4905                  ->  Sort
4906                        Sort Key: t3_4.id
4907                        ->  Seq Scan on t3 t3_4
4908    ->  Nested Loop
4909          ->  Nested Loop
4910                ->  Nested Loop
4911                      ->  Index Only Scan using t1_pkey on t1 t1_1
4912                            Index Cond: (id = $5)
4913                      ->  Index Only Scan using t2_pkey on t2 t2_1
4914                            Index Cond: (id = $5)
4915                ->  Seq Scan on t3 t3_1
4916                      Filter: (id = $5)
4917          ->  Nested Loop
4918                ->  Nested Loop
4919                      ->  Index Only Scan using t1_pkey on t1 t1_3
4920                            Index Cond: (id = $5)
4921                      ->  Index Only Scan using t2_pkey on t2 t2_3
4922                            Index Cond: (id = $5)
4923                ->  Seq Scan on t3 t3_3
4924                      Filter: (id = $5)
4925    ->  CTE Scan on c1_1
4926          Filter: (id = $5)
4927 (53 rows)
4928
4929 /*+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)*/
4930 EXPLAIN (COSTS false)
4931 WITH c1_1(id) AS (
4932 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
4933 )
4934 SELECT t1_1.id, (
4935 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
4936 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
4937 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
4938 ) 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 = (
4939 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
4940 );
4941 LOG:  pg_hint_plan:
4942 used hint:
4943 HashJoin(t1_1 t3_1)
4944 NestLoop(t1_2 t2_2)
4945 MergeJoin(t1_3 t3_3)
4946 NestLoop(t1_4 t2_4)
4947 NestLoop(t1_5 t2_5)
4948 not used hint:
4949 Leading(a t1_1 t1_2 t1_4 t1_5)
4950 duplication hint:
4951 error hint:
4952
4953                              QUERY PLAN
4954 --------------------------------------------------------------------
4955  Nested Loop
4956    CTE c1_1
4957      ->  Aggregate
4958            ->  Merge Join
4959                  Merge Cond: (t1_5.id = t3_5.id)
4960                  ->  Nested Loop
4961                        ->  Index Only Scan using t2_pkey on t2 t2_5
4962                        ->  Index Only Scan using t1_pkey on t1 t1_5
4963                              Index Cond: (id = t2_5.id)
4964                  ->  Sort
4965                        Sort Key: t3_5.id
4966                        ->  Seq Scan on t3 t3_5
4967    InitPlan 2 (returns $3)
4968      ->  Aggregate
4969            ->  Merge Join
4970                  Merge Cond: (t1_2.id = t3_2.id)
4971                  ->  Nested Loop
4972                        ->  Index Only Scan using t2_pkey on t2 t2_2
4973                        ->  Index Only Scan using t1_pkey on t1 t1_2
4974                              Index Cond: (id = t2_2.id)
4975                  ->  Sort
4976                        Sort Key: t3_2.id
4977                        ->  Seq Scan on t3 t3_2
4978    InitPlan 3 (returns $5)
4979      ->  Aggregate
4980            ->  Merge Join
4981                  Merge Cond: (t1_4.id = t3_4.id)
4982                  ->  Nested Loop
4983                        ->  Index Only Scan using t2_pkey on t2 t2_4
4984                        ->  Index Only Scan using t1_pkey on t1 t1_4
4985                              Index Cond: (id = t2_4.id)
4986                  ->  Sort
4987                        Sort Key: t3_4.id
4988                        ->  Seq Scan on t3 t3_4
4989    ->  Nested Loop
4990          ->  Nested Loop
4991                ->  Nested Loop
4992                      ->  Index Only Scan using t1_pkey on t1 t1_1
4993                            Index Cond: (id = $5)
4994                      ->  Index Only Scan using t2_pkey on t2 t2_1
4995                            Index Cond: (id = $5)
4996                ->  Seq Scan on t3 t3_1
4997                      Filter: (id = $5)
4998          ->  Nested Loop
4999                ->  Nested Loop
5000                      ->  Index Only Scan using t1_pkey on t1 t1_3
5001                            Index Cond: (id = $5)
5002                      ->  Index Only Scan using t2_pkey on t2 t2_3
5003                            Index Cond: (id = $5)
5004                ->  Seq Scan on t3 t3_3
5005                      Filter: (id = $5)
5006    ->  CTE Scan on c1_1
5007          Filter: (id = $5)
5008 (53 rows)
5009
5010 /*+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)*/
5011 EXPLAIN (COSTS false)
5012 WITH c1_1(id) AS (
5013 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
5014 )
5015 SELECT t1_1.id, (
5016 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
5017 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5018 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
5019 ) 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 = (
5020 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
5021 );
5022 LOG:  pg_hint_plan:
5023 used hint:
5024 HashJoin(t1_1 t3_1)
5025 NestLoop(t1_2 t2_2)
5026 MergeJoin(t1_3 t3_3)
5027 NestLoop(t1_4 t2_4)
5028 NestLoop(t1_5 t2_5)
5029 not used hint:
5030 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)
5031 duplication hint:
5032 error hint:
5033
5034                              QUERY PLAN
5035 --------------------------------------------------------------------
5036  Nested Loop
5037    CTE c1_1
5038      ->  Aggregate
5039            ->  Merge Join
5040                  Merge Cond: (t1_5.id = t3_5.id)
5041                  ->  Nested Loop
5042                        ->  Index Only Scan using t2_pkey on t2 t2_5
5043                        ->  Index Only Scan using t1_pkey on t1 t1_5
5044                              Index Cond: (id = t2_5.id)
5045                  ->  Sort
5046                        Sort Key: t3_5.id
5047                        ->  Seq Scan on t3 t3_5
5048    InitPlan 2 (returns $3)
5049      ->  Aggregate
5050            ->  Merge Join
5051                  Merge Cond: (t1_2.id = t3_2.id)
5052                  ->  Nested Loop
5053                        ->  Index Only Scan using t2_pkey on t2 t2_2
5054                        ->  Index Only Scan using t1_pkey on t1 t1_2
5055                              Index Cond: (id = t2_2.id)
5056                  ->  Sort
5057                        Sort Key: t3_2.id
5058                        ->  Seq Scan on t3 t3_2
5059    InitPlan 3 (returns $5)
5060      ->  Aggregate
5061            ->  Merge Join
5062                  Merge Cond: (t1_4.id = t3_4.id)
5063                  ->  Nested Loop
5064                        ->  Index Only Scan using t2_pkey on t2 t2_4
5065                        ->  Index Only Scan using t1_pkey on t1 t1_4
5066                              Index Cond: (id = t2_4.id)
5067                  ->  Sort
5068                        Sort Key: t3_4.id
5069                        ->  Seq Scan on t3 t3_4
5070    ->  Nested Loop
5071          ->  Nested Loop
5072                ->  Nested Loop
5073                      ->  Index Only Scan using t1_pkey on t1 t1_1
5074                            Index Cond: (id = $5)
5075                      ->  Index Only Scan using t2_pkey on t2 t2_1
5076                            Index Cond: (id = $5)
5077                ->  Seq Scan on t3 t3_1
5078                      Filter: (id = $5)
5079          ->  Nested Loop
5080                ->  Nested Loop
5081                      ->  Index Only Scan using t1_pkey on t1 t1_3
5082                            Index Cond: (id = $5)
5083                      ->  Index Only Scan using t2_pkey on t2 t2_3
5084                            Index Cond: (id = $5)
5085                ->  Seq Scan on t3 t3_3
5086                      Filter: (id = $5)
5087    ->  CTE Scan on c1_1
5088          Filter: (id = $5)
5089 (53 rows)
5090
5091 /*+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)*/
5092 EXPLAIN (COSTS false)
5093 WITH c1_1(id) AS (
5094 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
5095 )
5096 SELECT t1_1.id, (
5097 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
5098 ) FROM t1 t1_1, t2 t2_1, t3 t3_1, (
5099 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
5100 ) 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 = (
5101 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
5102 );
5103 LOG:  pg_hint_plan:
5104 used hint:
5105 MergeJoin(t1_3 t3_3)
5106 Leading(t3_5 t2_5 t1_5)
5107 Leading(t3_2 t2_2 t1_2)
5108 Leading(t3_4 t2_4 t1_4)
5109 Leading(c1_1 t3_3 t2_3 t1_3 t3_1 t2_1 t1_1)
5110 not used hint:
5111 HashJoin(t1_1 t3_1)
5112 NestLoop(t1_2 t2_2)
5113 NestLoop(t1_4 t2_4)
5114 NestLoop(t1_5 t2_5)
5115 duplication hint:
5116 error hint:
5117
5118                                   QUERY PLAN
5119 ------------------------------------------------------------------------------
5120  Nested Loop
5121    CTE c1_1
5122      ->  Aggregate
5123            ->  Merge Join
5124                  Merge Cond: (t2_5.id = t1_5.id)
5125                  ->  Merge Join
5126                        Merge Cond: (t2_5.id = t3_5.id)
5127                        ->  Index Only Scan using t2_pkey on t2 t2_5
5128                        ->  Sort
5129                              Sort Key: t3_5.id
5130                              ->  Seq Scan on t3 t3_5
5131                  ->  Index Only Scan using t1_pkey on t1 t1_5
5132    InitPlan 2 (returns $1)
5133      ->  Aggregate
5134            ->  Merge Join
5135                  Merge Cond: (t2_2.id = t1_2.id)
5136                  ->  Merge Join
5137                        Merge Cond: (t2_2.id = t3_2.id)
5138                        ->  Index Only Scan using t2_pkey on t2 t2_2
5139                        ->  Sort
5140                              Sort Key: t3_2.id
5141                              ->  Seq Scan on t3 t3_2
5142                  ->  Index Only Scan using t1_pkey on t1 t1_2
5143    InitPlan 3 (returns $2)
5144      ->  Aggregate
5145            ->  Merge Join
5146                  Merge Cond: (t2_4.id = t1_4.id)
5147                  ->  Merge Join
5148                        Merge Cond: (t2_4.id = t3_4.id)
5149                        ->  Index Only Scan using t2_pkey on t2 t2_4
5150                        ->  Sort
5151                              Sort Key: t3_4.id
5152                              ->  Seq Scan on t3 t3_4
5153                  ->  Index Only Scan using t1_pkey on t1 t1_4
5154    ->  Nested Loop
5155          ->  Nested Loop
5156                ->  Nested Loop
5157                      ->  Nested Loop
5158                            ->  Nested Loop
5159                                  ->  Index Only Scan using t1_pkey on t1 t1_3
5160                                        Index Cond: (id = $2)
5161                                  ->  Index Only Scan using t2_pkey on t2 t2_3
5162                                        Index Cond: (id = $2)
5163                            ->  Seq Scan on t3 t3_3
5164                                  Filter: (id = $2)
5165                      ->  CTE Scan on c1_1
5166                            Filter: (id = $2)
5167                ->  Seq Scan on t3 t3_1
5168                      Filter: (id = $2)
5169          ->  Index Only Scan using t2_pkey on t2 t2_1
5170                Index Cond: (id = $2)
5171    ->  Index Only Scan using t1_pkey on t1 t1_1
5172          Index Cond: (id = $2)
5173 (53 rows)
5174
5175 -- ambigous error
5176 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5177                   QUERY PLAN
5178 -----------------------------------------------
5179  Merge Join
5180    Merge Cond: (public.t1.id = t2.id)
5181    ->  Merge Join
5182          Merge Cond: (public.t1.id = s0.t1.id)
5183          ->  Index Scan using t1_pkey on t1
5184          ->  Index Scan using t1_pkey on t1
5185    ->  Index Scan using t2_pkey on t2
5186 (7 rows)
5187
5188 /*+NestLoop(t1 t2)*/
5189 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5190 INFO:  hint syntax error at or near "NestLoop(t1 t2)"
5191 DETAIL:  Relation name "t1" is ambiguous.
5192 LOG:  pg_hint_plan:
5193 used hint:
5194 not used hint:
5195 duplication hint:
5196 error hint:
5197 NestLoop(t1 t2)
5198
5199                   QUERY PLAN
5200 -----------------------------------------------
5201  Merge Join
5202    Merge Cond: (public.t1.id = t2.id)
5203    ->  Merge Join
5204          Merge Cond: (public.t1.id = s0.t1.id)
5205          ->  Index Scan using t1_pkey on t1
5206          ->  Index Scan using t1_pkey on t1
5207    ->  Index Scan using t2_pkey on t2
5208 (7 rows)
5209
5210 /*+Leading(t1 t2 t1)*/
5211 EXPLAIN (COSTS false) SELECT * FROM t1, s0.t1, t2 WHERE public.t1.id = s0.t1.id AND public.t1.id = t2.id;
5212 INFO:  hint syntax error at or near "Leading(t1 t2 t1)"
5213 DETAIL:  Relation name "t1" is ambiguous.
5214 LOG:  pg_hint_plan:
5215 used hint:
5216 not used hint:
5217 duplication hint:
5218 error hint:
5219 Leading(t1 t2 t1)
5220
5221                   QUERY PLAN
5222 -----------------------------------------------
5223  Merge Join
5224    Merge Cond: (public.t1.id = t2.id)
5225    ->  Merge Join
5226          Merge Cond: (public.t1.id = s0.t1.id)
5227          ->  Index Scan using t1_pkey on t1
5228          ->  Index Scan using t1_pkey on t1
5229    ->  Index Scan using t2_pkey on t2
5230 (7 rows)
5231
5232 -- identifier length test
5233 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5234                                                   QUERY PLAN
5235 --------------------------------------------------------------------------------------------------------------
5236  Merge Join
5237    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5238    ->  Merge Join
5239          Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id)
5240          ->  Index Scan using t1_pkey on t1 "123456789012345678901234567890123456789012345678901234567890123"
5241          ->  Index Scan using t2_pkey on t2
5242    ->  Sort
5243          Sort Key: t3.id
5244          ->  Seq Scan on t3
5245 (9 rows)
5246
5247 /*+
5248 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5249 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5250 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5251 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5252 */
5253 EXPLAIN (COSTS false) SELECT * FROM t1 "123456789012345678901234567890123456789012345678901234567890123" JOIN t2 ON ("123456789012345678901234567890123456789012345678901234567890123".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5254 INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5255 LOG:  pg_hint_plan:
5256 used hint:
5257 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5258 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5259 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5260 not used hint:
5261 duplication hint:
5262 error hint:
5263 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5264
5265                                              QUERY PLAN
5266 ----------------------------------------------------------------------------------------------------
5267  Merge Join
5268    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5269    ->  Merge Join
5270          Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5271          ->  Index Scan using t2_pkey on t2
5272          ->  Sort
5273                Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5274                ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5275    ->  Sort
5276          Sort Key: t3.id
5277          ->  Seq Scan on t3
5278 (11 rows)
5279
5280 /*+
5281 Leading(1234567890123456789012345678901234567890123456789012345678901234 t2 t3)
5282 SeqScan(1234567890123456789012345678901234567890123456789012345678901234)
5283 MergeJoin(1234567890123456789012345678901234567890123456789012345678901234 t2)
5284 Set(1234567890123456789012345678901234567890123456789012345678901234 1)
5285 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5286 */
5287 EXPLAIN (COSTS false) SELECT * FROM t1 "1234567890123456789012345678901234567890123456789012345678901234" JOIN t2 ON ("1234567890123456789012345678901234567890123456789012345678901234".id = t2.id) JOIN t3 ON (t2.id = t3.id);
5288 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5289 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5290 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5291 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5292 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5293 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5294 INFO:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5295 LOG:  pg_hint_plan:
5296 used hint:
5297 SeqScan(123456789012345678901234567890123456789012345678901234567890123)
5298 MergeJoin(123456789012345678901234567890123456789012345678901234567890123 t2)
5299 Leading(123456789012345678901234567890123456789012345678901234567890123 t2 t3)
5300 Set(cursor_tuple_fraction 0.1234567890123456789012345678901234567890123456789012345678901234)
5301 not used hint:
5302 duplication hint:
5303 error hint:
5304 Set(123456789012345678901234567890123456789012345678901234567890123 1)
5305
5306                                              QUERY PLAN
5307 ----------------------------------------------------------------------------------------------------
5308  Merge Join
5309    Merge Cond: ("123456789012345678901234567890123456789012345678901234567890123".id = t3.id)
5310    ->  Merge Join
5311          Merge Cond: (t2.id = "123456789012345678901234567890123456789012345678901234567890123".id)
5312          ->  Index Scan using t2_pkey on t2
5313          ->  Sort
5314                Sort Key: "123456789012345678901234567890123456789012345678901234567890123".id
5315                ->  Seq Scan on t1 "123456789012345678901234567890123456789012345678901234567890123"
5316    ->  Sort
5317          Sort Key: t3.id
5318          ->  Seq Scan on t3
5319 (11 rows)
5320
5321 SET "123456789012345678901234567890123456789012345678901234567890123" TO 1;
5322 ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5323 SET "1234567890123456789012345678901234567890123456789012345678901234" TO 1;
5324 NOTICE:  identifier "1234567890123456789012345678901234567890123456789012345678901234" will be truncated to "123456789012345678901234567890123456789012345678901234567890123"
5325 ERROR:  unrecognized configuration parameter "123456789012345678901234567890123456789012345678901234567890123"
5326 SET cursor_tuple_fraction TO 1234567890123456789012345678901234567890123456789012345678901234;
5327 ERROR:  1.23457e+63 is outside the valid range for parameter "cursor_tuple_fraction" (0 .. 1)
5328 -- multi error
5329 /*+ Set(enable_seqscan 100)Set(seq_page_cost on)*/
5330 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id;
5331 INFO:  parameter "enable_seqscan" requires a Boolean value
5332 INFO:  parameter "seq_page_cost" requires a numeric value
5333 LOG:  pg_hint_plan:
5334 used hint:
5335 not used hint:
5336 duplication hint:
5337 error hint:
5338 Set(enable_seqscan 100)
5339 Set(seq_page_cost on)
5340
5341               QUERY PLAN
5342 --------------------------------------
5343  Merge Join
5344    Merge Cond: (t1.id = t2.id)
5345    ->  Index Scan using t1_pkey on t1
5346    ->  Index Scan using t2_pkey on t2
5347 (4 rows)
5348
5349 -- debug log of candidate index to use IndexScan
5350 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5351                                        QUERY PLAN
5352 ----------------------------------------------------------------------------------------
5353  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
5354    Index Cond: (id = 1)
5355 (2 rows)
5356
5357 /*+IndexScan(t5 t5_id2)*/
5358 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5359 LOG:  available indexes for IndexScan(t5): t5_id2
5360 LOG:  pg_hint_plan:
5361 used hint:
5362 IndexScan(t5 t5_id2)
5363 not used hint:
5364 duplication hint:
5365 error hint:
5366
5367           QUERY PLAN
5368 -------------------------------
5369  Index Scan using t5_id2 on t5
5370    Index Cond: (id = 1)
5371 (2 rows)
5372
5373 /*+IndexScan(t5 no_exist)*/
5374 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5375 LOG:  available indexes for IndexScan(t5):
5376 LOG:  pg_hint_plan:
5377 used hint:
5378 IndexScan(t5 no_exist)
5379 not used hint:
5380 duplication hint:
5381 error hint:
5382
5383      QUERY PLAN
5384 --------------------
5385  Seq Scan on t5
5386    Filter: (id = 1)
5387 (2 rows)
5388
5389 /*+IndexScan(t5 t5_id1 t5_id2)*/
5390 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5391 LOG:  available indexes for IndexScan(t5): t5_id2 t5_id1
5392 LOG:  pg_hint_plan:
5393 used hint:
5394 IndexScan(t5 t5_id1 t5_id2)
5395 not used hint:
5396 duplication hint:
5397 error hint:
5398
5399           QUERY PLAN
5400 -------------------------------
5401  Index Scan using t5_id2 on t5
5402    Index Cond: (id = 1)
5403 (2 rows)
5404
5405 /*+IndexScan(t5 no_exist t5_id2)*/
5406 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5407 LOG:  available indexes for IndexScan(t5): t5_id2
5408 LOG:  pg_hint_plan:
5409 used hint:
5410 IndexScan(t5 no_exist t5_id2)
5411 not used hint:
5412 duplication hint:
5413 error hint:
5414
5415           QUERY PLAN
5416 -------------------------------
5417  Index Scan using t5_id2 on t5
5418    Index Cond: (id = 1)
5419 (2 rows)
5420
5421 /*+IndexScan(t5 no_exist5 no_exist2)*/
5422 EXPLAIN (COSTS false) SELECT * FROM t5 WHERE t5.id = 1;
5423 LOG:  available indexes for IndexScan(t5):
5424 LOG:  pg_hint_plan:
5425 used hint:
5426 IndexScan(t5 no_exist5 no_exist2)
5427 not used hint:
5428 duplication hint:
5429 error hint:
5430
5431      QUERY PLAN
5432 --------------------
5433  Seq Scan on t5
5434    Filter: (id = 1)
5435 (2 rows)
5436
5437 -- outer inner
5438 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5439                        QUERY PLAN
5440 --------------------------------------------------------
5441  Hash Join
5442    Hash Cond: (t3.val = t2.val)
5443    ->  Seq Scan on t3
5444    ->  Hash
5445          ->  Hash Join
5446                Hash Cond: (t2.id = t1.id)
5447                ->  Seq Scan on t2
5448                ->  Hash
5449                      ->  Index Scan using t1_pkey on t1
5450                            Index Cond: (id < 10)
5451 (10 rows)
5452
5453 /*+Leading((t1))*/
5454 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5455 INFO:  hint syntax error at or near "Leading((t1))"
5456 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
5457 LOG:  pg_hint_plan:
5458 used hint:
5459 not used hint:
5460 duplication hint:
5461 error hint:
5462 Leading((t1))
5463
5464                        QUERY PLAN
5465 --------------------------------------------------------
5466  Hash Join
5467    Hash Cond: (t3.val = t2.val)
5468    ->  Seq Scan on t3
5469    ->  Hash
5470          ->  Hash Join
5471                Hash Cond: (t2.id = t1.id)
5472                ->  Seq Scan on t2
5473                ->  Hash
5474                      ->  Index Scan using t1_pkey on t1
5475                            Index Cond: (id < 10)
5476 (10 rows)
5477
5478 /*+Leading((t1 t2))*/
5479 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5480 LOG:  pg_hint_plan:
5481 used hint:
5482 Leading((t1 t2))
5483 not used hint:
5484 duplication hint:
5485 error hint:
5486
5487                  QUERY PLAN
5488 --------------------------------------------
5489  Nested Loop
5490    Join Filter: (t2.val = t3.val)
5491    ->  Hash Join
5492          Hash Cond: (t1.id = t2.id)
5493          ->  Index Scan using t1_pkey on t1
5494                Index Cond: (id < 10)
5495          ->  Hash
5496                ->  Seq Scan on t2
5497    ->  Seq Scan on t3
5498 (9 rows)
5499
5500 /*+Leading((t1 t2 t3))*/
5501 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5502 INFO:  hint syntax error at or near "Leading((t1 t2 t3))"
5503 DETAIL:  Leading hint requires two sets of relations when parentheses nests.
5504 LOG:  pg_hint_plan:
5505 used hint:
5506 not used hint:
5507 duplication hint:
5508 error hint:
5509 Leading((t1 t2 t3))
5510
5511                        QUERY PLAN
5512 --------------------------------------------------------
5513  Hash Join
5514    Hash Cond: (t3.val = t2.val)
5515    ->  Seq Scan on t3
5516    ->  Hash
5517          ->  Hash Join
5518                Hash Cond: (t2.id = t1.id)
5519                ->  Seq Scan on t2
5520                ->  Hash
5521                      ->  Index Scan using t1_pkey on t1
5522                            Index Cond: (id < 10)
5523 (10 rows)
5524
5525 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5526                  QUERY PLAN
5527 --------------------------------------------
5528  Hash Join
5529    Hash Cond: (t2.id = t1.id)
5530    ->  Seq Scan on t2
5531    ->  Hash
5532          ->  Index Scan using t1_pkey on t1
5533                Index Cond: (id < 10)
5534 (6 rows)
5535
5536 /*+Leading((t1 t2))*/
5537 EXPLAIN (COSTS false) SELECT * FROM t1, t2 WHERE t1.id = t2.id AND t1.id < 10;
5538 LOG:  pg_hint_plan:
5539 used hint:
5540 Leading((t1 t2))
5541 not used hint:
5542 duplication hint:
5543 error hint:
5544
5545               QUERY PLAN
5546 --------------------------------------
5547  Hash Join
5548    Hash Cond: (t1.id = t2.id)
5549    ->  Index Scan using t1_pkey on t1
5550          Index Cond: (id < 10)
5551    ->  Hash
5552          ->  Seq Scan on t2
5553 (6 rows)
5554
5555 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5556                        QUERY PLAN
5557 --------------------------------------------------------
5558  Hash Join
5559    Hash Cond: (t3.val = t2.val)
5560    ->  Seq Scan on t3
5561    ->  Hash
5562          ->  Hash Join
5563                Hash Cond: (t2.id = t1.id)
5564                ->  Seq Scan on t2
5565                ->  Hash
5566                      ->  Index Scan using t1_pkey on t1
5567                            Index Cond: (id < 10)
5568 (10 rows)
5569
5570 /*+Leading(((t1 t2) t3))*/
5571 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5572 LOG:  pg_hint_plan:
5573 used hint:
5574 Leading(((t1 t2) t3))
5575 not used hint:
5576 duplication hint:
5577 error hint:
5578
5579                  QUERY PLAN
5580 --------------------------------------------
5581  Nested Loop
5582    Join Filter: (t2.val = t3.val)
5583    ->  Hash Join
5584          Hash Cond: (t1.id = t2.id)
5585          ->  Index Scan using t1_pkey on t1
5586                Index Cond: (id < 10)
5587          ->  Hash
5588                ->  Seq Scan on t2
5589    ->  Seq Scan on t3
5590 (9 rows)
5591
5592 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;
5593                        QUERY PLAN
5594 --------------------------------------------------------
5595  Nested Loop
5596    ->  Merge Join
5597          Merge Cond: (t3.id = t4.id)
5598          ->  Nested Loop
5599                Join Filter: (t1.val = t3.val)
5600                ->  Index Scan using t3_pkey on t3
5601                ->  Materialize
5602                      ->  Index Scan using t1_pkey on t1
5603                            Index Cond: (id < 10)
5604          ->  Sort
5605                Sort Key: t4.id
5606                ->  Seq Scan on t4
5607    ->  Index Scan using t2_pkey on t2
5608          Index Cond: (id = t1.id)
5609 (14 rows)
5610
5611 /*+Leading((((t1 t2) t3) t4))*/
5612 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;
5613 LOG:  pg_hint_plan:
5614 used hint:
5615 Leading((((t1 t2) t3) t4))
5616 not used hint:
5617 duplication hint:
5618 error hint:
5619
5620                     QUERY PLAN
5621 --------------------------------------------------
5622  Nested Loop
5623    ->  Nested Loop
5624          Join Filter: (t1.val = t3.val)
5625          ->  Hash Join
5626                Hash Cond: (t1.id = t2.id)
5627                ->  Index Scan using t1_pkey on t1
5628                      Index Cond: (id < 10)
5629                ->  Hash
5630                      ->  Seq Scan on t2
5631          ->  Seq Scan on t3
5632    ->  Index Scan using t4_pkey on t4
5633          Index Cond: (id = t3.id)
5634 (12 rows)
5635
5636 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5637                        QUERY PLAN
5638 --------------------------------------------------------
5639  Hash Join
5640    Hash Cond: (t3.val = t2.val)
5641    ->  Seq Scan on t3
5642    ->  Hash
5643          ->  Hash Join
5644                Hash Cond: (t2.id = t1.id)
5645                ->  Seq Scan on t2
5646                ->  Hash
5647                      ->  Index Scan using t1_pkey on t1
5648                            Index Cond: (id < 10)
5649 (10 rows)
5650
5651 /*+Leading(((t1 t2) t3))*/
5652 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5653 LOG:  pg_hint_plan:
5654 used hint:
5655 Leading(((t1 t2) t3))
5656 not used hint:
5657 duplication hint:
5658 error hint:
5659
5660                  QUERY PLAN
5661 --------------------------------------------
5662  Nested Loop
5663    Join Filter: (t2.val = t3.val)
5664    ->  Hash Join
5665          Hash Cond: (t1.id = t2.id)
5666          ->  Index Scan using t1_pkey on t1
5667                Index Cond: (id < 10)
5668          ->  Hash
5669                ->  Seq Scan on t2
5670    ->  Seq Scan on t3
5671 (9 rows)
5672
5673 /*+Leading((t1 (t2 t3)))*/
5674 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5675 LOG:  pg_hint_plan:
5676 used hint:
5677 Leading((t1 (t2 t3)))
5678 not used hint:
5679 duplication hint:
5680 error hint:
5681
5682                  QUERY PLAN
5683 --------------------------------------------
5684  Hash Join
5685    Hash Cond: (t1.id = t2.id)
5686    ->  Index Scan using t1_pkey on t1
5687          Index Cond: (id < 10)
5688    ->  Hash
5689          ->  Hash Join
5690                Hash Cond: (t2.val = t3.val)
5691                ->  Seq Scan on t2
5692                ->  Hash
5693                      ->  Seq Scan on t3
5694 (10 rows)
5695
5696 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;
5697                        QUERY PLAN
5698 --------------------------------------------------------
5699  Nested Loop
5700    ->  Merge Join
5701          Merge Cond: (t3.id = t4.id)
5702          ->  Nested Loop
5703                Join Filter: (t1.val = t3.val)
5704                ->  Index Scan using t3_pkey on t3
5705                ->  Materialize
5706                      ->  Index Scan using t1_pkey on t1
5707                            Index Cond: (id < 10)
5708          ->  Sort
5709                Sort Key: t4.id
5710                ->  Seq Scan on t4
5711    ->  Index Scan using t2_pkey on t2
5712          Index Cond: (id = t1.id)
5713 (14 rows)
5714
5715 /*+Leading(((t1 t2) (t3 t4)))*/
5716 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;
5717 LOG:  pg_hint_plan:
5718 used hint:
5719 Leading(((t1 t2) (t3 t4)))
5720 not used hint:
5721 duplication hint:
5722 error hint:
5723
5724                  QUERY PLAN
5725 --------------------------------------------
5726  Nested Loop
5727    Join Filter: (t1.val = t3.val)
5728    ->  Hash Join
5729          Hash Cond: (t1.id = t2.id)
5730          ->  Index Scan using t1_pkey on t1
5731                Index Cond: (id < 10)
5732          ->  Hash
5733                ->  Seq Scan on t2
5734    ->  Merge Join
5735          Merge Cond: (t3.id = t4.id)
5736          ->  Index Scan using t3_pkey on t3
5737          ->  Sort
5738                Sort Key: t4.id
5739                ->  Seq Scan on t4
5740 (14 rows)
5741
5742 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);
5743                              QUERY PLAN
5744 --------------------------------------------------------------------
5745  Hash Join
5746    Hash Cond: (t2.val = t3.val)
5747    InitPlan 1 (returns $1)
5748      ->  Limit
5749            ->  Sort
5750                  Sort Key: t1_2.id
5751                  ->  Nested Loop
5752                        ->  Index Scan using t2_val on t2 t2_2
5753                              Index Cond: (val > 100)
5754                        ->  Index Only Scan using t1_pkey on t1 t1_2
5755                              Index Cond: (id = t2_2.id)
5756    ->  Merge Join
5757          Merge Cond: (t1.id = t2.id)
5758          ->  Index Scan using t1_pkey on t1
5759                Index Cond: (id < $1)
5760          ->  Index Scan using t2_pkey on t2
5761    ->  Hash
5762          ->  Seq Scan on t3
5763 (18 rows)
5764
5765 /*+Leading(((t1 t2) t3)) Leading(((t3 t1) t2))*/
5766 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);
5767 INFO:  hint syntax error at or near "Leading(((t1 t2) t3)) Leading(((t3 t1) t2))"
5768 DETAIL:  Conflict leading hint.
5769 LOG:  pg_hint_plan:
5770 used hint:
5771 Leading(((t3 t1) t2))
5772 not used hint:
5773 duplication hint:
5774 Leading(((t1 t2) t3))
5775 error hint:
5776
5777                              QUERY PLAN
5778 --------------------------------------------------------------------
5779  Hash Join
5780    Hash Cond: (t1.id = t2.id)
5781    InitPlan 1 (returns $1)
5782      ->  Limit
5783            ->  Sort
5784                  Sort Key: t1_2.id
5785                  ->  Nested Loop
5786                        ->  Index Scan using t2_val on t2 t2_2
5787                              Index Cond: (val > 100)
5788                        ->  Index Only Scan using t1_pkey on t1 t1_2
5789                              Index Cond: (id = t2_2.id)
5790    ->  Hash Join
5791          Hash Cond: (t3.val = t1.val)
5792          ->  Seq Scan on t3
5793          ->  Hash
5794                ->  Index Scan using t1_pkey on t1
5795                      Index Cond: (id < $1)
5796    ->  Hash
5797          ->  Seq Scan on t2
5798 (19 rows)
5799
5800 /*+Leading(((t1 t2) t3)) Leading((t1_2 t2_2))*/
5801 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);
5802 LOG:  pg_hint_plan:
5803 used hint:
5804 Leading(((t1 t2) t3))
5805 Leading((t1_2 t2_2))
5806 not used hint:
5807 duplication hint:
5808 error hint:
5809
5810                           QUERY PLAN
5811 --------------------------------------------------------------
5812  Hash Join
5813    Hash Cond: (t2.val = t3.val)
5814    InitPlan 1 (returns $0)
5815      ->  Limit
5816            ->  Merge Join
5817                  Merge Cond: (t1_2.id = t2_2.id)
5818                  ->  Index Only Scan using t1_pkey on t1 t1_2
5819                  ->  Sort
5820                        Sort Key: t2_2.id
5821                        ->  Index Scan using t2_val on t2 t2_2
5822                              Index Cond: (val > 100)
5823    ->  Merge Join
5824          Merge Cond: (t1.id = t2.id)
5825          ->  Index Scan using t1_pkey on t1
5826                Index Cond: (id < $0)
5827          ->  Index Scan using t2_pkey on t2
5828    ->  Hash
5829          ->  Seq Scan on t3
5830 (18 rows)
5831
5832 /*+Leading(((((t1 t2) t3) t1_2) t2_2))*/
5833 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);
5834 LOG:  pg_hint_plan:
5835 used hint:
5836 not used hint:
5837 Leading(((((t1 t2) t3) t1_2) t2_2))
5838 duplication hint:
5839 error hint:
5840
5841                              QUERY PLAN
5842 --------------------------------------------------------------------
5843  Hash Join
5844    Hash Cond: (t2.val = t3.val)
5845    InitPlan 1 (returns $1)
5846      ->  Limit
5847            ->  Sort
5848                  Sort Key: t1_2.id
5849                  ->  Nested Loop
5850                        ->  Index Scan using t2_val on t2 t2_2
5851                              Index Cond: (val > 100)
5852                        ->  Index Only Scan using t1_pkey on t1 t1_2
5853                              Index Cond: (id = t2_2.id)
5854    ->  Merge Join
5855          Merge Cond: (t1.id = t2.id)
5856          ->  Index Scan using t1_pkey on t1
5857                Index Cond: (id < $1)
5858          ->  Index Scan using t2_pkey on t2
5859    ->  Hash
5860          ->  Seq Scan on t3
5861 (18 rows)
5862
5863 -- Specified outer/inner leading hint and join method hint at the same time
5864 /*+Leading(((t1 t2) t3))*/
5865 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5866 LOG:  pg_hint_plan:
5867 used hint:
5868 Leading(((t1 t2) t3))
5869 not used hint:
5870 duplication hint:
5871 error hint:
5872
5873                  QUERY PLAN
5874 --------------------------------------------
5875  Nested Loop
5876    Join Filter: (t2.val = t3.val)
5877    ->  Hash Join
5878          Hash Cond: (t1.id = t2.id)
5879          ->  Index Scan using t1_pkey on t1
5880                Index Cond: (id < 10)
5881          ->  Hash
5882                ->  Seq Scan on t2
5883    ->  Seq Scan on t3
5884 (9 rows)
5885
5886 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2)*/
5887 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5888 LOG:  pg_hint_plan:
5889 used hint:
5890 MergeJoin(t1 t2)
5891 Leading(((t1 t2) t3))
5892 not used hint:
5893 duplication hint:
5894 error hint:
5895
5896                  QUERY PLAN
5897 --------------------------------------------
5898  Nested Loop
5899    Join Filter: (t2.val = t3.val)
5900    ->  Merge Join
5901          Merge Cond: (t1.id = t2.id)
5902          ->  Index Scan using t1_pkey on t1
5903                Index Cond: (id < 10)
5904          ->  Index Scan using t2_pkey on t2
5905    ->  Seq Scan on t3
5906 (8 rows)
5907
5908 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3)*/
5909 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5910 LOG:  pg_hint_plan:
5911 used hint:
5912 MergeJoin(t1 t2 t3)
5913 Leading(((t1 t2) t3))
5914 not used hint:
5915 duplication hint:
5916 error hint:
5917
5918                     QUERY PLAN
5919 --------------------------------------------------
5920  Merge Join
5921    Merge Cond: (t2.val = t3.val)
5922    ->  Sort
5923          Sort Key: t2.val
5924          ->  Hash Join
5925                Hash Cond: (t1.id = t2.id)
5926                ->  Index Scan using t1_pkey on t1
5927                      Index Cond: (id < 10)
5928                ->  Hash
5929                      ->  Seq Scan on t2
5930    ->  Sort
5931          Sort Key: t3.val
5932          ->  Seq Scan on t3
5933 (13 rows)
5934
5935 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t3)*/
5936 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
5937 LOG:  pg_hint_plan:
5938 used hint:
5939 Leading(((t1 t2) t3))
5940 not used hint:
5941 MergeJoin(t1 t3)
5942 duplication hint:
5943 error hint:
5944
5945                  QUERY PLAN
5946 --------------------------------------------
5947  Nested Loop
5948    Join Filter: (t2.val = t3.val)
5949    ->  Hash Join
5950          Hash Cond: (t1.id = t2.id)
5951          ->  Index Scan using t1_pkey on t1
5952                Index Cond: (id < 10)
5953          ->  Hash
5954                ->  Seq Scan on t2
5955    ->  Seq Scan on t3
5956 (9 rows)
5957
5958 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;
5959                        QUERY PLAN
5960 --------------------------------------------------------
5961  Nested Loop
5962    ->  Merge Join
5963          Merge Cond: (t3.id = t4.id)
5964          ->  Nested Loop
5965                Join Filter: (t1.val = t3.val)
5966                ->  Index Scan using t3_pkey on t3
5967                ->  Materialize
5968                      ->  Index Scan using t1_pkey on t1
5969                            Index Cond: (id < 10)
5970          ->  Sort
5971                Sort Key: t4.id
5972                ->  Seq Scan on t4
5973    ->  Index Scan using t2_pkey on t2
5974          Index Cond: (id = t1.id)
5975 (14 rows)
5976
5977 /*+Leading(((t1 t2) t3)) MergeJoin(t3 t4)*/
5978 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;
5979 LOG:  pg_hint_plan:
5980 used hint:
5981 Leading(((t1 t2) t3))
5982 not used hint:
5983 MergeJoin(t3 t4)
5984 duplication hint:
5985 error hint:
5986
5987                     QUERY PLAN
5988 --------------------------------------------------
5989  Nested Loop
5990    ->  Nested Loop
5991          Join Filter: (t1.val = t3.val)
5992          ->  Hash Join
5993                Hash Cond: (t1.id = t2.id)
5994                ->  Index Scan using t1_pkey on t1
5995                      Index Cond: (id < 10)
5996                ->  Hash
5997                      ->  Seq Scan on t2
5998          ->  Seq Scan on t3
5999    ->  Index Scan using t4_pkey on t4
6000          Index Cond: (id = t3.id)
6001 (12 rows)
6002
6003 /*+Leading(((t1 t2) t3)) MergeJoin(t1 t2 t3 t4)*/
6004 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;
6005 LOG:  pg_hint_plan:
6006 used hint:
6007 MergeJoin(t1 t2 t3 t4)
6008 Leading(((t1 t2) t3))
6009 not used hint:
6010 duplication hint:
6011 error hint:
6012
6013                        QUERY PLAN
6014 --------------------------------------------------------
6015  Merge Join
6016    Merge Cond: (t3.id = t4.id)
6017    ->  Sort
6018          Sort Key: t3.id
6019          ->  Nested Loop
6020                Join Filter: (t1.val = t3.val)
6021                ->  Hash Join
6022                      Hash Cond: (t1.id = t2.id)
6023                      ->  Index Scan using t1_pkey on t1
6024                            Index Cond: (id < 10)
6025                      ->  Hash
6026                            ->  Seq Scan on t2
6027                ->  Seq Scan on t3
6028    ->  Sort
6029          Sort Key: t4.id
6030          ->  Seq Scan on t4
6031 (16 rows)
6032
6033 /*+ Leading ( ( t1 ( t2 t3 ) ) ) */
6034 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6035 LOG:  pg_hint_plan:
6036 used hint:
6037 Leading((t1 (t2 t3)))
6038 not used hint:
6039 duplication hint:
6040 error hint:
6041
6042                  QUERY PLAN
6043 --------------------------------------------
6044  Hash Join
6045    Hash Cond: (t1.id = t2.id)
6046    ->  Index Scan using t1_pkey on t1
6047          Index Cond: (id < 10)
6048    ->  Hash
6049          ->  Hash Join
6050                Hash Cond: (t2.val = t3.val)
6051                ->  Seq Scan on t2
6052                ->  Hash
6053                      ->  Seq Scan on t3
6054 (10 rows)
6055
6056 /*+Leading((t1(t2 t3)))*/
6057 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6058 LOG:  pg_hint_plan:
6059 used hint:
6060 Leading((t1 (t2 t3)))
6061 not used hint:
6062 duplication hint:
6063 error hint:
6064
6065                  QUERY PLAN
6066 --------------------------------------------
6067  Hash Join
6068    Hash Cond: (t1.id = t2.id)
6069    ->  Index Scan using t1_pkey on t1
6070          Index Cond: (id < 10)
6071    ->  Hash
6072          ->  Hash Join
6073                Hash Cond: (t2.val = t3.val)
6074                ->  Seq Scan on t2
6075                ->  Hash
6076                      ->  Seq Scan on t3
6077 (10 rows)
6078
6079 /*+Leading(("t1(t2" "t3)"))*/
6080 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6081 LOG:  pg_hint_plan:
6082 used hint:
6083 not used hint:
6084 Leading(("t1(t2" "t3)"))
6085 duplication hint:
6086 error hint:
6087
6088                        QUERY PLAN
6089 --------------------------------------------------------
6090  Hash Join
6091    Hash Cond: (t3.val = t2.val)
6092    ->  Seq Scan on t3
6093    ->  Hash
6094          ->  Hash Join
6095                Hash Cond: (t2.id = t1.id)
6096                ->  Seq Scan on t2
6097                ->  Hash
6098                      ->  Index Scan using t1_pkey on t1
6099                            Index Cond: (id < 10)
6100 (10 rows)
6101
6102 /*+ Leading ( ( ( t1 t2 ) t3 ) ) */
6103 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6104 LOG:  pg_hint_plan:
6105 used hint:
6106 Leading(((t1 t2) t3))
6107 not used hint:
6108 duplication hint:
6109 error hint:
6110
6111                  QUERY PLAN
6112 --------------------------------------------
6113  Nested Loop
6114    Join Filter: (t2.val = t3.val)
6115    ->  Hash Join
6116          Hash Cond: (t1.id = t2.id)
6117          ->  Index Scan using t1_pkey on t1
6118                Index Cond: (id < 10)
6119          ->  Hash
6120                ->  Seq Scan on t2
6121    ->  Seq Scan on t3
6122 (9 rows)
6123
6124 /*+Leading(((t1 t2)t3))*/
6125 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6126 LOG:  pg_hint_plan:
6127 used hint:
6128 Leading(((t1 t2) t3))
6129 not used hint:
6130 duplication hint:
6131 error hint:
6132
6133                  QUERY PLAN
6134 --------------------------------------------
6135  Nested Loop
6136    Join Filter: (t2.val = t3.val)
6137    ->  Hash Join
6138          Hash Cond: (t1.id = t2.id)
6139          ->  Index Scan using t1_pkey on t1
6140                Index Cond: (id < 10)
6141          ->  Hash
6142                ->  Seq Scan on t2
6143    ->  Seq Scan on t3
6144 (9 rows)
6145
6146 /*+Leading(("(t1" "t2)t3"))*/
6147 EXPLAIN (COSTS false) SELECT * FROM t1, t2, t3 WHERE t1.id = t2.id AND t2.val = t3.val AND t1.id < 10;
6148 LOG:  pg_hint_plan:
6149 used hint:
6150 not used hint:
6151 Leading(("(t1" "t2)t3"))
6152 duplication hint:
6153 error hint:
6154
6155                        QUERY PLAN
6156 --------------------------------------------------------
6157  Hash Join
6158    Hash Cond: (t3.val = t2.val)
6159    ->  Seq Scan on t3
6160    ->  Hash
6161          ->  Hash Join
6162                Hash Cond: (t2.id = t1.id)
6163                ->  Seq Scan on t2
6164                ->  Hash
6165                      ->  Index Scan using t1_pkey on t1
6166                            Index Cond: (id < 10)
6167 (10 rows)
6168
6169 /*+Leading((t1(t2(t3(t4 t5)))))*/
6170 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;
6171 LOG:  pg_hint_plan:
6172 used hint:
6173 Leading((t1 (t2 (t3 (t4 t5)))))
6174 not used hint:
6175 duplication hint:
6176 error hint:
6177
6178                                                             QUERY PLAN
6179 ----------------------------------------------------------------------------------------------------------------------------------
6180  Merge Join
6181    Merge Cond: (t1.id = t2.id)
6182    ->  Index Scan using t1_pkey on t1
6183    ->  Materialize
6184          ->  Merge Join
6185                Merge Cond: (t2.id = t3.id)
6186                ->  Index Scan using t2_pkey on t2
6187                ->  Materialize
6188                      ->  Merge Join
6189                            Merge Cond: (t3.id = t4.id)
6190                            ->  Index Scan using t3_pkey on t3
6191                            ->  Materialize
6192                                  ->  Merge Join
6193                                        Merge Cond: (t4.id = t5.id)
6194                                        ->  Index Scan using t4_pkey on t4
6195                                        ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6196 (16 rows)
6197
6198 /*+Leading((t5(t4(t3(t2 t1)))))*/
6199 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;
6200 LOG:  pg_hint_plan:
6201 used hint:
6202 Leading((t5 (t4 (t3 (t2 t1)))))
6203 not used hint:
6204 duplication hint:
6205 error hint:
6206
6207                                 QUERY PLAN
6208 --------------------------------------------------------------------------
6209  Hash Join
6210    Hash Cond: (t5.id = t1.id)
6211    ->  Seq Scan on t5
6212    ->  Hash
6213          ->  Merge Join
6214                Merge Cond: (t4.id = t1.id)
6215                ->  Sort
6216                      Sort Key: t4.id
6217                      ->  Seq Scan on t4
6218                ->  Materialize
6219                      ->  Merge Join
6220                            Merge Cond: (t3.id = t1.id)
6221                            ->  Sort
6222                                  Sort Key: t3.id
6223                                  ->  Seq Scan on t3
6224                            ->  Materialize
6225                                  ->  Merge Join
6226                                        Merge Cond: (t2.id = t1.id)
6227                                        ->  Index Scan using t2_pkey on t2
6228                                        ->  Index Scan using t1_pkey on t1
6229 (20 rows)
6230
6231 /*+Leading(((((t1 t2)t3)t4)t5))*/
6232 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;
6233 LOG:  pg_hint_plan:
6234 used hint:
6235 Leading(((((t1 t2) t3) t4) t5))
6236 not used hint:
6237 duplication hint:
6238 error hint:
6239
6240                                           QUERY PLAN
6241 ----------------------------------------------------------------------------------------------
6242  Nested Loop
6243    ->  Merge Join
6244          Merge Cond: (t1.id = t4.id)
6245          ->  Merge Join
6246                Merge Cond: (t1.id = t3.id)
6247                ->  Merge Join
6248                      Merge Cond: (t1.id = t2.id)
6249                      ->  Index Scan using t1_pkey on t1
6250                      ->  Index Scan using t2_pkey on t2
6251                ->  Index Scan using t3_pkey on t3
6252          ->  Sort
6253                Sort Key: t4.id
6254                ->  Seq Scan on t4
6255    ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6256          Index Cond: (id = t1.id)
6257 (15 rows)
6258
6259 /*+Leading(((((t5 t4)t3)t2)t1))*/
6260 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;
6261 LOG:  pg_hint_plan:
6262 used hint:
6263 Leading(((((t5 t4) t3) t2) t1))
6264 not used hint:
6265 duplication hint:
6266 error hint:
6267
6268                                                    QUERY PLAN
6269 ----------------------------------------------------------------------------------------------------------------
6270  Nested Loop
6271    Join Filter: (t2.id = t1.id)
6272    ->  Nested Loop
6273          Join Filter: (t3.id = t2.id)
6274          ->  Merge Join
6275                Merge Cond: (t4.id = t3.id)
6276                ->  Merge Join
6277                      Merge Cond: (t5.id = t4.id)
6278                      ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6279                      ->  Sort
6280                            Sort Key: t4.id
6281                            ->  Seq Scan on t4
6282                ->  Index Scan using t3_pkey on t3
6283          ->  Index Scan using t2_pkey on t2
6284                Index Cond: (id = t5.id)
6285    ->  Index Scan using t1_pkey on t1
6286          Index Cond: (id = t5.id)
6287 (17 rows)
6288
6289 /*+Leading(((t1 t2)(t3(t4 t5))))*/
6290 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;
6291 LOG:  pg_hint_plan:
6292 used hint:
6293 Leading(((t1 t2) (t3 (t4 t5))))
6294 not used hint:
6295 duplication hint:
6296 error hint:
6297
6298                                                       QUERY PLAN
6299 ----------------------------------------------------------------------------------------------------------------------
6300  Merge Join
6301    Merge Cond: (t1.id = t3.id)
6302    ->  Merge Join
6303          Merge Cond: (t1.id = t2.id)
6304          ->  Index Scan using t1_pkey on t1
6305          ->  Index Scan using t2_pkey on t2
6306    ->  Materialize
6307          ->  Merge Join
6308                Merge Cond: (t3.id = t4.id)
6309                ->  Index Scan using t3_pkey on t3
6310                ->  Materialize
6311                      ->  Merge Join
6312                            Merge Cond: (t4.id = t5.id)
6313                            ->  Index Scan using t4_pkey on t4
6314                            ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6315 (15 rows)
6316
6317 /*+Leading(((t5 t4)(t3(t2 t1))))*/
6318 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;
6319 LOG:  pg_hint_plan:
6320 used hint:
6321 Leading(((t5 t4) (t3 (t2 t1))))
6322 not used hint:
6323 duplication hint:
6324 error hint:
6325
6326                                              QUERY PLAN
6327 ----------------------------------------------------------------------------------------------------
6328  Merge Join
6329    Merge Cond: (t4.id = t1.id)
6330    ->  Merge Join
6331          Merge Cond: (t5.id = t4.id)
6332          ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6333          ->  Sort
6334                Sort Key: t4.id
6335                ->  Seq Scan on t4
6336    ->  Materialize
6337          ->  Merge Join
6338                Merge Cond: (t3.id = t1.id)
6339                ->  Index Scan using t3_pkey on t3
6340                ->  Materialize
6341                      ->  Merge Join
6342                            Merge Cond: (t2.id = t1.id)
6343                            ->  Index Scan using t2_pkey on t2
6344                            ->  Index Scan using t1_pkey on t1
6345 (17 rows)
6346
6347 /*+Leading((((t1 t2)t3)(t4 t5)))*/
6348 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;
6349 LOG:  pg_hint_plan:
6350 used hint:
6351 Leading((((t1 t2) t3) (t4 t5)))
6352 not used hint:
6353 duplication hint:
6354 error hint:
6355
6356                                                 QUERY PLAN
6357 ----------------------------------------------------------------------------------------------------------
6358  Merge Join
6359    Merge Cond: (t1.id = t4.id)
6360    ->  Merge Join
6361          Merge Cond: (t1.id = t3.id)
6362          ->  Merge Join
6363                Merge Cond: (t1.id = t2.id)
6364                ->  Index Scan using t1_pkey on t1
6365                ->  Index Scan using t2_pkey on t2
6366          ->  Index Scan using t3_pkey on t3
6367    ->  Materialize
6368          ->  Merge Join
6369                Merge Cond: (t4.id = t5.id)
6370                ->  Index Scan using t4_pkey on t4
6371                ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6372 (14 rows)
6373
6374 /*+Leading((((t5 t4)t3)(t2 t1)))*/
6375 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;
6376 LOG:  pg_hint_plan:
6377 used hint:
6378 Leading((((t5 t4) t3) (t2 t1)))
6379 not used hint:
6380 duplication hint:
6381 error hint:
6382
6383                                                 QUERY PLAN
6384 ----------------------------------------------------------------------------------------------------------
6385  Merge Join
6386    Merge Cond: (t3.id = t1.id)
6387    ->  Merge Join
6388          Merge Cond: (t4.id = t3.id)
6389          ->  Merge Join
6390                Merge Cond: (t5.id = t4.id)
6391                ->  Index Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
6392                ->  Sort
6393                      Sort Key: t4.id
6394                      ->  Seq Scan on t4
6395          ->  Index Scan using t3_pkey on t3
6396    ->  Materialize
6397          ->  Merge Join
6398                Merge Cond: (t2.id = t1.id)
6399                ->  Index Scan using t2_pkey on t2
6400                ->  Index Scan using t1_pkey on t1
6401 (16 rows)
6402
6403 -- inherite table test to specify the index's name
6404 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6405                               QUERY PLAN
6406 -----------------------------------------------------------------------
6407  Append
6408    ->  Seq Scan on p2
6409          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6410    ->  Seq Scan on p2_c1
6411          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6412    ->  Tid Scan on p2_c1_c1
6413          TID Cond: (ctid = '(1,1)'::tid)
6414          Filter: ((id >= 50) AND (id <= 51))
6415    ->  Tid Scan on p2_c1_c2
6416          TID Cond: (ctid = '(1,1)'::tid)
6417          Filter: ((id >= 50) AND (id <= 51))
6418 (11 rows)
6419
6420 /*+IndexScan(p2 p2_pkey)*/
6421 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6422 LOG:  available indexes for IndexScan(p2): p2_pkey
6423 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6424 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6425 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6426 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6427 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6428 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6429 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6430 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6431 LOG:  pg_hint_plan:
6432 used hint:
6433 IndexScan(p2 p2_pkey)
6434 not used hint:
6435 duplication hint:
6436 error hint:
6437
6438                     QUERY PLAN
6439 --------------------------------------------------
6440  Append
6441    ->  Index Scan using p2_pkey on p2
6442          Index Cond: ((id >= 50) AND (id <= 51))
6443          Filter: (ctid = '(1,1)'::tid)
6444    ->  Index Scan using p2_c1_pkey on p2_c1
6445          Index Cond: ((id >= 50) AND (id <= 51))
6446          Filter: (ctid = '(1,1)'::tid)
6447    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6448          Index Cond: ((id >= 50) AND (id <= 51))
6449          Filter: (ctid = '(1,1)'::tid)
6450    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6451          Index Cond: ((id >= 50) AND (id <= 51))
6452          Filter: (ctid = '(1,1)'::tid)
6453 (13 rows)
6454
6455 /*+IndexScan(p2 p2_id_val_idx)*/
6456 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6457 LOG:  available indexes for IndexScan(p2): p2_id_val_idx
6458 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6459 LOG:  available indexes for IndexScan(p2_c2): p2_c2_id_val_idx
6460 LOG:  available indexes for IndexScan(p2_c3): p2_c3_id_val_idx
6461 LOG:  available indexes for IndexScan(p2_c4): p2_c4_id_val_idx
6462 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_id_val_idx
6463 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_id_val_idx
6464 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_id_val_idx
6465 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_id_val_idx
6466 LOG:  pg_hint_plan:
6467 used hint:
6468 IndexScan(p2 p2_id_val_idx)
6469 not used hint:
6470 duplication hint:
6471 error hint:
6472
6473                        QUERY PLAN
6474 --------------------------------------------------------
6475  Append
6476    ->  Index Scan using p2_id_val_idx on p2
6477          Index Cond: ((id >= 50) AND (id <= 51))
6478          Filter: (ctid = '(1,1)'::tid)
6479    ->  Index Scan using p2_c1_id_val_idx on p2_c1
6480          Index Cond: ((id >= 50) AND (id <= 51))
6481          Filter: (ctid = '(1,1)'::tid)
6482    ->  Index Scan using p2_c1_c1_id_val_idx on p2_c1_c1
6483          Index Cond: ((id >= 50) AND (id <= 51))
6484          Filter: (ctid = '(1,1)'::tid)
6485    ->  Index Scan using p2_c1_c2_id_val_idx on p2_c1_c2
6486          Index Cond: ((id >= 50) AND (id <= 51))
6487          Filter: (ctid = '(1,1)'::tid)
6488 (13 rows)
6489
6490 /*+IndexScan(p2 p2_val_id_idx)*/
6491 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6492 LOG:  available indexes for IndexScan(p2): p2_val_id_idx
6493 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_id_idx
6494 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_id_idx
6495 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_id_idx
6496 LOG:  available indexes for IndexScan(p2_c4):
6497 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_id_idx
6498 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_id_idx
6499 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_id_idx
6500 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_id_idx
6501 LOG:  pg_hint_plan:
6502 used hint:
6503 IndexScan(p2 p2_val_id_idx)
6504 not used hint:
6505 duplication hint:
6506 error hint:
6507
6508                        QUERY PLAN
6509 --------------------------------------------------------
6510  Append
6511    ->  Index Scan using p2_val_id_idx on p2
6512          Index Cond: ((id >= 50) AND (id <= 51))
6513          Filter: (ctid = '(1,1)'::tid)
6514    ->  Index Scan using p2_c1_val_id_idx on p2_c1
6515          Index Cond: ((id >= 50) AND (id <= 51))
6516          Filter: (ctid = '(1,1)'::tid)
6517    ->  Index Scan using p2_c1_c1_val_id_idx on p2_c1_c1
6518          Index Cond: ((id >= 50) AND (id <= 51))
6519          Filter: (ctid = '(1,1)'::tid)
6520    ->  Index Scan using p2_c1_c2_val_id_idx on p2_c1_c2
6521          Index Cond: ((id >= 50) AND (id <= 51))
6522          Filter: (ctid = '(1,1)'::tid)
6523 (13 rows)
6524
6525 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6526                                        QUERY PLAN
6527 -----------------------------------------------------------------------------------------
6528  Append
6529    ->  Seq Scan on p2
6530          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6531    ->  Seq Scan on p2_c1
6532          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6533    ->  Seq Scan on p2_c2
6534          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6535    ->  Seq Scan on p2_c3
6536          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6537    ->  Tid Scan on p2_c4
6538          TID Cond: (ctid = '(1,1)'::tid)
6539          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6540    ->  Tid Scan on p2_c1_c1
6541          TID Cond: (ctid = '(1,1)'::tid)
6542          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6543    ->  Tid Scan on p2_c1_c2
6544          TID Cond: (ctid = '(1,1)'::tid)
6545          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6546    ->  Tid Scan on p2_c3_c1
6547          TID Cond: (ctid = '(1,1)'::tid)
6548          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6549    ->  Tid Scan on p2_c3_c2
6550          TID Cond: (ctid = '(1,1)'::tid)
6551          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6552 (24 rows)
6553
6554 /*+IndexScan(p2 p2_val)*/
6555 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6556 LOG:  available indexes for IndexScan(p2):
6557 LOG:  available indexes for IndexScan(p2_c1):
6558 LOG:  available indexes for IndexScan(p2_c2):
6559 LOG:  available indexes for IndexScan(p2_c3):
6560 LOG:  available indexes for IndexScan(p2_c4):
6561 LOG:  available indexes for IndexScan(p2_c1_c1):
6562 LOG:  available indexes for IndexScan(p2_c1_c2):
6563 LOG:  available indexes for IndexScan(p2_c3_c1):
6564 LOG:  available indexes for IndexScan(p2_c3_c2):
6565 LOG:  pg_hint_plan:
6566 used hint:
6567 IndexScan(p2 p2_val)
6568 not used hint:
6569 duplication hint:
6570 error hint:
6571
6572                                        QUERY PLAN
6573 -----------------------------------------------------------------------------------------
6574  Append
6575    ->  Seq Scan on p2
6576          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6577    ->  Seq Scan on p2_c1
6578          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6579    ->  Seq Scan on p2_c2
6580          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6581    ->  Seq Scan on p2_c3
6582          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
6583    ->  Tid Scan on p2_c4
6584          TID Cond: (ctid = '(1,1)'::tid)
6585          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6586    ->  Tid Scan on p2_c1_c1
6587          TID Cond: (ctid = '(1,1)'::tid)
6588          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6589    ->  Tid Scan on p2_c1_c2
6590          TID Cond: (ctid = '(1,1)'::tid)
6591          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6592    ->  Tid Scan on p2_c3_c1
6593          TID Cond: (ctid = '(1,1)'::tid)
6594          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6595    ->  Tid Scan on p2_c3_c2
6596          TID Cond: (ctid = '(1,1)'::tid)
6597          Filter: ((val >= '50'::text) AND (val <= '51'::text))
6598 (24 rows)
6599
6600 /*+IndexScan(p2 p2_pkey)*/
6601 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6602 LOG:  available indexes for IndexScan(p2): p2_pkey
6603 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6604 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6605 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6606 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6607 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6608 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6609 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6610 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6611 LOG:  pg_hint_plan:
6612 used hint:
6613 IndexScan(p2 p2_pkey)
6614 not used hint:
6615 duplication hint:
6616 error hint:
6617
6618                     QUERY PLAN
6619 --------------------------------------------------
6620  Append
6621    ->  Index Scan using p2_pkey on p2
6622          Index Cond: ((id >= 50) AND (id <= 51))
6623          Filter: (ctid = '(1,1)'::tid)
6624    ->  Index Scan using p2_c1_pkey on p2_c1
6625          Index Cond: ((id >= 50) AND (id <= 51))
6626          Filter: (ctid = '(1,1)'::tid)
6627    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6628          Index Cond: ((id >= 50) AND (id <= 51))
6629          Filter: (ctid = '(1,1)'::tid)
6630    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6631          Index Cond: ((id >= 50) AND (id <= 51))
6632          Filter: (ctid = '(1,1)'::tid)
6633 (13 rows)
6634
6635 /*+IndexScan(p2 p2_id2_val)*/
6636 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6637 LOG:  available indexes for IndexScan(p2): p2_id2_val
6638 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id2_val
6639 LOG:  available indexes for IndexScan(p2_c2): p2_c2_id2_val
6640 LOG:  available indexes for IndexScan(p2_c3):
6641 LOG:  available indexes for IndexScan(p2_c4):
6642 LOG:  available indexes for IndexScan(p2_c1_c1):
6643 LOG:  available indexes for IndexScan(p2_c1_c2):
6644 LOG:  available indexes for IndexScan(p2_c3_c1):
6645 LOG:  available indexes for IndexScan(p2_c3_c2):
6646 LOG:  pg_hint_plan:
6647 used hint:
6648 IndexScan(p2 p2_id2_val)
6649 not used hint:
6650 duplication hint:
6651 error hint:
6652
6653                    QUERY PLAN
6654 -------------------------------------------------
6655  Append
6656    ->  Index Scan using p2_id2_val on p2
6657          Index Cond: ((id >= 50) AND (id <= 51))
6658          Filter: (ctid = '(1,1)'::tid)
6659    ->  Index Scan using p2_c1_id2_val on p2_c1
6660          Index Cond: ((id >= 50) AND (id <= 51))
6661          Filter: (ctid = '(1,1)'::tid)
6662    ->  Tid Scan on p2_c1_c1
6663          TID Cond: (ctid = '(1,1)'::tid)
6664          Filter: ((id >= 50) AND (id <= 51))
6665    ->  Tid Scan on p2_c1_c2
6666          TID Cond: (ctid = '(1,1)'::tid)
6667          Filter: ((id >= 50) AND (id <= 51))
6668 (13 rows)
6669
6670 /*+IndexScan(p2 p2_val2_id)*/
6671 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6672 LOG:  available indexes for IndexScan(p2): p2_val2_id
6673 LOG:  available indexes for IndexScan(p2_c1):
6674 LOG:  available indexes for IndexScan(p2_c2):
6675 LOG:  available indexes for IndexScan(p2_c3):
6676 LOG:  available indexes for IndexScan(p2_c4):
6677 LOG:  available indexes for IndexScan(p2_c1_c1):
6678 LOG:  available indexes for IndexScan(p2_c1_c2):
6679 LOG:  available indexes for IndexScan(p2_c3_c1):
6680 LOG:  available indexes for IndexScan(p2_c3_c2):
6681 LOG:  pg_hint_plan:
6682 used hint:
6683 IndexScan(p2 p2_val2_id)
6684 not used hint:
6685 duplication hint:
6686 error hint:
6687
6688                               QUERY PLAN
6689 -----------------------------------------------------------------------
6690  Append
6691    ->  Index Scan using p2_val2_id on p2
6692          Index Cond: ((id >= 50) AND (id <= 51))
6693          Filter: (ctid = '(1,1)'::tid)
6694    ->  Seq Scan on p2_c1
6695          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6696    ->  Tid Scan on p2_c1_c1
6697          TID Cond: (ctid = '(1,1)'::tid)
6698          Filter: ((id >= 50) AND (id <= 51))
6699    ->  Tid Scan on p2_c1_c2
6700          TID Cond: (ctid = '(1,1)'::tid)
6701          Filter: ((id >= 50) AND (id <= 51))
6702 (12 rows)
6703
6704 /*+IndexScan(p2 p2_pkey)*/
6705 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6706 LOG:  available indexes for IndexScan(p2): p2_pkey
6707 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6708 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6709 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6710 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6711 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6712 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6713 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6714 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6715 LOG:  pg_hint_plan:
6716 used hint:
6717 IndexScan(p2 p2_pkey)
6718 not used hint:
6719 duplication hint:
6720 error hint:
6721
6722                     QUERY PLAN
6723 --------------------------------------------------
6724  Append
6725    ->  Index Scan using p2_pkey on p2
6726          Index Cond: ((id >= 50) AND (id <= 51))
6727          Filter: (ctid = '(1,1)'::tid)
6728    ->  Index Scan using p2_c1_pkey on p2_c1
6729          Index Cond: ((id >= 50) AND (id <= 51))
6730          Filter: (ctid = '(1,1)'::tid)
6731    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6732          Index Cond: ((id >= 50) AND (id <= 51))
6733          Filter: (ctid = '(1,1)'::tid)
6734    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6735          Index Cond: ((id >= 50) AND (id <= 51))
6736          Filter: (ctid = '(1,1)'::tid)
6737 (13 rows)
6738
6739 /*+IndexScan(p2 p2_c1_id_val_idx)*/
6740 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6741 LOG:  available indexes for IndexScan(p2):
6742 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6743 LOG:  available indexes for IndexScan(p2_c2):
6744 LOG:  available indexes for IndexScan(p2_c3):
6745 LOG:  available indexes for IndexScan(p2_c4):
6746 LOG:  available indexes for IndexScan(p2_c1_c1):
6747 LOG:  available indexes for IndexScan(p2_c1_c2):
6748 LOG:  available indexes for IndexScan(p2_c3_c1):
6749 LOG:  available indexes for IndexScan(p2_c3_c2):
6750 LOG:  pg_hint_plan:
6751 used hint:
6752 IndexScan(p2 p2_c1_id_val_idx)
6753 not used hint:
6754 duplication hint:
6755 error hint:
6756
6757                               QUERY PLAN
6758 -----------------------------------------------------------------------
6759  Append
6760    ->  Seq Scan on p2
6761          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6762    ->  Index Scan using p2_c1_id_val_idx on p2_c1
6763          Index Cond: ((id >= 50) AND (id <= 51))
6764          Filter: (ctid = '(1,1)'::tid)
6765    ->  Tid Scan on p2_c1_c1
6766          TID Cond: (ctid = '(1,1)'::tid)
6767          Filter: ((id >= 50) AND (id <= 51))
6768    ->  Tid Scan on p2_c1_c2
6769          TID Cond: (ctid = '(1,1)'::tid)
6770          Filter: ((id >= 50) AND (id <= 51))
6771 (12 rows)
6772
6773 /*+IndexScan(p2 no_exist)*/
6774 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6775 LOG:  available indexes for IndexScan(p2):
6776 LOG:  available indexes for IndexScan(p2_c1):
6777 LOG:  available indexes for IndexScan(p2_c2):
6778 LOG:  available indexes for IndexScan(p2_c3):
6779 LOG:  available indexes for IndexScan(p2_c4):
6780 LOG:  available indexes for IndexScan(p2_c1_c1):
6781 LOG:  available indexes for IndexScan(p2_c1_c2):
6782 LOG:  available indexes for IndexScan(p2_c3_c1):
6783 LOG:  available indexes for IndexScan(p2_c3_c2):
6784 LOG:  pg_hint_plan:
6785 used hint:
6786 IndexScan(p2 no_exist)
6787 not used hint:
6788 duplication hint:
6789 error hint:
6790
6791                               QUERY PLAN
6792 -----------------------------------------------------------------------
6793  Append
6794    ->  Seq Scan on p2
6795          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6796    ->  Seq Scan on p2_c1
6797          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6798    ->  Tid Scan on p2_c1_c1
6799          TID Cond: (ctid = '(1,1)'::tid)
6800          Filter: ((id >= 50) AND (id <= 51))
6801    ->  Tid Scan on p2_c1_c2
6802          TID Cond: (ctid = '(1,1)'::tid)
6803          Filter: ((id >= 50) AND (id <= 51))
6804 (11 rows)
6805
6806 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx)*/
6807 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6808 LOG:  available indexes for IndexScan(p2): p2_pkey
6809 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6810 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6811 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6812 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6813 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6814 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6815 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6816 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6817 LOG:  pg_hint_plan:
6818 used hint:
6819 IndexScan(p2 p2_pkey p2_c1_id_val_idx)
6820 not used hint:
6821 duplication hint:
6822 error hint:
6823
6824                     QUERY PLAN
6825 --------------------------------------------------
6826  Append
6827    ->  Index Scan using p2_pkey on p2
6828          Index Cond: ((id >= 50) AND (id <= 51))
6829          Filter: (ctid = '(1,1)'::tid)
6830    ->  Index Scan using p2_c1_id_val_idx on p2_c1
6831          Index Cond: ((id >= 50) AND (id <= 51))
6832          Filter: (ctid = '(1,1)'::tid)
6833    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6834          Index Cond: ((id >= 50) AND (id <= 51))
6835          Filter: (ctid = '(1,1)'::tid)
6836    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6837          Index Cond: ((id >= 50) AND (id <= 51))
6838          Filter: (ctid = '(1,1)'::tid)
6839 (13 rows)
6840
6841 /*+IndexScan(p2 p2_pkey no_exist)*/
6842 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6843 LOG:  available indexes for IndexScan(p2): p2_pkey
6844 LOG:  available indexes for IndexScan(p2_c1): p2_c1_pkey
6845 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6846 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6847 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6848 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6849 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6850 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6851 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6852 LOG:  pg_hint_plan:
6853 used hint:
6854 IndexScan(p2 p2_pkey no_exist)
6855 not used hint:
6856 duplication hint:
6857 error hint:
6858
6859                     QUERY PLAN
6860 --------------------------------------------------
6861  Append
6862    ->  Index Scan using p2_pkey on p2
6863          Index Cond: ((id >= 50) AND (id <= 51))
6864          Filter: (ctid = '(1,1)'::tid)
6865    ->  Index Scan using p2_c1_pkey on p2_c1
6866          Index Cond: ((id >= 50) AND (id <= 51))
6867          Filter: (ctid = '(1,1)'::tid)
6868    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6869          Index Cond: ((id >= 50) AND (id <= 51))
6870          Filter: (ctid = '(1,1)'::tid)
6871    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6872          Index Cond: ((id >= 50) AND (id <= 51))
6873          Filter: (ctid = '(1,1)'::tid)
6874 (13 rows)
6875
6876 /*+IndexScan(p2 p2_c1_id_val_idx no_exist)*/
6877 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6878 LOG:  available indexes for IndexScan(p2):
6879 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx
6880 LOG:  available indexes for IndexScan(p2_c2):
6881 LOG:  available indexes for IndexScan(p2_c3):
6882 LOG:  available indexes for IndexScan(p2_c4):
6883 LOG:  available indexes for IndexScan(p2_c1_c1):
6884 LOG:  available indexes for IndexScan(p2_c1_c2):
6885 LOG:  available indexes for IndexScan(p2_c3_c1):
6886 LOG:  available indexes for IndexScan(p2_c3_c2):
6887 LOG:  pg_hint_plan:
6888 used hint:
6889 IndexScan(p2 p2_c1_id_val_idx no_exist)
6890 not used hint:
6891 duplication hint:
6892 error hint:
6893
6894                               QUERY PLAN
6895 -----------------------------------------------------------------------
6896  Append
6897    ->  Seq Scan on p2
6898          Filter: ((id >= 50) AND (id <= 51) AND (ctid = '(1,1)'::tid))
6899    ->  Index Scan using p2_c1_id_val_idx on p2_c1
6900          Index Cond: ((id >= 50) AND (id <= 51))
6901          Filter: (ctid = '(1,1)'::tid)
6902    ->  Tid Scan on p2_c1_c1
6903          TID Cond: (ctid = '(1,1)'::tid)
6904          Filter: ((id >= 50) AND (id <= 51))
6905    ->  Tid Scan on p2_c1_c2
6906          TID Cond: (ctid = '(1,1)'::tid)
6907          Filter: ((id >= 50) AND (id <= 51))
6908 (12 rows)
6909
6910 /*+IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)*/
6911 EXPLAIN (COSTS false) SELECT * FROM p2 WHERE id >= 50 AND id <= 51 AND p2.ctid = '(1,1)';
6912 LOG:  available indexes for IndexScan(p2): p2_pkey
6913 LOG:  available indexes for IndexScan(p2_c1): p2_c1_id_val_idx p2_c1_pkey
6914 LOG:  available indexes for IndexScan(p2_c2): p2_c2_pkey
6915 LOG:  available indexes for IndexScan(p2_c3): p2_c3_pkey
6916 LOG:  available indexes for IndexScan(p2_c4): p2_c4_pkey
6917 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_pkey
6918 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_pkey
6919 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_pkey
6920 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_pkey
6921 LOG:  pg_hint_plan:
6922 used hint:
6923 IndexScan(p2 p2_pkey p2_c1_id_val_idx no_exist)
6924 not used hint:
6925 duplication hint:
6926 error hint:
6927
6928                     QUERY PLAN
6929 --------------------------------------------------
6930  Append
6931    ->  Index Scan using p2_pkey on p2
6932          Index Cond: ((id >= 50) AND (id <= 51))
6933          Filter: (ctid = '(1,1)'::tid)
6934    ->  Index Scan using p2_c1_id_val_idx on p2_c1
6935          Index Cond: ((id >= 50) AND (id <= 51))
6936          Filter: (ctid = '(1,1)'::tid)
6937    ->  Index Scan using p2_c1_c1_pkey on p2_c1_c1
6938          Index Cond: ((id >= 50) AND (id <= 51))
6939          Filter: (ctid = '(1,1)'::tid)
6940    ->  Index Scan using p2_c1_c2_pkey on p2_c1_c2
6941          Index Cond: ((id >= 50) AND (id <= 51))
6942          Filter: (ctid = '(1,1)'::tid)
6943 (13 rows)
6944
6945 /*+IndexScan(p2 p2_val_idx)*/
6946 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6947 LOG:  available indexes for IndexScan(p2): p2_val_idx
6948 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx
6949 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx
6950 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx
6951 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx
6952 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx
6953 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx
6954 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx
6955 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx
6956 LOG:  pg_hint_plan:
6957 used hint:
6958 IndexScan(p2 p2_val_idx)
6959 not used hint:
6960 duplication hint:
6961 error hint:
6962
6963                             QUERY PLAN
6964 -------------------------------------------------------------------
6965  Append
6966    ->  Index Scan using p2_val_idx on p2
6967          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6968          Filter: (ctid = '(1,1)'::tid)
6969    ->  Index Scan using p2_c1_val_idx on p2_c1
6970          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6971          Filter: (ctid = '(1,1)'::tid)
6972    ->  Index Scan using p2_c2_val_idx on p2_c2
6973          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6974          Filter: (ctid = '(1,1)'::tid)
6975    ->  Index Scan using p2_c3_val_idx on p2_c3
6976          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6977          Filter: (ctid = '(1,1)'::tid)
6978    ->  Index Scan using p2_c4_val_idx on p2_c4
6979          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6980          Filter: (ctid = '(1,1)'::tid)
6981    ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1
6982          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6983          Filter: (ctid = '(1,1)'::tid)
6984    ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2
6985          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6986          Filter: (ctid = '(1,1)'::tid)
6987    ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1
6988          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6989          Filter: (ctid = '(1,1)'::tid)
6990    ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2
6991          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
6992          Filter: (ctid = '(1,1)'::tid)
6993 (28 rows)
6994
6995 /*+IndexScan(p2 p2_expr)*/
6996 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
6997 LOG:  available indexes for IndexScan(p2): p2_expr
6998 LOG:  available indexes for IndexScan(p2_c1): p2_c1_expr_idx
6999 LOG:  available indexes for IndexScan(p2_c2): p2_c2_expr_idx
7000 LOG:  available indexes for IndexScan(p2_c3): p2_c3_expr_idx
7001 LOG:  available indexes for IndexScan(p2_c4): p2_c4_expr_idx
7002 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_expr_idx
7003 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_expr_idx
7004 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_expr_idx
7005 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_expr_idx
7006 LOG:  pg_hint_plan:
7007 used hint:
7008 IndexScan(p2 p2_expr)
7009 not used hint:
7010 duplication hint:
7011 error hint:
7012
7013                                        QUERY PLAN
7014 -----------------------------------------------------------------------------------------
7015  Append
7016    ->  Seq Scan on p2
7017          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7018    ->  Seq Scan on p2_c1
7019          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7020    ->  Seq Scan on p2_c2
7021          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7022    ->  Seq Scan on p2_c3
7023          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7024    ->  Tid Scan on p2_c4
7025          TID Cond: (ctid = '(1,1)'::tid)
7026          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7027    ->  Tid Scan on p2_c1_c1
7028          TID Cond: (ctid = '(1,1)'::tid)
7029          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7030    ->  Tid Scan on p2_c1_c2
7031          TID Cond: (ctid = '(1,1)'::tid)
7032          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7033    ->  Tid Scan on p2_c3_c1
7034          TID Cond: (ctid = '(1,1)'::tid)
7035          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7036    ->  Tid Scan on p2_c3_c2
7037          TID Cond: (ctid = '(1,1)'::tid)
7038          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7039 (24 rows)
7040
7041 /*+IndexScan(p2 p2_val_idx6)*/
7042 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7043 LOG:  available indexes for IndexScan(p2): p2_val_idx6
7044 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6
7045 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6
7046 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6
7047 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6
7048 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6
7049 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6
7050 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6
7051 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6
7052 LOG:  pg_hint_plan:
7053 used hint:
7054 IndexScan(p2 p2_val_idx6)
7055 not used hint:
7056 duplication hint:
7057 error hint:
7058
7059                                        QUERY PLAN
7060 -----------------------------------------------------------------------------------------
7061  Append
7062    ->  Seq Scan on p2
7063          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7064    ->  Seq Scan on p2_c1
7065          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7066    ->  Seq Scan on p2_c2
7067          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7068    ->  Seq Scan on p2_c3
7069          Filter: ((val >= '50'::text) AND (val <= '51'::text) AND (ctid = '(1,1)'::tid))
7070    ->  Tid Scan on p2_c4
7071          TID Cond: (ctid = '(1,1)'::tid)
7072          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7073    ->  Tid Scan on p2_c1_c1
7074          TID Cond: (ctid = '(1,1)'::tid)
7075          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7076    ->  Tid Scan on p2_c1_c2
7077          TID Cond: (ctid = '(1,1)'::tid)
7078          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7079    ->  Tid Scan on p2_c3_c1
7080          TID Cond: (ctid = '(1,1)'::tid)
7081          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7082    ->  Tid Scan on p2_c3_c2
7083          TID Cond: (ctid = '(1,1)'::tid)
7084          Filter: ((val >= '50'::text) AND (val <= '51'::text))
7085 (24 rows)
7086
7087 /*+IndexScan(p2 p2_val_idx p2_val_idx6)*/
7088 EXPLAIN (COSTS false) SELECT val FROM p2 WHERE val >= '50' AND val <= '51' AND p2.ctid = '(1,1)';
7089 LOG:  available indexes for IndexScan(p2): p2_val_idx6 p2_val_idx
7090 LOG:  available indexes for IndexScan(p2_c1): p2_c1_val_idx6 p2_c1_val_idx
7091 LOG:  available indexes for IndexScan(p2_c2): p2_c2_val_idx6 p2_c2_val_idx
7092 LOG:  available indexes for IndexScan(p2_c3): p2_c3_val_idx6 p2_c3_val_idx
7093 LOG:  available indexes for IndexScan(p2_c4): p2_c4_val_idx6 p2_c4_val_idx
7094 LOG:  available indexes for IndexScan(p2_c1_c1): p2_c1_c1_val_idx6 p2_c1_c1_val_idx
7095 LOG:  available indexes for IndexScan(p2_c1_c2): p2_c1_c2_val_idx6 p2_c1_c2_val_idx
7096 LOG:  available indexes for IndexScan(p2_c3_c1): p2_c3_c1_val_idx6 p2_c3_c1_val_idx
7097 LOG:  available indexes for IndexScan(p2_c3_c2): p2_c3_c2_val_idx6 p2_c3_c2_val_idx
7098 LOG:  pg_hint_plan:
7099 used hint:
7100 IndexScan(p2 p2_val_idx p2_val_idx6)
7101 not used hint:
7102 duplication hint:
7103 error hint:
7104
7105                             QUERY PLAN
7106 -------------------------------------------------------------------
7107  Append
7108    ->  Index Scan using p2_val_idx on p2
7109          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7110          Filter: (ctid = '(1,1)'::tid)
7111    ->  Index Scan using p2_c1_val_idx on p2_c1
7112          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7113          Filter: (ctid = '(1,1)'::tid)
7114    ->  Index Scan using p2_c2_val_idx on p2_c2
7115          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7116          Filter: (ctid = '(1,1)'::tid)
7117    ->  Index Scan using p2_c3_val_idx on p2_c3
7118          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7119          Filter: (ctid = '(1,1)'::tid)
7120    ->  Index Scan using p2_c4_val_idx on p2_c4
7121          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7122          Filter: (ctid = '(1,1)'::tid)
7123    ->  Index Scan using p2_c1_c1_val_idx on p2_c1_c1
7124          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7125          Filter: (ctid = '(1,1)'::tid)
7126    ->  Index Scan using p2_c1_c2_val_idx on p2_c1_c2
7127          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7128          Filter: (ctid = '(1,1)'::tid)
7129    ->  Index Scan using p2_c3_c1_val_idx on p2_c3_c1
7130          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7131          Filter: (ctid = '(1,1)'::tid)
7132    ->  Index Scan using p2_c3_c2_val_idx on p2_c3_c2
7133          Index Cond: ((val >= '50'::text) AND (val <= '51'::text))
7134          Filter: (ctid = '(1,1)'::tid)
7135 (28 rows)
7136
7137 -- regular expression
7138 -- ordinary table
7139 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7140                                          QUERY PLAN
7141 ---------------------------------------------------------------------------------------------
7142  Index Only Scan using t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa on t5
7143    Index Cond: (id = 1)
7144 (2 rows)
7145
7146 /*+ IndexScanRegexp(t5 t5_[^i].*)*/
7147 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7148 LOG:  available indexes for IndexScanRegexp(t5): t5_val t5_pkey
7149 LOG:  pg_hint_plan:
7150 used hint:
7151 IndexScanRegexp(t5 t5_[^i].*)
7152 not used hint:
7153 duplication hint:
7154 error hint:
7155
7156            QUERY PLAN
7157 --------------------------------
7158  Index Scan using t5_pkey on t5
7159    Index Cond: (id = 1)
7160 (2 rows)
7161
7162 /*+ IndexScanRegexp(t5 t5_id[0-9].*)*/
7163 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7164 LOG:  available indexes for IndexScanRegexp(t5): t5_id3 t5_id2 t5_id1
7165 LOG:  pg_hint_plan:
7166 used hint:
7167 IndexScanRegexp(t5 t5_id[0-9].*)
7168 not used hint:
7169 duplication hint:
7170 error hint:
7171
7172           QUERY PLAN
7173 -------------------------------
7174  Index Scan using t5_id3 on t5
7175    Index Cond: (id = 1)
7176 (2 rows)
7177
7178 /*+ IndexScanRegexp(t5 t5[^_].*)*/
7179 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7180 LOG:  available indexes for IndexScanRegexp(t5):
7181 LOG:  pg_hint_plan:
7182 used hint:
7183 IndexScanRegexp(t5 t5[^_].*)
7184 not used hint:
7185 duplication hint:
7186 error hint:
7187
7188      QUERY PLAN
7189 --------------------
7190  Seq Scan on t5
7191    Filter: (id = 1)
7192 (2 rows)
7193
7194 /*+ IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7195 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7196 LOG:  available indexes for IndexScanRegexp(t5):
7197 LOG:  pg_hint_plan:
7198 used hint:
7199 IndexScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7200 not used hint:
7201 duplication hint:
7202 error hint:
7203
7204      QUERY PLAN
7205 --------------------
7206  Seq Scan on t5
7207    Filter: (id = 1)
7208 (2 rows)
7209
7210 /*+ IndexScan(t5 t5_id[0-9].*)*/
7211 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7212 LOG:  available indexes for IndexScan(t5):
7213 LOG:  pg_hint_plan:
7214 used hint:
7215 IndexScan(t5 t5_id[0-9].*)
7216 not used hint:
7217 duplication hint:
7218 error hint:
7219
7220      QUERY PLAN
7221 --------------------
7222  Seq Scan on t5
7223    Filter: (id = 1)
7224 (2 rows)
7225
7226 /*+ IndexOnlyScanRegexp(t5 t5_[^i].*)*/
7227 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7228 LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_val t5_pkey
7229 LOG:  pg_hint_plan:
7230 used hint:
7231 IndexOnlyScanRegexp(t5 t5_[^i].*)
7232 not used hint:
7233 duplication hint:
7234 error hint:
7235
7236              QUERY PLAN
7237 -------------------------------------
7238  Index Only Scan using t5_pkey on t5
7239    Index Cond: (id = 1)
7240 (2 rows)
7241
7242 /*+ IndexOnlyScanRegexp(t5 t5_id[0-9].*)*/
7243 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7244 LOG:  available indexes for IndexOnlyScanRegexp(t5): t5_id3 t5_id2 t5_id1
7245 LOG:  pg_hint_plan:
7246 used hint:
7247 IndexOnlyScanRegexp(t5 t5_id[0-9].*)
7248 not used hint:
7249 duplication hint:
7250 error hint:
7251
7252              QUERY PLAN
7253 ------------------------------------
7254  Index Only Scan using t5_id3 on t5
7255    Index Cond: (id = 1)
7256 (2 rows)
7257
7258 /*+ IndexOnlyScanRegexp(t5 t5[^_].*)*/
7259 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7260 LOG:  available indexes for IndexOnlyScanRegexp(t5):
7261 LOG:  pg_hint_plan:
7262 used hint:
7263 IndexOnlyScanRegexp(t5 t5[^_].*)
7264 not used hint:
7265 duplication hint:
7266 error hint:
7267
7268      QUERY PLAN
7269 --------------------
7270  Seq Scan on t5
7271    Filter: (id = 1)
7272 (2 rows)
7273
7274 /*+ IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7275 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7276 LOG:  available indexes for IndexOnlyScanRegexp(t5):
7277 LOG:  pg_hint_plan:
7278 used hint:
7279 IndexOnlyScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7280 not used hint:
7281 duplication hint:
7282 error hint:
7283
7284      QUERY PLAN
7285 --------------------
7286  Seq Scan on t5
7287    Filter: (id = 1)
7288 (2 rows)
7289
7290 /*+ IndexOnlyScan(t5 t5_id[0-9].*)*/
7291 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7292 LOG:  available indexes for IndexOnlyScan(t5):
7293 LOG:  pg_hint_plan:
7294 used hint:
7295 IndexOnlyScan(t5 t5_id[0-9].*)
7296 not used hint:
7297 duplication hint:
7298 error hint:
7299
7300      QUERY PLAN
7301 --------------------
7302  Seq Scan on t5
7303    Filter: (id = 1)
7304 (2 rows)
7305
7306 /*+ BitmapScanRegexp(t5 t5_[^i].*)*/
7307 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7308 LOG:  available indexes for BitmapScanRegexp(t5): t5_val t5_pkey
7309 LOG:  pg_hint_plan:
7310 used hint:
7311 BitmapScanRegexp(t5 t5_[^i].*)
7312 not used hint:
7313 duplication hint:
7314 error hint:
7315
7316              QUERY PLAN
7317 ------------------------------------
7318  Bitmap Heap Scan on t5
7319    Recheck Cond: (id = 1)
7320    ->  Bitmap Index Scan on t5_pkey
7321          Index Cond: (id = 1)
7322 (4 rows)
7323
7324 /*+ BitmapScanRegexp(t5 t5_id[0-9].*)*/
7325 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7326 LOG:  available indexes for BitmapScanRegexp(t5): t5_id3 t5_id2 t5_id1
7327 LOG:  pg_hint_plan:
7328 used hint:
7329 BitmapScanRegexp(t5 t5_id[0-9].*)
7330 not used hint:
7331 duplication hint:
7332 error hint:
7333
7334             QUERY PLAN
7335 -----------------------------------
7336  Bitmap Heap Scan on t5
7337    Recheck Cond: (id = 1)
7338    ->  Bitmap Index Scan on t5_id3
7339          Index Cond: (id = 1)
7340 (4 rows)
7341
7342 /*+ BitmapScanRegexp(t5 t5[^_].*)*/
7343 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7344 LOG:  available indexes for BitmapScanRegexp(t5):
7345 LOG:  pg_hint_plan:
7346 used hint:
7347 BitmapScanRegexp(t5 t5[^_].*)
7348 not used hint:
7349 duplication hint:
7350 error hint:
7351
7352      QUERY PLAN
7353 --------------------
7354  Seq Scan on t5
7355    Filter: (id = 1)
7356 (2 rows)
7357
7358 /*+ BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)*/
7359 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7360 LOG:  available indexes for BitmapScanRegexp(t5):
7361 LOG:  pg_hint_plan:
7362 used hint:
7363 BitmapScanRegexp(t5 ^.*t5_idaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab)
7364 not used hint:
7365 duplication hint:
7366 error hint:
7367
7368      QUERY PLAN
7369 --------------------
7370  Seq Scan on t5
7371    Filter: (id = 1)
7372 (2 rows)
7373
7374 /*+ BitmapScan(t5 t5_id[0-9].*)*/
7375 EXPLAIN (COSTS false) SELECT id FROM t5 WHERE id = 1;
7376 LOG:  available indexes for BitmapScan(t5):
7377 LOG:  pg_hint_plan:
7378 used hint:
7379 BitmapScan(t5 t5_id[0-9].*)
7380 not used hint:
7381 duplication hint:
7382 error hint:
7383
7384      QUERY PLAN
7385 --------------------
7386  Seq Scan on t5
7387    Filter: (id = 1)
7388 (2 rows)
7389
7390 -- Inheritance
7391 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7392          QUERY PLAN
7393 ----------------------------
7394  Append
7395    ->  Seq Scan on p1
7396          Filter: (val = 1)
7397    ->  Seq Scan on p1_c1
7398          Filter: (val = 1)
7399    ->  Seq Scan on p1_c2
7400          Filter: (val = 1)
7401    ->  Seq Scan on p1_c3
7402          Filter: (val = 1)
7403    ->  Seq Scan on p1_c4
7404          Filter: (val = 1)
7405    ->  Seq Scan on p1_c1_c1
7406          Filter: (val = 1)
7407    ->  Seq Scan on p1_c1_c2
7408          Filter: (val = 1)
7409    ->  Seq Scan on p1_c3_c1
7410          Filter: (val = 1)
7411    ->  Seq Scan on p1_c3_c2
7412          Filter: (val = 1)
7413 (19 rows)
7414
7415 /*+ IndexScanRegexp(p1 p1_.*[^0-9]$)*/
7416 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7417 LOG:  available indexes for IndexScanRegexp(p1): p1_pkey
7418 LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_pkey
7419 LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_pkey
7420 LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_pkey
7421 LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_pkey
7422 LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7423 LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7424 LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7425 LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7426 LOG:  pg_hint_plan:
7427 used hint:
7428 IndexScanRegexp(p1 p1_.*[^0-9]$)
7429 not used hint:
7430 duplication hint:
7431 error hint:
7432
7433          QUERY PLAN
7434 ----------------------------
7435  Append
7436    ->  Seq Scan on p1
7437          Filter: (val = 1)
7438    ->  Seq Scan on p1_c1
7439          Filter: (val = 1)
7440    ->  Seq Scan on p1_c2
7441          Filter: (val = 1)
7442    ->  Seq Scan on p1_c3
7443          Filter: (val = 1)
7444    ->  Seq Scan on p1_c4
7445          Filter: (val = 1)
7446    ->  Seq Scan on p1_c1_c1
7447          Filter: (val = 1)
7448    ->  Seq Scan on p1_c1_c2
7449          Filter: (val = 1)
7450    ->  Seq Scan on p1_c3_c1
7451          Filter: (val = 1)
7452    ->  Seq Scan on p1_c3_c2
7453          Filter: (val = 1)
7454 (19 rows)
7455
7456 /*+ IndexScanRegexp(p1 p1_.*val2.*)*/
7457 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7458 LOG:  available indexes for IndexScanRegexp(p1): p1_val2
7459 LOG:  available indexes for IndexScanRegexp(p1_c1): p1_c1_val2
7460 LOG:  available indexes for IndexScanRegexp(p1_c2): p1_c2_val2
7461 LOG:  available indexes for IndexScanRegexp(p1_c3): p1_c3_val2
7462 LOG:  available indexes for IndexScanRegexp(p1_c4): p1_c4_val2
7463 LOG:  available indexes for IndexScanRegexp(p1_c1_c1): p1_c1_c1_val2
7464 LOG:  available indexes for IndexScanRegexp(p1_c1_c2): p1_c1_c2_val2
7465 LOG:  available indexes for IndexScanRegexp(p1_c3_c1): p1_c3_c1_val2
7466 LOG:  available indexes for IndexScanRegexp(p1_c3_c2): p1_c3_c2_val2
7467 LOG:  pg_hint_plan:
7468 used hint:
7469 IndexScanRegexp(p1 p1_.*val2.*)
7470 not used hint:
7471 duplication hint:
7472 error hint:
7473
7474                     QUERY PLAN
7475 --------------------------------------------------
7476  Append
7477    ->  Index Scan using p1_val2 on p1
7478          Index Cond: (val = 1)
7479    ->  Index Scan using p1_c1_val2 on p1_c1
7480          Index Cond: (val = 1)
7481    ->  Index Scan using p1_c2_val2 on p1_c2
7482          Index Cond: (val = 1)
7483    ->  Index Scan using p1_c3_val2 on p1_c3
7484          Index Cond: (val = 1)
7485    ->  Index Scan using p1_c4_val2 on p1_c4
7486          Index Cond: (val = 1)
7487    ->  Index Scan using p1_c1_c1_val2 on p1_c1_c1
7488          Index Cond: (val = 1)
7489    ->  Index Scan using p1_c1_c2_val2 on p1_c1_c2
7490          Index Cond: (val = 1)
7491    ->  Index Scan using p1_c3_c1_val2 on p1_c3_c1
7492          Index Cond: (val = 1)
7493    ->  Index Scan using p1_c3_c2_val2 on p1_c3_c2
7494          Index Cond: (val = 1)
7495 (19 rows)
7496
7497 /*+ IndexScanRegexp(p1 p1[^_].*)*/
7498 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7499 LOG:  available indexes for IndexScanRegexp(p1):
7500 LOG:  available indexes for IndexScanRegexp(p1_c1):
7501 LOG:  available indexes for IndexScanRegexp(p1_c2):
7502 LOG:  available indexes for IndexScanRegexp(p1_c3):
7503 LOG:  available indexes for IndexScanRegexp(p1_c4):
7504 LOG:  available indexes for IndexScanRegexp(p1_c1_c1):
7505 LOG:  available indexes for IndexScanRegexp(p1_c1_c2):
7506 LOG:  available indexes for IndexScanRegexp(p1_c3_c1):
7507 LOG:  available indexes for IndexScanRegexp(p1_c3_c2):
7508 LOG:  pg_hint_plan:
7509 used hint:
7510 IndexScanRegexp(p1 p1[^_].*)
7511 not used hint:
7512 duplication hint:
7513 error hint:
7514
7515          QUERY PLAN
7516 ----------------------------
7517  Append
7518    ->  Seq Scan on p1
7519          Filter: (val = 1)
7520    ->  Seq Scan on p1_c1
7521          Filter: (val = 1)
7522    ->  Seq Scan on p1_c2
7523          Filter: (val = 1)
7524    ->  Seq Scan on p1_c3
7525          Filter: (val = 1)
7526    ->  Seq Scan on p1_c4
7527          Filter: (val = 1)
7528    ->  Seq Scan on p1_c1_c1
7529          Filter: (val = 1)
7530    ->  Seq Scan on p1_c1_c2
7531          Filter: (val = 1)
7532    ->  Seq Scan on p1_c3_c1
7533          Filter: (val = 1)
7534    ->  Seq Scan on p1_c3_c2
7535          Filter: (val = 1)
7536 (19 rows)
7537
7538 /*+ IndexScan(p1 p1_.*val2.*)*/
7539 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7540 LOG:  available indexes for IndexScan(p1):
7541 LOG:  available indexes for IndexScan(p1_c1):
7542 LOG:  available indexes for IndexScan(p1_c2):
7543 LOG:  available indexes for IndexScan(p1_c3):
7544 LOG:  available indexes for IndexScan(p1_c4):
7545 LOG:  available indexes for IndexScan(p1_c1_c1):
7546 LOG:  available indexes for IndexScan(p1_c1_c2):
7547 LOG:  available indexes for IndexScan(p1_c3_c1):
7548 LOG:  available indexes for IndexScan(p1_c3_c2):
7549 LOG:  pg_hint_plan:
7550 used hint:
7551 IndexScan(p1 p1_.*val2.*)
7552 not used hint:
7553 duplication hint:
7554 error hint:
7555
7556          QUERY PLAN
7557 ----------------------------
7558  Append
7559    ->  Seq Scan on p1
7560          Filter: (val = 1)
7561    ->  Seq Scan on p1_c1
7562          Filter: (val = 1)
7563    ->  Seq Scan on p1_c2
7564          Filter: (val = 1)
7565    ->  Seq Scan on p1_c3
7566          Filter: (val = 1)
7567    ->  Seq Scan on p1_c4
7568          Filter: (val = 1)
7569    ->  Seq Scan on p1_c1_c1
7570          Filter: (val = 1)
7571    ->  Seq Scan on p1_c1_c2
7572          Filter: (val = 1)
7573    ->  Seq Scan on p1_c3_c1
7574          Filter: (val = 1)
7575    ->  Seq Scan on p1_c3_c2
7576          Filter: (val = 1)
7577 (19 rows)
7578
7579 /*+ IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)*/
7580 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7581 LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_pkey
7582 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_pkey
7583 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_pkey
7584 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_pkey
7585 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_pkey
7586 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7587 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7588 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7589 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7590 LOG:  pg_hint_plan:
7591 used hint:
7592 IndexOnlyScanRegexp(p1 p1_.*[^0-9]$)
7593 not used hint:
7594 duplication hint:
7595 error hint:
7596
7597          QUERY PLAN
7598 ----------------------------
7599  Append
7600    ->  Seq Scan on p1
7601          Filter: (val = 1)
7602    ->  Seq Scan on p1_c1
7603          Filter: (val = 1)
7604    ->  Seq Scan on p1_c2
7605          Filter: (val = 1)
7606    ->  Seq Scan on p1_c3
7607          Filter: (val = 1)
7608    ->  Seq Scan on p1_c4
7609          Filter: (val = 1)
7610    ->  Seq Scan on p1_c1_c1
7611          Filter: (val = 1)
7612    ->  Seq Scan on p1_c1_c2
7613          Filter: (val = 1)
7614    ->  Seq Scan on p1_c3_c1
7615          Filter: (val = 1)
7616    ->  Seq Scan on p1_c3_c2
7617          Filter: (val = 1)
7618 (19 rows)
7619
7620 /*+ IndexOnlyScanRegexp(p1 p1_.*val2.*)*/
7621 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7622 LOG:  available indexes for IndexOnlyScanRegexp(p1): p1_val2
7623 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1): p1_c1_val2
7624 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2): p1_c2_val2
7625 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3): p1_c3_val2
7626 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4): p1_c4_val2
7627 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1): p1_c1_c1_val2
7628 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2): p1_c1_c2_val2
7629 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1): p1_c3_c1_val2
7630 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2): p1_c3_c2_val2
7631 LOG:  pg_hint_plan:
7632 used hint:
7633 IndexOnlyScanRegexp(p1 p1_.*val2.*)
7634 not used hint:
7635 duplication hint:
7636 error hint:
7637
7638                       QUERY PLAN
7639 -------------------------------------------------------
7640  Append
7641    ->  Index Only Scan using p1_val2 on p1
7642          Index Cond: (val = 1)
7643    ->  Index Only Scan using p1_c1_val2 on p1_c1
7644          Index Cond: (val = 1)
7645    ->  Index Only Scan using p1_c2_val2 on p1_c2
7646          Index Cond: (val = 1)
7647    ->  Index Only Scan using p1_c3_val2 on p1_c3
7648          Index Cond: (val = 1)
7649    ->  Index Only Scan using p1_c4_val2 on p1_c4
7650          Index Cond: (val = 1)
7651    ->  Index Only Scan using p1_c1_c1_val2 on p1_c1_c1
7652          Index Cond: (val = 1)
7653    ->  Index Only Scan using p1_c1_c2_val2 on p1_c1_c2
7654          Index Cond: (val = 1)
7655    ->  Index Only Scan using p1_c3_c1_val2 on p1_c3_c1
7656          Index Cond: (val = 1)
7657    ->  Index Only Scan using p1_c3_c2_val2 on p1_c3_c2
7658          Index Cond: (val = 1)
7659 (19 rows)
7660
7661 /*+ IndexOnlyScanRegexp(p1 p1[^_].*)*/
7662 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7663 LOG:  available indexes for IndexOnlyScanRegexp(p1):
7664 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1):
7665 LOG:  available indexes for IndexOnlyScanRegexp(p1_c2):
7666 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3):
7667 LOG:  available indexes for IndexOnlyScanRegexp(p1_c4):
7668 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c1):
7669 LOG:  available indexes for IndexOnlyScanRegexp(p1_c1_c2):
7670 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c1):
7671 LOG:  available indexes for IndexOnlyScanRegexp(p1_c3_c2):
7672 LOG:  pg_hint_plan:
7673 used hint:
7674 IndexOnlyScanRegexp(p1 p1[^_].*)
7675 not used hint:
7676 duplication hint:
7677 error hint:
7678
7679          QUERY PLAN
7680 ----------------------------
7681  Append
7682    ->  Seq Scan on p1
7683          Filter: (val = 1)
7684    ->  Seq Scan on p1_c1
7685          Filter: (val = 1)
7686    ->  Seq Scan on p1_c2
7687          Filter: (val = 1)
7688    ->  Seq Scan on p1_c3
7689          Filter: (val = 1)
7690    ->  Seq Scan on p1_c4
7691          Filter: (val = 1)
7692    ->  Seq Scan on p1_c1_c1
7693          Filter: (val = 1)
7694    ->  Seq Scan on p1_c1_c2
7695          Filter: (val = 1)
7696    ->  Seq Scan on p1_c3_c1
7697          Filter: (val = 1)
7698    ->  Seq Scan on p1_c3_c2
7699          Filter: (val = 1)
7700 (19 rows)
7701
7702 /*+ IndexOnlyScan(p1 p1_.*val2.*)*/
7703 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7704 LOG:  available indexes for IndexOnlyScan(p1):
7705 LOG:  available indexes for IndexOnlyScan(p1_c1):
7706 LOG:  available indexes for IndexOnlyScan(p1_c2):
7707 LOG:  available indexes for IndexOnlyScan(p1_c3):
7708 LOG:  available indexes for IndexOnlyScan(p1_c4):
7709 LOG:  available indexes for IndexOnlyScan(p1_c1_c1):
7710 LOG:  available indexes for IndexOnlyScan(p1_c1_c2):
7711 LOG:  available indexes for IndexOnlyScan(p1_c3_c1):
7712 LOG:  available indexes for IndexOnlyScan(p1_c3_c2):
7713 LOG:  pg_hint_plan:
7714 used hint:
7715 IndexOnlyScan(p1 p1_.*val2.*)
7716 not used hint:
7717 duplication hint:
7718 error hint:
7719
7720          QUERY PLAN
7721 ----------------------------
7722  Append
7723    ->  Seq Scan on p1
7724          Filter: (val = 1)
7725    ->  Seq Scan on p1_c1
7726          Filter: (val = 1)
7727    ->  Seq Scan on p1_c2
7728          Filter: (val = 1)
7729    ->  Seq Scan on p1_c3
7730          Filter: (val = 1)
7731    ->  Seq Scan on p1_c4
7732          Filter: (val = 1)
7733    ->  Seq Scan on p1_c1_c1
7734          Filter: (val = 1)
7735    ->  Seq Scan on p1_c1_c2
7736          Filter: (val = 1)
7737    ->  Seq Scan on p1_c3_c1
7738          Filter: (val = 1)
7739    ->  Seq Scan on p1_c3_c2
7740          Filter: (val = 1)
7741 (19 rows)
7742
7743 /*+ BitmapScanRegexp(p1 p1_.*[^0-9]$)*/
7744 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7745 LOG:  available indexes for BitmapScanRegexp(p1): p1_pkey
7746 LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_pkey
7747 LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_pkey
7748 LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_pkey
7749 LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_pkey
7750 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_pkey
7751 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_pkey
7752 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_pkey
7753 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_pkey
7754 LOG:  pg_hint_plan:
7755 used hint:
7756 BitmapScanRegexp(p1 p1_.*[^0-9]$)
7757 not used hint:
7758 duplication hint:
7759 error hint:
7760
7761          QUERY PLAN
7762 ----------------------------
7763  Append
7764    ->  Seq Scan on p1
7765          Filter: (val = 1)
7766    ->  Seq Scan on p1_c1
7767          Filter: (val = 1)
7768    ->  Seq Scan on p1_c2
7769          Filter: (val = 1)
7770    ->  Seq Scan on p1_c3
7771          Filter: (val = 1)
7772    ->  Seq Scan on p1_c4
7773          Filter: (val = 1)
7774    ->  Seq Scan on p1_c1_c1
7775          Filter: (val = 1)
7776    ->  Seq Scan on p1_c1_c2
7777          Filter: (val = 1)
7778    ->  Seq Scan on p1_c3_c1
7779          Filter: (val = 1)
7780    ->  Seq Scan on p1_c3_c2
7781          Filter: (val = 1)
7782 (19 rows)
7783
7784 /*+ BitmapScanRegexp(p1 p1_.*val2.*)*/
7785 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7786 LOG:  available indexes for BitmapScanRegexp(p1): p1_val2
7787 LOG:  available indexes for BitmapScanRegexp(p1_c1): p1_c1_val2
7788 LOG:  available indexes for BitmapScanRegexp(p1_c2): p1_c2_val2
7789 LOG:  available indexes for BitmapScanRegexp(p1_c3): p1_c3_val2
7790 LOG:  available indexes for BitmapScanRegexp(p1_c4): p1_c4_val2
7791 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1): p1_c1_c1_val2
7792 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2): p1_c1_c2_val2
7793 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1): p1_c3_c1_val2
7794 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2): p1_c3_c2_val2
7795 LOG:  pg_hint_plan:
7796 used hint:
7797 BitmapScanRegexp(p1 p1_.*val2.*)
7798 not used hint:
7799 duplication hint:
7800 error hint:
7801
7802                    QUERY PLAN
7803 ------------------------------------------------
7804  Append
7805    ->  Bitmap Heap Scan on p1
7806          Recheck Cond: (val = 1)
7807          ->  Bitmap Index Scan on p1_val2
7808                Index Cond: (val = 1)
7809    ->  Bitmap Heap Scan on p1_c1
7810          Recheck Cond: (val = 1)
7811          ->  Bitmap Index Scan on p1_c1_val2
7812                Index Cond: (val = 1)
7813    ->  Bitmap Heap Scan on p1_c2
7814          Recheck Cond: (val = 1)
7815          ->  Bitmap Index Scan on p1_c2_val2
7816                Index Cond: (val = 1)
7817    ->  Bitmap Heap Scan on p1_c3
7818          Recheck Cond: (val = 1)
7819          ->  Bitmap Index Scan on p1_c3_val2
7820                Index Cond: (val = 1)
7821    ->  Bitmap Heap Scan on p1_c4
7822          Recheck Cond: (val = 1)
7823          ->  Bitmap Index Scan on p1_c4_val2
7824                Index Cond: (val = 1)
7825    ->  Bitmap Heap Scan on p1_c1_c1
7826          Recheck Cond: (val = 1)
7827          ->  Bitmap Index Scan on p1_c1_c1_val2
7828                Index Cond: (val = 1)
7829    ->  Bitmap Heap Scan on p1_c1_c2
7830          Recheck Cond: (val = 1)
7831          ->  Bitmap Index Scan on p1_c1_c2_val2
7832                Index Cond: (val = 1)
7833    ->  Bitmap Heap Scan on p1_c3_c1
7834          Recheck Cond: (val = 1)
7835          ->  Bitmap Index Scan on p1_c3_c1_val2
7836                Index Cond: (val = 1)
7837    ->  Bitmap Heap Scan on p1_c3_c2
7838          Recheck Cond: (val = 1)
7839          ->  Bitmap Index Scan on p1_c3_c2_val2
7840                Index Cond: (val = 1)
7841 (37 rows)
7842
7843 /*+ BitmapScanRegexp(p1 p1[^_].*)*/
7844 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7845 LOG:  available indexes for BitmapScanRegexp(p1):
7846 LOG:  available indexes for BitmapScanRegexp(p1_c1):
7847 LOG:  available indexes for BitmapScanRegexp(p1_c2):
7848 LOG:  available indexes for BitmapScanRegexp(p1_c3):
7849 LOG:  available indexes for BitmapScanRegexp(p1_c4):
7850 LOG:  available indexes for BitmapScanRegexp(p1_c1_c1):
7851 LOG:  available indexes for BitmapScanRegexp(p1_c1_c2):
7852 LOG:  available indexes for BitmapScanRegexp(p1_c3_c1):
7853 LOG:  available indexes for BitmapScanRegexp(p1_c3_c2):
7854 LOG:  pg_hint_plan:
7855 used hint:
7856 BitmapScanRegexp(p1 p1[^_].*)
7857 not used hint:
7858 duplication hint:
7859 error hint:
7860
7861          QUERY PLAN
7862 ----------------------------
7863  Append
7864    ->  Seq Scan on p1
7865          Filter: (val = 1)
7866    ->  Seq Scan on p1_c1
7867          Filter: (val = 1)
7868    ->  Seq Scan on p1_c2
7869          Filter: (val = 1)
7870    ->  Seq Scan on p1_c3
7871          Filter: (val = 1)
7872    ->  Seq Scan on p1_c4
7873          Filter: (val = 1)
7874    ->  Seq Scan on p1_c1_c1
7875          Filter: (val = 1)
7876    ->  Seq Scan on p1_c1_c2
7877          Filter: (val = 1)
7878    ->  Seq Scan on p1_c3_c1
7879          Filter: (val = 1)
7880    ->  Seq Scan on p1_c3_c2
7881          Filter: (val = 1)
7882 (19 rows)
7883
7884 /*+ BitmapScan(p1 p1_.*val2.*)*/
7885 EXPLAIN (COSTS false) SELECT val FROM p1 WHERE val = 1;
7886 LOG:  available indexes for BitmapScan(p1):
7887 LOG:  available indexes for BitmapScan(p1_c1):
7888 LOG:  available indexes for BitmapScan(p1_c2):
7889 LOG:  available indexes for BitmapScan(p1_c3):
7890 LOG:  available indexes for BitmapScan(p1_c4):
7891 LOG:  available indexes for BitmapScan(p1_c1_c1):
7892 LOG:  available indexes for BitmapScan(p1_c1_c2):
7893 LOG:  available indexes for BitmapScan(p1_c3_c1):
7894 LOG:  available indexes for BitmapScan(p1_c3_c2):
7895 LOG:  pg_hint_plan:
7896 used hint:
7897 BitmapScan(p1 p1_.*val2.*)
7898 not used hint:
7899 duplication hint:
7900 error hint:
7901
7902          QUERY PLAN
7903 ----------------------------
7904  Append
7905    ->  Seq Scan on p1
7906          Filter: (val = 1)
7907    ->  Seq Scan on p1_c1
7908          Filter: (val = 1)
7909    ->  Seq Scan on p1_c2
7910          Filter: (val = 1)
7911    ->  Seq Scan on p1_c3
7912          Filter: (val = 1)
7913    ->  Seq Scan on p1_c4
7914          Filter: (val = 1)
7915    ->  Seq Scan on p1_c1_c1
7916          Filter: (val = 1)
7917    ->  Seq Scan on p1_c1_c2
7918          Filter: (val = 1)
7919    ->  Seq Scan on p1_c3_c1
7920          Filter: (val = 1)
7921    ->  Seq Scan on p1_c3_c2
7922          Filter: (val = 1)
7923 (19 rows)
7924
7925 -- search from hint table
7926 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;', '', 'SeqScan(t1)');
7927 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?;', '', 'IndexScan(t1)');
7928 INSERT INTO hint_plan.hints (norm_query_string, application_name, hints) VALUES ('EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;', '', 'BitmapScan(t1)');
7929 SELECT * FROM hint_plan.hints ORDER BY id;
7930  id |                    norm_query_string                     | application_name |     hints
7931 ----+----------------------------------------------------------+------------------+----------------
7932   1 | EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = ?;  |                  | SeqScan(t1)
7933   2 | EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = ?; |                  | IndexScan(t1)
7934   3 | EXPLAIN SELECT * FROM t1 WHERE t1.id = ?;                |                  | BitmapScan(t1)
7935 (3 rows)
7936
7937 SET pg_hint_plan.enable_hint_table = on;
7938 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7939 LOG:  pg_hint_plan:
7940 used hint:
7941 SeqScan(t1)
7942 not used hint:
7943 duplication hint:
7944 error hint:
7945
7946      QUERY PLAN
7947 --------------------
7948  Seq Scan on t1
7949    Filter: (id = 1)
7950 (2 rows)
7951
7952 SET pg_hint_plan.enable_hint_table = off;
7953 EXPLAIN (COSTS false) SELECT * FROM t1 WHERE t1.id = 1;
7954            QUERY PLAN
7955 --------------------------------
7956  Index Scan using t1_pkey on t1
7957    Index Cond: (id = 1)
7958 (2 rows)
7959
7960 TRUNCATE hint_plan.hints;
7961 VACUUM ANALYZE hint_plan.hints;
7962 -- plpgsql test
7963 EXPLAIN (COSTS false) SELECT id FROM t1 WHERE t1.id = 1;
7964              QUERY PLAN
7965 -------------------------------------
7966  Index Only Scan using t1_pkey on t1
7967    Index Cond: (id = 1)
7968 (2 rows)
7969
7970 DO LANGUAGE plpgsql $$
7971 DECLARE
7972     id integer;
7973 BEGIN
7974         SELECT /*+SeqScan(t1)*/ t1.id INTO id FROM t1 WHERE t1.id = 1;
7975         RETURN;
7976 END;
7977 $$;
7978 LOG:  pg_hint_plan:
7979 used hint:
7980 SeqScan(t1)
7981 not used hint:
7982 duplication hint:
7983 error hint:
7984
7985 CONTEXT:  SQL statement "SELECT /*+SeqScan(t1)*/ t1.id         FROM t1 WHERE t1.id = 1"
7986 PL/pgSQL function inline_code_block line 5 at SQL statement
7987 DROP EXTENSION pg_hint_plan;