expected/prepare-9.1.out

   1 LOAD 'pg_hint_plan';
   2 SET search_path TO public;
   3 SET pg_hint_plan.enable TO on;
   4 SET pg_hint_plan.debug_print TO on;
   5 SET client_min_messages TO LOG;
   6 EXPLAIN (COSTS false) SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id;
   7                  QUERY PLAN
   8 --------------------------------------------
   9  Aggregate
  10    ->  Merge Join
  11          Merge Cond: (t1.id = t2.id)
  12          ->  Index Scan using t1_pkey on t1
  13          ->  Index Scan using t2_pkey on t2
  14 (5 rows)
  15
  16 EXPLAIN (COSTS false) SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > 10;
  17                  QUERY PLAN
  18 --------------------------------------------
  19  Aggregate
  20    ->  Merge Join
  21          Merge Cond: (t1.id = t2.id)
  22          ->  Index Scan using t1_pkey on t1
  23                Index Cond: (id > 10)
  24          ->  Index Scan using t2_pkey on t2
  25 (6 rows)
  26
  27 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
  28 -- 9.2:PREPAREでヒント句を指定しても、実行計画は制御できない
  29 /*+ NestLoop(t1 t2) */
  30 PREPARE p1 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id;
  31 LOG:  pg_hint_plan:
  32 used hint:
  33 NestLoop(t1 t2)
  34 not used hint:
  35 duplication hint:
  36 error hint:
  37
  38 EXPLAIN (COSTS false) EXECUTE p1;
  39                  QUERY PLAN
  40 --------------------------------------------
  41  Aggregate
  42    ->  Nested Loop
  43          ->  Seq Scan on t2
  44          ->  Index Scan using t1_pkey on t1
  45                Index Cond: (id = t2.id)
  46 (5 rows)
  47
  48 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
  49 -- 9.2:パラメータがない場合は、1回目のEXPLAINで実行計画が決定する
  50 /*+ NestLoop(t1 t2) */
  51 PREPARE p2 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id;
  52 LOG:  pg_hint_plan:
  53 used hint:
  54 NestLoop(t1 t2)
  55 not used hint:
  56 duplication hint:
  57 error hint:
  58
  59 /*+ HashJoin(t1 t2) */
  60 EXPLAIN (COSTS false) EXECUTE p2;
  61                  QUERY PLAN
  62 --------------------------------------------
  63  Aggregate
  64    ->  Nested Loop
  65          ->  Seq Scan on t2
  66          ->  Index Scan using t1_pkey on t1
  67                Index Cond: (id = t2.id)
  68 (5 rows)
  69
  70 EXPLAIN (COSTS false) EXECUTE p2;
  71                  QUERY PLAN
  72 --------------------------------------------
  73  Aggregate
  74    ->  Nested Loop
  75          ->  Seq Scan on t2
  76          ->  Index Scan using t1_pkey on t1
  77                Index Cond: (id = t2.id)
  78 (5 rows)
  79
  80 EXPLAIN (COSTS false) EXECUTE p2;
  81                  QUERY PLAN
  82 --------------------------------------------
  83  Aggregate
  84    ->  Nested Loop
  85          ->  Seq Scan on t2
  86          ->  Index Scan using t1_pkey on t1
  87                Index Cond: (id = t2.id)
  88 (5 rows)
  89
  90 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
  91 -- 9.2:5回目のEXPLAINまでヒント句を指定しても、6回目以降は本来の実行計画に戻る
  92 /*+ NestLoop(t1 t2) */
  93 PREPARE p3 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > $1;
  94 LOG:  pg_hint_plan:
  95 used hint:
  96 NestLoop(t1 t2)
  97 not used hint:
  98 duplication hint:
  99 error hint:
 100
 101 /*+ HashJoin(t1 t2) */
 102 EXPLAIN (COSTS false) EXECUTE p3 (10);
 103                        QUERY PLAN
 104 --------------------------------------------------------
 105  Aggregate
 106    ->  Nested Loop
 107          ->  Seq Scan on t2
 108          ->  Index Scan using t1_pkey on t1
 109                Index Cond: ((id > $1) AND (id = t2.id))
 110 (5 rows)
 111
 112 /*+ HashJoin(t1 t2) */
 113 EXPLAIN (COSTS false) EXECUTE p3 (10);
 114                        QUERY PLAN
 115 --------------------------------------------------------
 116  Aggregate
 117    ->  Nested Loop
 118          ->  Seq Scan on t2
 119          ->  Index Scan using t1_pkey on t1
 120                Index Cond: ((id > $1) AND (id = t2.id))
 121 (5 rows)
 122
 123 /*+ HashJoin(t1 t2) */
 124 EXPLAIN (COSTS false) EXECUTE p3 (10);
 125                        QUERY PLAN
 126 --------------------------------------------------------
 127  Aggregate
 128    ->  Nested Loop
 129          ->  Seq Scan on t2
 130          ->  Index Scan using t1_pkey on t1
 131                Index Cond: ((id > $1) AND (id = t2.id))
 132 (5 rows)
 133
 134 /*+ HashJoin(t1 t2) */
 135 EXPLAIN (COSTS false) EXECUTE p3 (10);
 136                        QUERY PLAN
 137 --------------------------------------------------------
 138  Aggregate
 139    ->  Nested Loop
 140          ->  Seq Scan on t2
 141          ->  Index Scan using t1_pkey on t1
 142                Index Cond: ((id > $1) AND (id = t2.id))
 143 (5 rows)
 144
 145 /*+ HashJoin(t1 t2) */
 146 EXPLAIN (COSTS false) EXECUTE p3 (10);
 147                        QUERY PLAN
 148 --------------------------------------------------------
 149  Aggregate
 150    ->  Nested Loop
 151          ->  Seq Scan on t2
 152          ->  Index Scan using t1_pkey on t1
 153                Index Cond: ((id > $1) AND (id = t2.id))
 154 (5 rows)
 155
 156 EXPLAIN (COSTS false) EXECUTE p3 (10);
 157                        QUERY PLAN
 158 --------------------------------------------------------
 159  Aggregate
 160    ->  Nested Loop
 161          ->  Seq Scan on t2
 162          ->  Index Scan using t1_pkey on t1
 163                Index Cond: ((id > $1) AND (id = t2.id))
 164 (5 rows)
 165
 166 EXPLAIN (COSTS false) EXECUTE p3 (10);
 167                        QUERY PLAN
 168 --------------------------------------------------------
 169  Aggregate
 170    ->  Nested Loop
 171          ->  Seq Scan on t2
 172          ->  Index Scan using t1_pkey on t1
 173                Index Cond: ((id > $1) AND (id = t2.id))
 174 (5 rows)
 175
 176 EXPLAIN (COSTS false) EXECUTE p3 (10);
 177                        QUERY PLAN
 178 --------------------------------------------------------
 179  Aggregate
 180    ->  Nested Loop
 181          ->  Seq Scan on t2
 182          ->  Index Scan using t1_pkey on t1
 183                Index Cond: ((id > $1) AND (id = t2.id))
 184 (5 rows)
 185
 186 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
 187 -- 9.2:6回目のEXPLAINまでヒント句を指定すると、7回目以降も実行計画が固定される
 188 /*+ NestLoop(t1 t2) */
 189 PREPARE p4 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > $1;
 190 LOG:  pg_hint_plan:
 191 used hint:
 192 NestLoop(t1 t2)
 193 not used hint:
 194 duplication hint:
 195 error hint:
 196
 197 /*+ HashJoin(t1 t2) */
 198 EXPLAIN (COSTS false) EXECUTE p4 (10);
 199                        QUERY PLAN
 200 --------------------------------------------------------
 201  Aggregate
 202    ->  Nested Loop
 203          ->  Seq Scan on t2
 204          ->  Index Scan using t1_pkey on t1
 205                Index Cond: ((id > $1) AND (id = t2.id))
 206 (5 rows)
 207
 208 /*+ HashJoin(t1 t2) */
 209 EXPLAIN (COSTS false) EXECUTE p4 (10);
 210                        QUERY PLAN
 211 --------------------------------------------------------
 212  Aggregate
 213    ->  Nested Loop
 214          ->  Seq Scan on t2
 215          ->  Index Scan using t1_pkey on t1
 216                Index Cond: ((id > $1) AND (id = t2.id))
 217 (5 rows)
 218
 219 /*+ HashJoin(t1 t2) */
 220 EXPLAIN (COSTS false) EXECUTE p4 (10);
 221                        QUERY PLAN
 222 --------------------------------------------------------
 223  Aggregate
 224    ->  Nested Loop
 225          ->  Seq Scan on t2
 226          ->  Index Scan using t1_pkey on t1
 227                Index Cond: ((id > $1) AND (id = t2.id))
 228 (5 rows)
 229
 230 /*+ HashJoin(t1 t2) */
 231 EXPLAIN (COSTS false) EXECUTE p4 (10);
 232                        QUERY PLAN
 233 --------------------------------------------------------
 234  Aggregate
 235    ->  Nested Loop
 236          ->  Seq Scan on t2
 237          ->  Index Scan using t1_pkey on t1
 238                Index Cond: ((id > $1) AND (id = t2.id))
 239 (5 rows)
 240
 241 /*+ HashJoin(t1 t2) */
 242 EXPLAIN (COSTS false) EXECUTE p4 (10);
 243                        QUERY PLAN
 244 --------------------------------------------------------
 245  Aggregate
 246    ->  Nested Loop
 247          ->  Seq Scan on t2
 248          ->  Index Scan using t1_pkey on t1
 249                Index Cond: ((id > $1) AND (id = t2.id))
 250 (5 rows)
 251
 252 /*+ HashJoin(t1 t2) */
 253 EXPLAIN (COSTS false) EXECUTE p4 (10);
 254                        QUERY PLAN
 255 --------------------------------------------------------
 256  Aggregate
 257    ->  Nested Loop
 258          ->  Seq Scan on t2
 259          ->  Index Scan using t1_pkey on t1
 260                Index Cond: ((id > $1) AND (id = t2.id))
 261 (5 rows)
 262
 263 EXPLAIN (COSTS false) EXECUTE p4 (10);
 264                        QUERY PLAN
 265 --------------------------------------------------------
 266  Aggregate
 267    ->  Nested Loop
 268          ->  Seq Scan on t2
 269          ->  Index Scan using t1_pkey on t1
 270                Index Cond: ((id > $1) AND (id = t2.id))
 271 (5 rows)
 272
 273 EXPLAIN (COSTS false) EXECUTE p4 (10);
 274                        QUERY PLAN
 275 --------------------------------------------------------
 276  Aggregate
 277    ->  Nested Loop
 278          ->  Seq Scan on t2
 279          ->  Index Scan using t1_pkey on t1
 280                Index Cond: ((id > $1) AND (id = t2.id))
 281 (5 rows)
 282
 283 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
 284 -- 9.2:6回目のEXPLAINでヒント句を指定すると、7回目以降も実行計画を制御できる
 285 /*+ NestLoop(t1 t2) */
 286 PREPARE p5 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > $1;
 287 LOG:  pg_hint_plan:
 288 used hint:
 289 NestLoop(t1 t2)
 290 not used hint:
 291 duplication hint:
 292 error hint:
 293
 294 EXPLAIN (COSTS false) EXECUTE p5 (10);
 295                        QUERY PLAN
 296 --------------------------------------------------------
 297  Aggregate
 298    ->  Nested Loop
 299          ->  Seq Scan on t2
 300          ->  Index Scan using t1_pkey on t1
 301                Index Cond: ((id > $1) AND (id = t2.id))
 302 (5 rows)
 303
 304 EXPLAIN (COSTS false) EXECUTE p5 (10);
 305                        QUERY PLAN
 306 --------------------------------------------------------
 307  Aggregate
 308    ->  Nested Loop
 309          ->  Seq Scan on t2
 310          ->  Index Scan using t1_pkey on t1
 311                Index Cond: ((id > $1) AND (id = t2.id))
 312 (5 rows)
 313
 314 EXPLAIN (COSTS false) EXECUTE p5 (10);
 315                        QUERY PLAN
 316 --------------------------------------------------------
 317  Aggregate
 318    ->  Nested Loop
 319          ->  Seq Scan on t2
 320          ->  Index Scan using t1_pkey on t1
 321                Index Cond: ((id > $1) AND (id = t2.id))
 322 (5 rows)
 323
 324 EXPLAIN (COSTS false) EXECUTE p5 (10);
 325                        QUERY PLAN
 326 --------------------------------------------------------
 327  Aggregate
 328    ->  Nested Loop
 329          ->  Seq Scan on t2
 330          ->  Index Scan using t1_pkey on t1
 331                Index Cond: ((id > $1) AND (id = t2.id))
 332 (5 rows)
 333
 334 EXPLAIN (COSTS false) EXECUTE p5 (10);
 335                        QUERY PLAN
 336 --------------------------------------------------------
 337  Aggregate
 338    ->  Nested Loop
 339          ->  Seq Scan on t2
 340          ->  Index Scan using t1_pkey on t1
 341                Index Cond: ((id > $1) AND (id = t2.id))
 342 (5 rows)
 343
 344 /*+ HashJoin(t1 t2) */
 345 EXPLAIN (COSTS false) EXECUTE p5 (10);
 346                        QUERY PLAN
 347 --------------------------------------------------------
 348  Aggregate
 349    ->  Nested Loop
 350          ->  Seq Scan on t2
 351          ->  Index Scan using t1_pkey on t1
 352                Index Cond: ((id > $1) AND (id = t2.id))
 353 (5 rows)
 354
 355 /*+ HashJoin(t1 t2) */
 356 EXPLAIN (COSTS false) EXECUTE p5 (10);
 357                        QUERY PLAN
 358 --------------------------------------------------------
 359  Aggregate
 360    ->  Nested Loop
 361          ->  Seq Scan on t2
 362          ->  Index Scan using t1_pkey on t1
 363                Index Cond: ((id > $1) AND (id = t2.id))
 364 (5 rows)
 365
 366 /*+ HashJoin(t1 t2) */
 367 EXPLAIN (COSTS false) EXECUTE p5 (10);
 368                        QUERY PLAN
 369 --------------------------------------------------------
 370  Aggregate
 371    ->  Nested Loop
 372          ->  Seq Scan on t2
 373          ->  Index Scan using t1_pkey on t1
 374                Index Cond: ((id > $1) AND (id = t2.id))
 375 (5 rows)
 376
 377 -- 9.1:PREPAREで指定したヒント句で実行計画が固定される
 378 -- 9.2:7回目以降のEXPLAINでヒント句を指定しても、以降も実行計画は制御できない
 379 /*+ NestLoop(t1 t2) */
 380 PREPARE p6 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > $1;
 381 LOG:  pg_hint_plan:
 382 used hint:
 383 NestLoop(t1 t2)
 384 not used hint:
 385 duplication hint:
 386 error hint:
 387
 388 EXPLAIN (COSTS false) EXECUTE p6 (10);
 389                        QUERY PLAN
 390 --------------------------------------------------------
 391  Aggregate
 392    ->  Nested Loop
 393          ->  Seq Scan on t2
 394          ->  Index Scan using t1_pkey on t1
 395                Index Cond: ((id > $1) AND (id = t2.id))
 396 (5 rows)
 397
 398 EXPLAIN (COSTS false) EXECUTE p6 (10);
 399                        QUERY PLAN
 400 --------------------------------------------------------
 401  Aggregate
 402    ->  Nested Loop
 403          ->  Seq Scan on t2
 404          ->  Index Scan using t1_pkey on t1
 405                Index Cond: ((id > $1) AND (id = t2.id))
 406 (5 rows)
 407
 408 EXPLAIN (COSTS false) EXECUTE p6 (10);
 409                        QUERY PLAN
 410 --------------------------------------------------------
 411  Aggregate
 412    ->  Nested Loop
 413          ->  Seq Scan on t2
 414          ->  Index Scan using t1_pkey on t1
 415                Index Cond: ((id > $1) AND (id = t2.id))
 416 (5 rows)
 417
 418 EXPLAIN (COSTS false) EXECUTE p6 (10);
 419                        QUERY PLAN
 420 --------------------------------------------------------
 421  Aggregate
 422    ->  Nested Loop
 423          ->  Seq Scan on t2
 424          ->  Index Scan using t1_pkey on t1
 425                Index Cond: ((id > $1) AND (id = t2.id))
 426 (5 rows)
 427
 428 EXPLAIN (COSTS false) EXECUTE p6 (10);
 429                        QUERY PLAN
 430 --------------------------------------------------------
 431  Aggregate
 432    ->  Nested Loop
 433          ->  Seq Scan on t2
 434          ->  Index Scan using t1_pkey on t1
 435                Index Cond: ((id > $1) AND (id = t2.id))
 436 (5 rows)
 437
 438 EXPLAIN (COSTS false) EXECUTE p6 (10);
 439                        QUERY PLAN
 440 --------------------------------------------------------
 441  Aggregate
 442    ->  Nested Loop
 443          ->  Seq Scan on t2
 444          ->  Index Scan using t1_pkey on t1
 445                Index Cond: ((id > $1) AND (id = t2.id))
 446 (5 rows)
 447
 448 /*+ HashJoin(t1 t2) */
 449 EXPLAIN (COSTS false) EXECUTE p6 (10);
 450                        QUERY PLAN
 451 --------------------------------------------------------
 452  Aggregate
 453    ->  Nested Loop
 454          ->  Seq Scan on t2
 455          ->  Index Scan using t1_pkey on t1
 456                Index Cond: ((id > $1) AND (id = t2.id))
 457 (5 rows)
 458
 459 /*+ HashJoin(t1 t2) */
 460 EXPLAIN (COSTS false) EXECUTE p6 (10);
 461                        QUERY PLAN
 462 --------------------------------------------------------
 463  Aggregate
 464    ->  Nested Loop
 465          ->  Seq Scan on t2
 466          ->  Index Scan using t1_pkey on t1
 467                Index Cond: ((id > $1) AND (id = t2.id))
 468 (5 rows)
 469
 470 -- 9.1:実行計画が固定されたあと、ANALYZEをすると1回目のEXECUTEで実行計画が固定される
 471 -- 9.2:実行計画が固定されたあと、ANALYZEをすると1回目のEXECUTEで実行計画が固定される
 472 /*+ NestLoop(t1 t2) */
 473 PREPARE p7 AS SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > $1;
 474 LOG:  pg_hint_plan:
 475 used hint:
 476 NestLoop(t1 t2)
 477 not used hint:
 478 duplication hint:
 479 error hint:
 480
 481 /*+ HashJoin(t1 t2) */
 482 EXPLAIN (COSTS false) EXECUTE p7 (10);
 483                        QUERY PLAN
 484 --------------------------------------------------------
 485  Aggregate
 486    ->  Nested Loop
 487          ->  Seq Scan on t2
 488          ->  Index Scan using t1_pkey on t1
 489                Index Cond: ((id > $1) AND (id = t2.id))
 490 (5 rows)
 491
 492 /*+ HashJoin(t1 t2) */
 493 EXPLAIN (COSTS false) EXECUTE p7 (10);
 494                        QUERY PLAN
 495 --------------------------------------------------------
 496  Aggregate
 497    ->  Nested Loop
 498          ->  Seq Scan on t2
 499          ->  Index Scan using t1_pkey on t1
 500                Index Cond: ((id > $1) AND (id = t2.id))
 501 (5 rows)
 502
 503 /*+ HashJoin(t1 t2) */
 504 EXPLAIN (COSTS false) EXECUTE p7 (10);
 505                        QUERY PLAN
 506 --------------------------------------------------------
 507  Aggregate
 508    ->  Nested Loop
 509          ->  Seq Scan on t2
 510          ->  Index Scan using t1_pkey on t1
 511                Index Cond: ((id > $1) AND (id = t2.id))
 512 (5 rows)
 513
 514 /*+ HashJoin(t1 t2) */
 515 EXPLAIN (COSTS false) EXECUTE p7 (10);
 516                        QUERY PLAN
 517 --------------------------------------------------------
 518  Aggregate
 519    ->  Nested Loop
 520          ->  Seq Scan on t2
 521          ->  Index Scan using t1_pkey on t1
 522                Index Cond: ((id > $1) AND (id = t2.id))
 523 (5 rows)
 524
 525 /*+ HashJoin(t1 t2) */
 526 EXPLAIN (COSTS false) EXECUTE p7 (10);
 527                        QUERY PLAN
 528 --------------------------------------------------------
 529  Aggregate
 530    ->  Nested Loop
 531          ->  Seq Scan on t2
 532          ->  Index Scan using t1_pkey on t1
 533                Index Cond: ((id > $1) AND (id = t2.id))
 534 (5 rows)
 535
 536 /*+ HashJoin(t1 t2) */
 537 EXPLAIN (COSTS false) EXECUTE p7 (10);
 538                        QUERY PLAN
 539 --------------------------------------------------------
 540  Aggregate
 541    ->  Nested Loop
 542          ->  Seq Scan on t2
 543          ->  Index Scan using t1_pkey on t1
 544                Index Cond: ((id > $1) AND (id = t2.id))
 545 (5 rows)
 546
 547 EXPLAIN (COSTS false) EXECUTE p7 (10);
 548                        QUERY PLAN
 549 --------------------------------------------------------
 550  Aggregate
 551    ->  Nested Loop
 552          ->  Seq Scan on t2
 553          ->  Index Scan using t1_pkey on t1
 554                Index Cond: ((id > $1) AND (id = t2.id))
 555 (5 rows)
 556
 557 EXPLAIN (COSTS false) EXECUTE p7 (10);
 558                        QUERY PLAN
 559 --------------------------------------------------------
 560  Aggregate
 561    ->  Nested Loop
 562          ->  Seq Scan on t2
 563          ->  Index Scan using t1_pkey on t1
 564                Index Cond: ((id > $1) AND (id = t2.id))
 565 (5 rows)
 566
 567 TRUNCATE t1;
 568 ANALYZE t1;
 569 EXPLAIN (COSTS false) SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > 10;
 570                  QUERY PLAN
 571 --------------------------------------------
 572  Aggregate
 573    ->  Merge Join
 574          Merge Cond: (t1.id = t2.id)
 575          ->  Index Scan using t1_pkey on t1
 576                Index Cond: (id > 10)
 577          ->  Index Scan using t2_pkey on t2
 578 (6 rows)
 579
 580 EXPLAIN (COSTS false) EXECUTE p7 (10);
 581 LOG:  pg_hint_plan:
 582 used hint:
 583 NestLoop(t1 t2)
 584 not used hint:
 585 duplication hint:
 586 error hint:
 587
 588                  QUERY PLAN
 589 --------------------------------------------
 590  Aggregate
 591    ->  Nested Loop
 592          ->  Index Scan using t1_pkey on t1
 593                Index Cond: (id > $1)
 594          ->  Index Scan using t2_pkey on t2
 595                Index Cond: (id = t1.id)
 596 (6 rows)
 597
 598 /*+ HashJoin(t1 t2) */
 599 EXPLAIN (COSTS false) EXECUTE p7 (10);
 600                  QUERY PLAN
 601 --------------------------------------------
 602  Aggregate
 603    ->  Nested Loop
 604          ->  Index Scan using t1_pkey on t1
 605                Index Cond: (id > $1)
 606          ->  Index Scan using t2_pkey on t2
 607                Index Cond: (id = t1.id)
 608 (6 rows)
 609
 610 INSERT INTO t1 SELECT i, i % 100 FROM (SELECT generate_series(1, 10000) i) t;
 611 ANALYZE t1;
 612 EXPLAIN (COSTS false) SELECT count(*) FROM t1, t2 WHERE t1.id = t2.id AND t1.id > 10;
 613                  QUERY PLAN
 614 --------------------------------------------
 615  Aggregate
 616    ->  Merge Join
 617          Merge Cond: (t1.id = t2.id)
 618          ->  Index Scan using t1_pkey on t1
 619                Index Cond: (id > 10)
 620          ->  Index Scan using t2_pkey on t2
 621 (6 rows)
 622
 623 /*+ HashJoin(t1 t2) */
 624 EXPLAIN (COSTS false) EXECUTE p7 (10);
 625 LOG:  pg_hint_plan:
 626 used hint:
 627 NestLoop(t1 t2)
 628 not used hint:
 629 duplication hint:
 630 error hint:
 631
 632                        QUERY PLAN
 633 --------------------------------------------------------
 634  Aggregate
 635    ->  Nested Loop
 636          ->  Seq Scan on t2
 637          ->  Index Scan using t1_pkey on t1
 638                Index Cond: ((id > $1) AND (id = t2.id))
 639 (5 rows)
 640
 641 /*+ NestLoop(t1 t2) */
 642 EXPLAIN (COSTS false) EXECUTE p7 (10);
 643                        QUERY PLAN
 644 --------------------------------------------------------
 645  Aggregate
 646    ->  Nested Loop
 647          ->  Seq Scan on t2
 648          ->  Index Scan using t1_pkey on t1
 649                Index Cond: ((id > $1) AND (id = t2.id))
 650 (5 rows)
 651
 652 -- error case
 653 /*+ NestLoop(t1 t2) */
 654 EXPLAIN (COSTS false) EXECUTE p8 (10);
 655 ERROR:  prepared statement "p8" does not exist