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