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