pg_hint_plan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * pg_hint_plan.c
   4  *                do instructions or hints to the planner using C-style block comments
   5  *                of the SQL.
   6  *
   7  * Copyright (c) 2012-2013, NIPPON TELEGRAPH AND TELEPHONE CORPORATION
   8  *
   9  *-------------------------------------------------------------------------
  10  */
  11 #include "postgres.h"
  12 #include "catalog/pg_collation.h"
  13 #include "catalog/pg_index.h"
  14 #include "commands/prepare.h"
  15 #include "mb/pg_wchar.h"
  16 #include "miscadmin.h"
  17 #include "nodes/nodeFuncs.h"
  18 #include "optimizer/clauses.h"
  19 #include "optimizer/cost.h"
  20 #include "optimizer/geqo.h"
  21 #include "optimizer/joininfo.h"
  22 #include "optimizer/pathnode.h"
  23 #include "optimizer/paths.h"
  24 #include "optimizer/plancat.h"
  25 #include "optimizer/planner.h"
  26 #include "optimizer/prep.h"
  27 #include "optimizer/restrictinfo.h"
  28 #include "parser/scansup.h"
  29 #include "tcop/utility.h"
  30 #include "utils/builtins.h"
  31 #include "utils/lsyscache.h"
  32 #include "utils/memutils.h"
  33 #include "utils/rel.h"
  34 #include "utils/syscache.h"
  35 #if PG_VERSION_NUM >= 90200
  36 #include "catalog/pg_class.h"
  37 #endif
  38
  39 #ifdef PG_MODULE_MAGIC
  40 PG_MODULE_MAGIC;
  41 #endif
  42
  43 #if PG_VERSION_NUM < 90100
  44 #error unsupported PostgreSQL version
  45 #endif
  46
  47 #define BLOCK_COMMENT_START             "/*"
  48 #define BLOCK_COMMENT_END               "*/"
  49 #define HINT_COMMENT_KEYWORD    "+"
  50 #define HINT_START                              BLOCK_COMMENT_START HINT_COMMENT_KEYWORD
  51 #define HINT_END                                BLOCK_COMMENT_END
  52
  53 /* hint keywords */
  54 #define HINT_SEQSCAN                    "SeqScan"
  55 #define HINT_INDEXSCAN                  "IndexScan"
  56 #define HINT_INDEXSCANREGEXP    "IndexScanRegexp"
  57 #define HINT_BITMAPSCAN                 "BitmapScan"
  58 #define HINT_BITMAPSCANREGEXP   "BitmapScanRegexp"
  59 #define HINT_TIDSCAN                    "TidScan"
  60 #define HINT_NOSEQSCAN                  "NoSeqScan"
  61 #define HINT_NOINDEXSCAN                "NoIndexScan"
  62 #define HINT_NOBITMAPSCAN               "NoBitmapScan"
  63 #define HINT_NOTIDSCAN                  "NoTidScan"
  64 #if PG_VERSION_NUM >= 90200
  65 #define HINT_INDEXONLYSCAN              "IndexOnlyScan"
  66 #define HINT_INDEXONLYSCANREGEXP        "IndexOnlyScanRegexp"
  67 #define HINT_NOINDEXONLYSCAN    "NoIndexOnlyScan"
  68 #endif
  69 #define HINT_NESTLOOP                   "NestLoop"
  70 #define HINT_MERGEJOIN                  "MergeJoin"
  71 #define HINT_HASHJOIN                   "HashJoin"
  72 #define HINT_NONESTLOOP                 "NoNestLoop"
  73 #define HINT_NOMERGEJOIN                "NoMergeJoin"
  74 #define HINT_NOHASHJOIN                 "NoHashJoin"
  75 #define HINT_LEADING                    "Leading"
  76 #define HINT_SET                                "Set"
  77
  78 #define HINT_ARRAY_DEFAULT_INITSIZE 8
  79
  80 #define hint_ereport(str, detail) \
  81         ereport(pg_hint_plan_parse_messages, \
  82                         (errmsg("hint syntax error at or near \"%s\"", (str)), \
  83                          errdetail detail))
  84
  85 #define skip_space(str) \
  86         while (isspace(*str)) \
  87                 str++;
  88
  89 enum
  90 {
  91         ENABLE_SEQSCAN = 0x01,
  92         ENABLE_INDEXSCAN = 0x02,
  93         ENABLE_BITMAPSCAN = 0x04,
  94         ENABLE_TIDSCAN = 0x08,
  95 #if PG_VERSION_NUM >= 90200
  96         ENABLE_INDEXONLYSCAN = 0x10
  97 #endif
  98 } SCAN_TYPE_BITS;
  99
 100 enum
 101 {
 102         ENABLE_NESTLOOP = 0x01,
 103         ENABLE_MERGEJOIN = 0x02,
 104         ENABLE_HASHJOIN = 0x04
 105 } JOIN_TYPE_BITS;
 106
 107 #if PG_VERSION_NUM >= 90200
 108 #define ENABLE_ALL_SCAN (ENABLE_SEQSCAN | ENABLE_INDEXSCAN | \
 109                                                  ENABLE_BITMAPSCAN | ENABLE_TIDSCAN | \
 110                                                  ENABLE_INDEXONLYSCAN)
 111 #else
 112 #define ENABLE_ALL_SCAN (ENABLE_SEQSCAN | ENABLE_INDEXSCAN | \
 113                                                  ENABLE_BITMAPSCAN | ENABLE_TIDSCAN)
 114 #endif
 115 #define ENABLE_ALL_JOIN (ENABLE_NESTLOOP | ENABLE_MERGEJOIN | ENABLE_HASHJOIN)
 116 #define DISABLE_ALL_SCAN 0
 117 #define DISABLE_ALL_JOIN 0
 118
 119 /* hint keyword of enum type*/
 120 typedef enum HintKeyword
 121 {
 122         HINT_KEYWORD_SEQSCAN,
 123         HINT_KEYWORD_INDEXSCAN,
 124         HINT_KEYWORD_INDEXSCANREGEXP,
 125         HINT_KEYWORD_BITMAPSCAN,
 126         HINT_KEYWORD_BITMAPSCANREGEXP,
 127         HINT_KEYWORD_TIDSCAN,
 128         HINT_KEYWORD_NOSEQSCAN,
 129         HINT_KEYWORD_NOINDEXSCAN,
 130         HINT_KEYWORD_NOBITMAPSCAN,
 131         HINT_KEYWORD_NOTIDSCAN,
 132 #if PG_VERSION_NUM >= 90200
 133         HINT_KEYWORD_INDEXONLYSCAN,
 134         HINT_KEYWORD_INDEXONLYSCANREGEXP,
 135         HINT_KEYWORD_NOINDEXONLYSCAN,
 136 #endif
 137         HINT_KEYWORD_NESTLOOP,
 138         HINT_KEYWORD_MERGEJOIN,
 139         HINT_KEYWORD_HASHJOIN,
 140         HINT_KEYWORD_NONESTLOOP,
 141         HINT_KEYWORD_NOMERGEJOIN,
 142         HINT_KEYWORD_NOHASHJOIN,
 143         HINT_KEYWORD_LEADING,
 144         HINT_KEYWORD_SET,
 145         HINT_KEYWORD_UNRECOGNIZED
 146 } HintKeyword;
 147
 148 typedef struct Hint Hint;
 149 typedef struct HintState HintState;
 150
 151 typedef Hint *(*HintCreateFunction) (const char *hint_str,
 152                                                                          const char *keyword,
 153                                                                          HintKeyword hint_keyword);
 154 typedef void (*HintDeleteFunction) (Hint *hint);
 155 typedef void (*HintDescFunction) (Hint *hint, StringInfo buf);
 156 typedef int (*HintCmpFunction) (const Hint *a, const Hint *b);
 157 typedef const char *(*HintParseFunction) (Hint *hint, HintState *hstate,
 158                                                                                   Query *parse, const char *str);
 159
 160 /* hint types */
 161 #define NUM_HINT_TYPE   4
 162 typedef enum HintType
 163 {
 164         HINT_TYPE_SCAN_METHOD,
 165         HINT_TYPE_JOIN_METHOD,
 166         HINT_TYPE_LEADING,
 167         HINT_TYPE_SET
 168 } HintType;
 169
 170 static const char *HintTypeName[] = {
 171         "scan method",
 172         "join method",
 173         "leading",
 174         "set"
 175 };
 176
 177 /* hint status */
 178 typedef enum HintStatus
 179 {
 180         HINT_STATE_NOTUSED = 0,         /* specified relation not used in query */
 181         HINT_STATE_USED,                        /* hint is used */
 182         HINT_STATE_DUPLICATION,         /* specified hint duplication */
 183         HINT_STATE_ERROR                        /* execute error (parse error does not include
 184                                                                  * it) */
 185 } HintStatus;
 186
 187 #define hint_state_enabled(hint) ((hint)->base.state == HINT_STATE_NOTUSED || \
 188                                                                   (hint)->base.state == HINT_STATE_USED)
 189
 190 /* common data for all hints. */
 191 struct Hint
 192 {
 193         const char                 *hint_str;           /* must not do pfree */
 194         const char                 *keyword;            /* must not do pfree */
 195         HintKeyword                     hint_keyword;
 196         HintType                        type;
 197         HintStatus                      state;
 198         HintDeleteFunction      delete_func;
 199         HintDescFunction        desc_func;
 200         HintCmpFunction         cmp_func;
 201         HintParseFunction       parse_func;
 202 };
 203
 204 /* scan method hints */
 205 typedef struct ScanMethodHint
 206 {
 207         Hint                    base;
 208         char               *relname;
 209         List               *indexnames;
 210         bool                    regexp;
 211         unsigned char   enforce_mask;
 212 } ScanMethodHint;
 213
 214 typedef struct ParentIndexInfo
 215 {
 216         bool            indisunique;
 217         Oid                     method;
 218         List       *column_names;
 219         char       *expression_str;
 220         Oid                *indcollation;
 221         Oid                *opclass;
 222         int16      *indoption;
 223         char       *indpred_str;
 224 } ParentIndexInfo;
 225
 226 /* join method hints */
 227 typedef struct JoinMethodHint
 228 {
 229         Hint                    base;
 230         int                             nrels;
 231         int                             inner_nrels;
 232         char              **relnames;
 233         unsigned char   enforce_mask;
 234         Relids                  joinrelids;
 235         Relids                  inner_joinrelids;
 236 } JoinMethodHint;
 237
 238 /* join order hints */
 239 typedef struct OuterInnerRels
 240 {
 241         char   *relation;
 242         List   *outer_inner_pair;
 243 } OuterInnerRels;
 244
 245 typedef struct LeadingHint
 246 {
 247         Hint                    base;
 248         List               *relations;  /* relation names specified in Leading hint */
 249         OuterInnerRels *outer_inner;
 250 } LeadingHint;
 251
 252 /* change a run-time parameter hints */
 253 typedef struct SetHint
 254 {
 255         Hint    base;
 256         char   *name;                           /* name of variable */
 257         char   *value;
 258         List   *words;
 259 } SetHint;
 260
 261 /*
 262  * Describes a context of hint processing.
 263  */
 264 struct HintState
 265 {
 266         char               *hint_str;                   /* original hint string */
 267
 268         /* all hint */
 269         int                             nall_hints;                     /* # of valid all hints */
 270         int                             max_all_hints;          /* # of slots for all hints */
 271         Hint              **all_hints;                  /* parsed all hints */
 272
 273         /* # of each hints */
 274         int                             num_hints[NUM_HINT_TYPE];
 275
 276         /* for scan method hints */
 277         ScanMethodHint **scan_hints;            /* parsed scan hints */
 278         int                             init_scan_mask;         /* initial value scan parameter */
 279         Index                   parent_relid;           /* inherit parent table relid */
 280         Oid                             parent_rel_oid;     /* inherit parent table relid */
 281         ScanMethodHint *parent_hint;            /* inherit parent table scan hint */
 282         List               *parent_index_infos; /* infomation of inherit parent table's
 283                                                                                  * index */
 284
 285         /* for join method hints */
 286         JoinMethodHint **join_hints;            /* parsed join hints */
 287         int                             init_join_mask;         /* initial value join parameter */
 288         List              **join_hint_level;
 289
 290         /* for Leading hint */
 291         LeadingHint       **leading_hint;               /* parsed Leading hints */
 292
 293         /* for Set hints */
 294         SetHint           **set_hints;                  /* parsed Set hints */
 295         GucContext              context;                        /* which GUC parameters can we set? */
 296 };
 297
 298 /*
 299  * Describes a hint parser module which is bound with particular hint keyword.
 300  */
 301 typedef struct HintParser
 302 {
 303         char                       *keyword;
 304         HintCreateFunction      create_func;
 305         HintKeyword                     hint_keyword;
 306 } HintParser;
 307
 308 /* Module callbacks */
 309 void            _PG_init(void);
 310 void            _PG_fini(void);
 311
 312 static void push_hint(HintState *hstate);
 313 static void pop_hint(void);
 314
 315 static void pg_hint_plan_ProcessUtility(Node *parsetree,
 316                                                                                 const char *queryString,
 317                                                                                 ParamListInfo params, bool isTopLevel,
 318                                                                                 DestReceiver *dest,
 319                                                                                 char *completionTag);
 320 static PlannedStmt *pg_hint_plan_planner(Query *parse, int cursorOptions,
 321                                                                                  ParamListInfo boundParams);
 322 static void pg_hint_plan_get_relation_info(PlannerInfo *root,
 323                                                                                    Oid relationObjectId,
 324                                                                                    bool inhparent, RelOptInfo *rel);
 325 static RelOptInfo *pg_hint_plan_join_search(PlannerInfo *root,
 326                                                                                         int levels_needed,
 327                                                                                         List *initial_rels);
 328
 329 static Hint *ScanMethodHintCreate(const char *hint_str, const char *keyword,
 330                                                                   HintKeyword hint_keyword);
 331 static void ScanMethodHintDelete(ScanMethodHint *hint);
 332 static void ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf);
 333 static int ScanMethodHintCmp(const ScanMethodHint *a, const ScanMethodHint *b);
 334 static const char *ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate,
 335                                                                            Query *parse, const char *str);
 336 static Hint *JoinMethodHintCreate(const char *hint_str, const char *keyword,
 337                                                                   HintKeyword hint_keyword);
 338 static void JoinMethodHintDelete(JoinMethodHint *hint);
 339 static void JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf);
 340 static int JoinMethodHintCmp(const JoinMethodHint *a, const JoinMethodHint *b);
 341 static const char *JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate,
 342                                                                            Query *parse, const char *str);
 343 static Hint *LeadingHintCreate(const char *hint_str, const char *keyword,
 344                                                            HintKeyword hint_keyword);
 345 static void LeadingHintDelete(LeadingHint *hint);
 346 static void LeadingHintDesc(LeadingHint *hint, StringInfo buf);
 347 static int LeadingHintCmp(const LeadingHint *a, const LeadingHint *b);
 348 static const char *LeadingHintParse(LeadingHint *hint, HintState *hstate,
 349                                                                         Query *parse, const char *str);
 350 static Hint *SetHintCreate(const char *hint_str, const char *keyword,
 351                                                    HintKeyword hint_keyword);
 352 static void SetHintDelete(SetHint *hint);
 353 static void SetHintDesc(SetHint *hint, StringInfo buf);
 354 static int SetHintCmp(const SetHint *a, const SetHint *b);
 355 static const char *SetHintParse(SetHint *hint, HintState *hstate, Query *parse,
 356                                                                 const char *str);
 357
 358 static void quote_value(StringInfo buf, const char *value);
 359
 360 static const char *parse_quoted_value(const char *str, char **word,
 361                                                                           bool truncate);
 362
 363 RelOptInfo *pg_hint_plan_standard_join_search(PlannerInfo *root,
 364                                                                                           int levels_needed,
 365                                                                                           List *initial_rels);
 366 void pg_hint_plan_join_search_one_level(PlannerInfo *root, int level);
 367 static void make_rels_by_clause_joins(PlannerInfo *root, RelOptInfo *old_rel,
 368                                                                           ListCell *other_rels);
 369 static void make_rels_by_clauseless_joins(PlannerInfo *root,
 370                                                                                   RelOptInfo *old_rel,
 371                                                                                   ListCell *other_rels);
 372 static bool has_join_restriction(PlannerInfo *root, RelOptInfo *rel);
 373 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 374                                                                         Index rti, RangeTblEntry *rte);
 375 #if PG_VERSION_NUM >= 90200
 376 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
 377                                                    List *live_childrels,
 378                                                    List *all_child_pathkeys);
 379 #endif
 380 static List *accumulate_append_subpath(List *subpaths, Path *path);
 381 #if PG_VERSION_NUM < 90200
 382 static void set_dummy_rel_pathlist(RelOptInfo *rel);
 383 #endif
 384 RelOptInfo *pg_hint_plan_make_join_rel(PlannerInfo *root, RelOptInfo *rel1,
 385                                                                            RelOptInfo *rel2);
 386
 387 /* GUC variables */
 388 static bool     pg_hint_plan_enable_hint = true;
 389 static bool     pg_hint_plan_debug_print = false;
 390 static int      pg_hint_plan_parse_messages = INFO;
 391
 392 static const struct config_enum_entry parse_messages_level_options[] = {
 393         {"debug", DEBUG2, true},
 394         {"debug5", DEBUG5, false},
 395         {"debug4", DEBUG4, false},
 396         {"debug3", DEBUG3, false},
 397         {"debug2", DEBUG2, false},
 398         {"debug1", DEBUG1, false},
 399         {"log", LOG, false},
 400         {"info", INFO, false},
 401         {"notice", NOTICE, false},
 402         {"warning", WARNING, false},
 403         {"error", ERROR, false},
 404         /*
 405          * {"fatal", FATAL, true},
 406          * {"panic", PANIC, true},
 407          */
 408         {NULL, 0, false}
 409 };
 410
 411 /* Saved hook values in case of unload */
 412 static ProcessUtility_hook_type prev_ProcessUtility = NULL;
 413 static planner_hook_type prev_planner = NULL;
 414 static get_relation_info_hook_type prev_get_relation_info = NULL;
 415 static join_search_hook_type prev_join_search = NULL;
 416
 417 /* Hold reference to currently active hint */
 418 static HintState *current_hint = NULL;
 419
 420 /*
 421  * List of hint contexts.  We treat the head of the list as the Top of the
 422  * context stack, so current_hint always points the first element of this list.
 423  */
 424 static List *HintStateStack = NIL;
 425
 426 /*
 427  * Holds statement name during executing EXECUTE command.  NULL for other
 428  * statements.
 429  */
 430 static char        *stmt_name = NULL;
 431
 432 static const HintParser parsers[] = {
 433         {HINT_SEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_SEQSCAN},
 434         {HINT_INDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCAN},
 435         {HINT_INDEXSCANREGEXP, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCANREGEXP},
 436         {HINT_BITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_BITMAPSCAN},
 437         {HINT_BITMAPSCANREGEXP, ScanMethodHintCreate,
 438          HINT_KEYWORD_BITMAPSCANREGEXP},
 439         {HINT_TIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_TIDSCAN},
 440         {HINT_NOSEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOSEQSCAN},
 441         {HINT_NOINDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXSCAN},
 442         {HINT_NOBITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOBITMAPSCAN},
 443         {HINT_NOTIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOTIDSCAN},
 444 #if PG_VERSION_NUM >= 90200
 445         {HINT_INDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXONLYSCAN},
 446         {HINT_INDEXONLYSCANREGEXP, ScanMethodHintCreate,
 447          HINT_KEYWORD_INDEXONLYSCANREGEXP},
 448         {HINT_NOINDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXONLYSCAN},
 449 #endif
 450         {HINT_NESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NESTLOOP},
 451         {HINT_MERGEJOIN, JoinMethodHintCreate, HINT_KEYWORD_MERGEJOIN},
 452         {HINT_HASHJOIN, JoinMethodHintCreate, HINT_KEYWORD_HASHJOIN},
 453         {HINT_NONESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NONESTLOOP},
 454         {HINT_NOMERGEJOIN, JoinMethodHintCreate, HINT_KEYWORD_NOMERGEJOIN},
 455         {HINT_NOHASHJOIN, JoinMethodHintCreate, HINT_KEYWORD_NOHASHJOIN},
 456         {HINT_LEADING, LeadingHintCreate, HINT_KEYWORD_LEADING},
 457         {HINT_SET, SetHintCreate, HINT_KEYWORD_SET},
 458         {NULL, NULL, HINT_KEYWORD_UNRECOGNIZED}
 459 };
 460
 461 /*
 462  * Module load callbacks
 463  */
 464 void
 465 _PG_init(void)
 466 {
 467         /* Define custom GUC variables. */
 468         DefineCustomBoolVariable("pg_hint_plan.enable_hint",
 469                          "Force planner to use plans specified in the hint comment preceding to the query.",
 470                                                          NULL,
 471                                                          &pg_hint_plan_enable_hint,
 472                                                          true,
 473                                                          PGC_USERSET,
 474                                                          0,
 475                                                          NULL,
 476                                                          NULL,
 477                                                          NULL);
 478
 479         DefineCustomBoolVariable("pg_hint_plan.debug_print",
 480                                                          "Logs results of hint parsing.",
 481                                                          NULL,
 482                                                          &pg_hint_plan_debug_print,
 483                                                          false,
 484                                                          PGC_USERSET,
 485                                                          0,
 486                                                          NULL,
 487                                                          NULL,
 488                                                          NULL);
 489
 490         DefineCustomEnumVariable("pg_hint_plan.parse_messages",
 491                                                          "Message level of parse errors.",
 492                                                          NULL,
 493                                                          &pg_hint_plan_parse_messages,
 494                                                          INFO,
 495                                                          parse_messages_level_options,
 496                                                          PGC_USERSET,
 497                                                          0,
 498                                                          NULL,
 499                                                          NULL,
 500                                                          NULL);
 501
 502         /* Install hooks. */
 503         prev_ProcessUtility = ProcessUtility_hook;
 504         ProcessUtility_hook = pg_hint_plan_ProcessUtility;
 505         prev_planner = planner_hook;
 506         planner_hook = pg_hint_plan_planner;
 507         prev_get_relation_info = get_relation_info_hook;
 508         get_relation_info_hook = pg_hint_plan_get_relation_info;
 509         prev_join_search = join_search_hook;
 510         join_search_hook = pg_hint_plan_join_search;
 511 }
 512
 513 /*
 514  * Module unload callback
 515  * XXX never called
 516  */
 517 void
 518 _PG_fini(void)
 519 {
 520         /* Uninstall hooks. */
 521         ProcessUtility_hook = prev_ProcessUtility;
 522         planner_hook = prev_planner;
 523         get_relation_info_hook = prev_get_relation_info;
 524         join_search_hook = prev_join_search;
 525 }
 526
 527 /*
 528  * create and delete functions the hint object
 529  */
 530
 531 static Hint *
 532 ScanMethodHintCreate(const char *hint_str, const char *keyword,
 533                                          HintKeyword hint_keyword)
 534 {
 535         ScanMethodHint *hint;
 536
 537         hint = palloc(sizeof(ScanMethodHint));
 538         hint->base.hint_str = hint_str;
 539         hint->base.keyword = keyword;
 540         hint->base.hint_keyword = hint_keyword;
 541         hint->base.type = HINT_TYPE_SCAN_METHOD;
 542         hint->base.state = HINT_STATE_NOTUSED;
 543         hint->base.delete_func = (HintDeleteFunction) ScanMethodHintDelete;
 544         hint->base.desc_func = (HintDescFunction) ScanMethodHintDesc;
 545         hint->base.cmp_func = (HintCmpFunction) ScanMethodHintCmp;
 546         hint->base.parse_func = (HintParseFunction) ScanMethodHintParse;
 547         hint->relname = NULL;
 548         hint->indexnames = NIL;
 549         hint->regexp = false;
 550         hint->enforce_mask = 0;
 551
 552         return (Hint *) hint;
 553 }
 554
 555 static void
 556 ScanMethodHintDelete(ScanMethodHint *hint)
 557 {
 558         if (!hint)
 559                 return;
 560
 561         if (hint->relname)
 562                 pfree(hint->relname);
 563         list_free_deep(hint->indexnames);
 564         pfree(hint);
 565 }
 566
 567 static Hint *
 568 JoinMethodHintCreate(const char *hint_str, const char *keyword,
 569                                          HintKeyword hint_keyword)
 570 {
 571         JoinMethodHint *hint;
 572
 573         hint = palloc(sizeof(JoinMethodHint));
 574         hint->base.hint_str = hint_str;
 575         hint->base.keyword = keyword;
 576         hint->base.hint_keyword = hint_keyword;
 577         hint->base.type = HINT_TYPE_JOIN_METHOD;
 578         hint->base.state = HINT_STATE_NOTUSED;
 579         hint->base.delete_func = (HintDeleteFunction) JoinMethodHintDelete;
 580         hint->base.desc_func = (HintDescFunction) JoinMethodHintDesc;
 581         hint->base.cmp_func = (HintCmpFunction) JoinMethodHintCmp;
 582         hint->base.parse_func = (HintParseFunction) JoinMethodHintParse;
 583         hint->nrels = 0;
 584         hint->inner_nrels = 0;
 585         hint->relnames = NULL;
 586         hint->enforce_mask = 0;
 587         hint->joinrelids = NULL;
 588         hint->inner_joinrelids = NULL;
 589
 590         return (Hint *) hint;
 591 }
 592
 593 static void
 594 JoinMethodHintDelete(JoinMethodHint *hint)
 595 {
 596         if (!hint)
 597                 return;
 598
 599         if (hint->relnames)
 600         {
 601                 int     i;
 602
 603                 for (i = 0; i < hint->nrels; i++)
 604                         pfree(hint->relnames[i]);
 605                 pfree(hint->relnames);
 606         }
 607
 608         bms_free(hint->joinrelids);
 609         bms_free(hint->inner_joinrelids);
 610         pfree(hint);
 611 }
 612
 613 static Hint *
 614 LeadingHintCreate(const char *hint_str, const char *keyword,
 615                                   HintKeyword hint_keyword)
 616 {
 617         LeadingHint        *hint;
 618
 619         hint = palloc(sizeof(LeadingHint));
 620         hint->base.hint_str = hint_str;
 621         hint->base.keyword = keyword;
 622         hint->base.hint_keyword = hint_keyword;
 623         hint->base.type = HINT_TYPE_LEADING;
 624         hint->base.state = HINT_STATE_NOTUSED;
 625         hint->base.delete_func = (HintDeleteFunction)LeadingHintDelete;
 626         hint->base.desc_func = (HintDescFunction) LeadingHintDesc;
 627         hint->base.cmp_func = (HintCmpFunction) LeadingHintCmp;
 628         hint->base.parse_func = (HintParseFunction) LeadingHintParse;
 629         hint->relations = NIL;
 630         hint->outer_inner = NULL;
 631
 632         return (Hint *) hint;
 633 }
 634
 635 static void
 636 LeadingHintDelete(LeadingHint *hint)
 637 {
 638         if (!hint)
 639                 return;
 640
 641         list_free_deep(hint->relations);
 642         if (hint->outer_inner)
 643                 pfree(hint->outer_inner);
 644         pfree(hint);
 645 }
 646
 647 static Hint *
 648 SetHintCreate(const char *hint_str, const char *keyword,
 649                           HintKeyword hint_keyword)
 650 {
 651         SetHint    *hint;
 652
 653         hint = palloc(sizeof(SetHint));
 654         hint->base.hint_str = hint_str;
 655         hint->base.keyword = keyword;
 656         hint->base.hint_keyword = hint_keyword;
 657         hint->base.type = HINT_TYPE_SET;
 658         hint->base.state = HINT_STATE_NOTUSED;
 659         hint->base.delete_func = (HintDeleteFunction) SetHintDelete;
 660         hint->base.desc_func = (HintDescFunction) SetHintDesc;
 661         hint->base.cmp_func = (HintCmpFunction) SetHintCmp;
 662         hint->base.parse_func = (HintParseFunction) SetHintParse;
 663         hint->name = NULL;
 664         hint->value = NULL;
 665         hint->words = NIL;
 666
 667         return (Hint *) hint;
 668 }
 669
 670 static void
 671 SetHintDelete(SetHint *hint)
 672 {
 673         if (!hint)
 674                 return;
 675
 676         if (hint->name)
 677                 pfree(hint->name);
 678         if (hint->value)
 679                 pfree(hint->value);
 680         if (hint->words)
 681                 list_free(hint->words);
 682         pfree(hint);
 683 }
 684
 685 static HintState *
 686 HintStateCreate(void)
 687 {
 688         HintState   *hstate;
 689
 690         hstate = palloc(sizeof(HintState));
 691         hstate->hint_str = NULL;
 692         hstate->nall_hints = 0;
 693         hstate->max_all_hints = 0;
 694         hstate->all_hints = NULL;
 695         memset(hstate->num_hints, 0, sizeof(hstate->num_hints));
 696         hstate->scan_hints = NULL;
 697         hstate->init_scan_mask = 0;
 698         hstate->parent_relid = 0;
 699         hstate->parent_rel_oid = InvalidOid;
 700         hstate->parent_hint = NULL;
 701         hstate->parent_index_infos = NIL;
 702         hstate->join_hints = NULL;
 703         hstate->init_join_mask = 0;
 704         hstate->join_hint_level = NULL;
 705         hstate->leading_hint = NULL;
 706         hstate->context = superuser() ? PGC_SUSET : PGC_USERSET;
 707         hstate->set_hints = NULL;
 708
 709         return hstate;
 710 }
 711
 712 static void
 713 HintStateDelete(HintState *hstate)
 714 {
 715         int                     i;
 716
 717         if (!hstate)
 718                 return;
 719
 720         if (hstate->hint_str)
 721                 pfree(hstate->hint_str);
 722
 723         for (i = 0; i < hstate->num_hints[HINT_TYPE_SCAN_METHOD]; i++)
 724                 hstate->all_hints[i]->delete_func(hstate->all_hints[i]);
 725         if (hstate->all_hints)
 726                 pfree(hstate->all_hints);
 727         if (hstate->parent_index_infos)
 728                 list_free(hstate->parent_index_infos);
 729 }
 730
 731 /*
 732  * Copy given value into buf, with quoting with '"' if necessary.
 733  */
 734 static void
 735 quote_value(StringInfo buf, const char *value)
 736 {
 737         bool            need_quote = false;
 738         const char *str;
 739
 740         for (str = value; *str != '\0'; str++)
 741         {
 742                 if (isspace(*str) || *str == '(' || *str == ')' || *str == '"')
 743                 {
 744                         need_quote = true;
 745                         appendStringInfoCharMacro(buf, '"');
 746                         break;
 747                 }
 748         }
 749
 750         for (str = value; *str != '\0'; str++)
 751         {
 752                 if (*str == '"')
 753                         appendStringInfoCharMacro(buf, '"');
 754
 755                 appendStringInfoCharMacro(buf, *str);
 756         }
 757
 758         if (need_quote)
 759                 appendStringInfoCharMacro(buf, '"');
 760 }
 761
 762 static void
 763 ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf)
 764 {
 765         ListCell   *l;
 766
 767         appendStringInfo(buf, "%s(", hint->base.keyword);
 768         if (hint->relname != NULL)
 769         {
 770                 quote_value(buf, hint->relname);
 771                 foreach(l, hint->indexnames)
 772                 {
 773                         appendStringInfoCharMacro(buf, ' ');
 774                         quote_value(buf, (char *) lfirst(l));
 775                 }
 776         }
 777         appendStringInfoString(buf, ")\n");
 778 }
 779
 780 static void
 781 JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf)
 782 {
 783         int     i;
 784
 785         appendStringInfo(buf, "%s(", hint->base.keyword);
 786         if (hint->relnames != NULL)
 787         {
 788                 quote_value(buf, hint->relnames[0]);
 789                 for (i = 1; i < hint->nrels; i++)
 790                 {
 791                         appendStringInfoCharMacro(buf, ' ');
 792                         quote_value(buf, hint->relnames[i]);
 793                 }
 794         }
 795         appendStringInfoString(buf, ")\n");
 796
 797 }
 798
 799 static void
 800 OuterInnerDesc(OuterInnerRels *outer_inner, StringInfo buf)
 801 {
 802         if (outer_inner->relation == NULL)
 803         {
 804                 bool            is_first;
 805                 ListCell   *l;
 806
 807                 is_first = true;
 808
 809                 appendStringInfoCharMacro(buf, '(');
 810                 foreach(l, outer_inner->outer_inner_pair)
 811                 {
 812                         if (is_first)
 813                                 is_first = false;
 814                         else
 815                                 appendStringInfoCharMacro(buf, ' ');
 816
 817                         OuterInnerDesc(lfirst(l), buf);
 818                 }
 819
 820                 appendStringInfoCharMacro(buf, ')');
 821         }
 822         else
 823                 quote_value(buf, outer_inner->relation);
 824 }
 825
 826 static void
 827 LeadingHintDesc(LeadingHint *hint, StringInfo buf)
 828 {
 829         appendStringInfo(buf, "%s(", HINT_LEADING);
 830         if (hint->outer_inner == NULL)
 831         {
 832                 ListCell   *l;
 833                 bool            is_first;
 834
 835                 is_first = true;
 836
 837                 foreach(l, hint->relations)
 838                 {
 839                         if (is_first)
 840                                 is_first = false;
 841                         else
 842                                 appendStringInfoCharMacro(buf, ' ');
 843
 844                         quote_value(buf, (char *) lfirst(l));
 845                 }
 846         }
 847         else
 848                 OuterInnerDesc(hint->outer_inner, buf);
 849
 850         appendStringInfoString(buf, ")\n");
 851 }
 852
 853 static void
 854 SetHintDesc(SetHint *hint, StringInfo buf)
 855 {
 856         bool            is_first = true;
 857         ListCell   *l;
 858
 859         appendStringInfo(buf, "%s(", HINT_SET);
 860         foreach(l, hint->words)
 861         {
 862                 if (is_first)
 863                         is_first = false;
 864                 else
 865                         appendStringInfoCharMacro(buf, ' ');
 866
 867                 quote_value(buf, (char *) lfirst(l));
 868         }
 869         appendStringInfo(buf, ")\n");
 870 }
 871
 872 /*
 873  * Append string which repserents all hints in a given state to buf, with
 874  * preceding title with them.
 875  */
 876 static void
 877 desc_hint_in_state(HintState *hstate, StringInfo buf, const char *title,
 878                                         HintStatus state)
 879 {
 880         int     i;
 881
 882         appendStringInfo(buf, "%s:\n", title);
 883         for (i = 0; i < hstate->nall_hints; i++)
 884         {
 885                 if (hstate->all_hints[i]->state != state)
 886                         continue;
 887
 888                 hstate->all_hints[i]->desc_func(hstate->all_hints[i], buf);
 889         }
 890 }
 891
 892 /*
 893  * Dump contents of given hstate to server log with log level LOG.
 894  */
 895 static void
 896 HintStateDump(HintState *hstate)
 897 {
 898         StringInfoData  buf;
 899
 900         if (!hstate)
 901         {
 902                 elog(LOG, "pg_hint_plan:\nno hint");
 903                 return;
 904         }
 905
 906         initStringInfo(&buf);
 907
 908         appendStringInfoString(&buf, "pg_hint_plan:\n");
 909         desc_hint_in_state(hstate, &buf, "used hint", HINT_STATE_USED);
 910         desc_hint_in_state(hstate, &buf, "not used hint", HINT_STATE_NOTUSED);
 911         desc_hint_in_state(hstate, &buf, "duplication hint", HINT_STATE_DUPLICATION);
 912         desc_hint_in_state(hstate, &buf, "error hint", HINT_STATE_ERROR);
 913
 914         elog(LOG, "%s", buf.data);
 915
 916         pfree(buf.data);
 917 }
 918
 919 /*
 920  * compare functions
 921  */
 922
 923 static int
 924 RelnameCmp(const void *a, const void *b)
 925 {
 926         const char *relnamea = *((const char **) a);
 927         const char *relnameb = *((const char **) b);
 928
 929         return strcmp(relnamea, relnameb);
 930 }
 931
 932 static int
 933 ScanMethodHintCmp(const ScanMethodHint *a, const ScanMethodHint *b)
 934 {
 935         return RelnameCmp(&a->relname, &b->relname);
 936 }
 937
 938 static int
 939 JoinMethodHintCmp(const JoinMethodHint *a, const JoinMethodHint *b)
 940 {
 941         int     i;
 942
 943         if (a->nrels != b->nrels)
 944                 return a->nrels - b->nrels;
 945
 946         for (i = 0; i < a->nrels; i++)
 947         {
 948                 int     result;
 949                 if ((result = RelnameCmp(&a->relnames[i], &b->relnames[i])) != 0)
 950                         return result;
 951         }
 952
 953         return 0;
 954 }
 955
 956 static int
 957 LeadingHintCmp(const LeadingHint *a, const LeadingHint *b)
 958 {
 959         return 0;
 960 }
 961
 962 static int
 963 SetHintCmp(const SetHint *a, const SetHint *b)
 964 {
 965         return strcmp(a->name, b->name);
 966 }
 967
 968 static int
 969 HintCmp(const void *a, const void *b)
 970 {
 971         const Hint *hinta = *((const Hint **) a);
 972         const Hint *hintb = *((const Hint **) b);
 973
 974         if (hinta->type != hintb->type)
 975                 return hinta->type - hintb->type;
 976         if (hinta->state == HINT_STATE_ERROR)
 977                 return -1;
 978         if (hintb->state == HINT_STATE_ERROR)
 979                 return 1;
 980         return hinta->cmp_func(hinta, hintb);
 981 }
 982
 983 /*
 984  * Returns byte offset of hint b from hint a.  If hint a was specified before
 985  * b, positive value is returned.
 986  */
 987 static int
 988 HintCmpWithPos(const void *a, const void *b)
 989 {
 990         const Hint *hinta = *((const Hint **) a);
 991         const Hint *hintb = *((const Hint **) b);
 992         int             result;
 993
 994         result = HintCmp(a, b);
 995         if (result == 0)
 996                 result = hinta->hint_str - hintb->hint_str;
 997
 998         return result;
 999 }
1000
1001 /*
1002  * parse functions
1003  */
1004 static const char *
1005 parse_keyword(const char *str, StringInfo buf)
1006 {
1007         skip_space(str);
1008
1009         while (!isspace(*str) && *str != '(' && *str != '\0')
1010                 appendStringInfoCharMacro(buf, *str++);
1011
1012         return str;
1013 }
1014
1015 static const char *
1016 skip_parenthesis(const char *str, char parenthesis)
1017 {
1018         skip_space(str);
1019
1020         if (*str != parenthesis)
1021         {
1022                 if (parenthesis == '(')
1023                         hint_ereport(str, ("Opening parenthesis is necessary."));
1024                 else if (parenthesis == ')')
1025                         hint_ereport(str, ("Closing parenthesis is necessary."));
1026
1027                 return NULL;
1028         }
1029
1030         str++;
1031
1032         return str;
1033 }
1034
1035 /*
1036  * Parse a token from str, and store malloc'd copy into word.  A token can be
1037  * quoted with '"'.  Return value is pointer to unparsed portion of original
1038  * string, or NULL if an error occurred.
1039  *
1040  * Parsed token is truncated within NAMEDATALEN-1 bytes, when truncate is true.
1041  */
1042 static const char *
1043 parse_quoted_value(const char *str, char **word, bool truncate)
1044 {
1045         StringInfoData  buf;
1046         bool                    in_quote;
1047
1048         /* Skip leading spaces. */
1049         skip_space(str);
1050
1051         initStringInfo(&buf);
1052         if (*str == '"')
1053         {
1054                 str++;
1055                 in_quote = true;
1056         }
1057         else
1058                 in_quote = false;
1059
1060         while (true)
1061         {
1062                 if (in_quote)
1063                 {
1064                         /* Double quotation must be closed. */
1065                         if (*str == '\0')
1066                         {
1067                                 pfree(buf.data);
1068                                 hint_ereport(str, ("Unterminated quoted string."));
1069                                 return NULL;
1070                         }
1071
1072                         /*
1073                          * Skip escaped double quotation.
1074                          *
1075                          * We don't allow slash-asterisk and asterisk-slash (delimiters of
1076                          * block comments) to be an object name, so users must specify
1077                          * alias for such object names.
1078                          *
1079                          * Those special names can be allowed if we care escaped slashes
1080                          * and asterisks, but we don't.
1081                          */
1082                         if (*str == '"')
1083                         {
1084                                 str++;
1085                                 if (*str != '"')
1086                                         break;
1087                         }
1088                 }
1089                 else if (isspace(*str) || *str == '(' || *str == ')' || *str == '"' ||
1090                                  *str == '\0')
1091                         break;
1092
1093                 appendStringInfoCharMacro(&buf, *str++);
1094         }
1095
1096         if (buf.len == 0)
1097         {
1098                 hint_ereport(str, ("Zero-length delimited string."));
1099
1100                 pfree(buf.data);
1101
1102                 return NULL;
1103         }
1104
1105         /* Truncate name if it's too long */
1106         if (truncate)
1107                 truncate_identifier(buf.data, strlen(buf.data), true);
1108
1109         *word = buf.data;
1110
1111         return str;
1112 }
1113
1114 static OuterInnerRels *
1115 OuterInnerRelsCreate(char *name, List *outer_inner_list)
1116 {
1117         OuterInnerRels *outer_inner;
1118
1119         outer_inner = palloc(sizeof(OuterInnerRels));
1120         outer_inner->relation = name;
1121         outer_inner->outer_inner_pair = outer_inner_list;
1122
1123         return outer_inner;
1124 }
1125
1126 static const char *
1127 parse_parentheses_Leading_in(const char *str, OuterInnerRels **outer_inner)
1128 {
1129         List   *outer_inner_pair = NIL;
1130
1131         if ((str = skip_parenthesis(str, '(')) == NULL)
1132                 return NULL;
1133
1134         skip_space(str);
1135
1136         /* Store words in parentheses into outer_inner_list. */
1137         while(*str != ')' && *str != '\0')
1138         {
1139                 OuterInnerRels *outer_inner_rels;
1140
1141                 if (*str == '(')
1142                 {
1143                         str = parse_parentheses_Leading_in(str, &outer_inner_rels);
1144                         if (str == NULL)
1145                                 break;
1146                 }
1147                 else
1148                 {
1149                         char   *name;
1150
1151                         if ((str = parse_quoted_value(str, &name, true)) == NULL)
1152                                 break;
1153                         else
1154                                 outer_inner_rels = OuterInnerRelsCreate(name, NIL);
1155                 }
1156
1157                 outer_inner_pair = lappend(outer_inner_pair, outer_inner_rels);
1158                 skip_space(str);
1159         }
1160
1161         if (str == NULL ||
1162                 (str = skip_parenthesis(str, ')')) == NULL)
1163         {
1164                 list_free(outer_inner_pair);
1165                 return NULL;
1166         }
1167
1168         *outer_inner = OuterInnerRelsCreate(NULL, outer_inner_pair);
1169
1170         return str;
1171 }
1172
1173 static const char *
1174 parse_parentheses_Leading(const char *str, List **name_list,
1175         OuterInnerRels **outer_inner)
1176 {
1177         char   *name;
1178         bool    truncate = true;
1179
1180         if ((str = skip_parenthesis(str, '(')) == NULL)
1181                 return NULL;
1182
1183         skip_space(str);
1184         if (*str =='(')
1185         {
1186                 if ((str = parse_parentheses_Leading_in(str, outer_inner)) == NULL)
1187                         return NULL;
1188         }
1189         else
1190         {
1191                 /* Store words in parentheses into name_list. */
1192                 while(*str != ')' && *str != '\0')
1193                 {
1194                         if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
1195                         {
1196                                 list_free(*name_list);
1197                                 return NULL;
1198                         }
1199
1200                         *name_list = lappend(*name_list, name);
1201                         skip_space(str);
1202                 }
1203         }
1204
1205         if ((str = skip_parenthesis(str, ')')) == NULL)
1206                 return NULL;
1207         return str;
1208 }
1209
1210 static const char *
1211 parse_parentheses(const char *str, List **name_list, HintKeyword keyword)
1212 {
1213         char   *name;
1214         bool    truncate = true;
1215
1216         if ((str = skip_parenthesis(str, '(')) == NULL)
1217                 return NULL;
1218
1219         skip_space(str);
1220
1221         /* Store words in parentheses into name_list. */
1222         while(*str != ')' && *str != '\0')
1223         {
1224                 if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
1225                 {
1226                         list_free(*name_list);
1227                         return NULL;
1228                 }
1229
1230                 *name_list = lappend(*name_list, name);
1231                 skip_space(str);
1232
1233                 if (keyword == HINT_KEYWORD_INDEXSCANREGEXP ||
1234 #if PG_VERSION_NUM >= 90200
1235                         keyword == HINT_KEYWORD_INDEXONLYSCANREGEXP ||
1236 #endif
1237                         keyword == HINT_KEYWORD_BITMAPSCANREGEXP ||
1238                         keyword == HINT_KEYWORD_SET)
1239                 {
1240                         truncate = false;
1241                 }
1242         }
1243
1244         if ((str = skip_parenthesis(str, ')')) == NULL)
1245                 return NULL;
1246         return str;
1247 }
1248
1249 static void
1250 parse_hints(HintState *hstate, Query *parse, const char *str)
1251 {
1252         StringInfoData  buf;
1253         char               *head;
1254
1255         initStringInfo(&buf);
1256         while (*str != '\0')
1257         {
1258                 const HintParser *parser;
1259
1260                 /* in error message, we output the comment including the keyword. */
1261                 head = (char *) str;
1262
1263                 /* parse only the keyword of the hint. */
1264                 resetStringInfo(&buf);
1265                 str = parse_keyword(str, &buf);
1266
1267                 for (parser = parsers; parser->keyword != NULL; parser++)
1268                 {
1269                         char   *keyword = parser->keyword;
1270                         Hint   *hint;
1271
1272                         if (strcasecmp(buf.data, keyword) != 0)
1273                                 continue;
1274
1275                         hint = parser->create_func(head, keyword, parser->hint_keyword);
1276
1277                         /* parser of each hint does parse in a parenthesis. */
1278                         if ((str = hint->parse_func(hint, hstate, parse, str)) == NULL)
1279                         {
1280                                 hint->delete_func(hint);
1281                                 pfree(buf.data);
1282                                 return;
1283                         }
1284
1285                         /*
1286                          * Add hint information into all_hints array.  If we don't have
1287                          * enough space, double the array.
1288                          */
1289                         if (hstate->nall_hints == 0)
1290                         {
1291                                 hstate->max_all_hints = HINT_ARRAY_DEFAULT_INITSIZE;
1292                                 hstate->all_hints = (Hint **)
1293                                         palloc(sizeof(Hint *) * hstate->max_all_hints);
1294                         }
1295                         else if (hstate->nall_hints == hstate->max_all_hints)
1296                         {
1297                                 hstate->max_all_hints *= 2;
1298                                 hstate->all_hints = (Hint **)
1299                                         repalloc(hstate->all_hints,
1300                                                          sizeof(Hint *) * hstate->max_all_hints);
1301                         }
1302
1303                         hstate->all_hints[hstate->nall_hints] = hint;
1304                         hstate->nall_hints++;
1305
1306                         skip_space(str);
1307
1308                         break;
1309                 }
1310
1311                 if (parser->keyword == NULL)
1312                 {
1313                         hint_ereport(head,
1314                                                  ("Unrecognized hint keyword \"%s\".", buf.data));
1315                         pfree(buf.data);
1316                         return;
1317                 }
1318         }
1319
1320         pfree(buf.data);
1321 }
1322
1323 /*
1324  * Do basic parsing of the query head comment.
1325  */
1326 /*
1327  * クエリに記述されたヒントを見つける。
1328  */
1329 static const char *
1330 find_hints_comment()
1331 {
1332         const char *p;
1333         const char *hint_head;
1334         char       *head;
1335         char       *tail;
1336         int                     len;
1337
1338         /* get client-supplied query string. */
1339         if (stmt_name)
1340         {
1341                 PreparedStatement  *entry;
1342
1343                 entry = FetchPreparedStatement(stmt_name, true);
1344                 p = entry->plansource->query_string;
1345         }
1346         else
1347                 p = debug_query_string;
1348
1349         if (p == NULL)
1350                 return NULL;
1351
1352         /* extract query head comment. */
1353         hint_head = strstr(p, HINT_START);
1354         if (hint_head == NULL)
1355                 return NULL;
1356         for (;p < hint_head; p++)
1357         {
1358                 /*
1359                  * Allow these characters precedes hint comment:
1360                  *   - digits
1361                  *   - alphabets which are in ASCII range
1362                  *   - space, tabs and new-lines
1363                  *   - underscores, for identifier
1364                  *   - commas, for SELECT clause, EXPLAIN and PREPARE
1365                  *   - parentheses, for EXPLAIN and PREPARE
1366                  *
1367                  * Note that we don't use isalpha() nor isalnum() in ctype.h here to
1368                  * avoid behavior which depends on locale setting.
1369                  */
1370                 if (!(*p >= '0' && *p <= '9') &&
1371                         !(*p >= 'A' && *p <= 'Z') &&
1372                         !(*p >= 'a' && *p <= 'z') &&
1373                         !isspace(*p) &&
1374                         *p != '_' &&
1375                         *p != ',' &&
1376                         *p != '(' && *p != ')')
1377                         return NULL;
1378         }
1379
1380         len = strlen(HINT_START);
1381         head = (char *) p;
1382         p += len;
1383         skip_space(p);
1384
1385         /* find hint end keyword. */
1386         if ((tail = strstr(p, HINT_END)) == NULL)
1387         {
1388                 hint_ereport(head, ("Unterminated block comment."));
1389                 return NULL;
1390         }
1391
1392         /* We don't support nested block comments. */
1393         if ((head = strstr(p, BLOCK_COMMENT_START)) != NULL && head < tail)
1394         {
1395                 hint_ereport(head, ("Nested block comments are not supported."));
1396                 return NULL;
1397         }
1398
1399         /* Make a copy of hint. */
1400         len = tail - p;
1401         head = palloc(len + 1);
1402         memcpy(head, p, len);
1403         head[len] = '\0';
1404         p = head;
1405
1406         return p;
1407 }
1408
1409 /*
1410  * 取得したヒントをパースする。
1411  */
1412 static HintState *
1413 get_hintstate(Query *parse,
1414                           const char *hints)
1415 {
1416         const char *p;
1417         int                     i;
1418         HintState   *hstate;
1419
1420         if (hints == NULL)
1421                 return NULL;
1422
1423         p = hints;
1424         hstate = HintStateCreate();
1425         hstate->hint_str = (char *) hints;
1426
1427         /* parse each hint. */
1428         parse_hints(hstate, parse, p);
1429
1430         /* When nothing specified a hint, we free HintState and returns NULL. */
1431         if (hstate->nall_hints == 0)
1432         {
1433                 HintStateDelete(hstate);
1434                 return NULL;
1435         }
1436
1437         /* Sort hints in order of original position. */
1438         qsort(hstate->all_hints, hstate->nall_hints, sizeof(Hint *),
1439                   HintCmpWithPos);
1440
1441         /* Count number of hints per hint-type. */
1442         for (i = 0; i < hstate->nall_hints; i++)
1443         {
1444                 Hint   *cur_hint = hstate->all_hints[i];
1445                 hstate->num_hints[cur_hint->type]++;
1446         }
1447
1448         /*
1449          * If an object (or a set of objects) has multiple hints of same hint-type,
1450          * only the last hint is valid and others are igonred in planning.
1451          * Hints except the last are marked as 'duplicated' to remember the order.
1452          */
1453         for (i = 0; i < hstate->nall_hints - 1; i++)
1454         {
1455                 Hint   *cur_hint = hstate->all_hints[i];
1456                 Hint   *next_hint = hstate->all_hints[i + 1];
1457
1458                 /*
1459                  * Leading hint is marked as 'duplicated' in transform_join_hints.
1460                  */
1461                 if (cur_hint->type == HINT_TYPE_LEADING &&
1462                         next_hint->type == HINT_TYPE_LEADING)
1463                         continue;
1464
1465                 /*
1466                  * Note that we need to pass addresses of hint pointers, because
1467                  * HintCmp is designed to sort array of Hint* by qsort.
1468                  */
1469                 if (HintCmp(&cur_hint, &next_hint) == 0)
1470                 {
1471                         hint_ereport(cur_hint->hint_str,
1472                                                  ("Conflict %s hint.", HintTypeName[cur_hint->type]));
1473                         cur_hint->state = HINT_STATE_DUPLICATION;
1474                 }
1475         }
1476
1477         /*
1478          * Make sure that per-type array pointers point proper position in the
1479          * array which consists of all hints.
1480          */
1481         hstate->scan_hints = (ScanMethodHint **) hstate->all_hints;
1482         hstate->join_hints = (JoinMethodHint **) (hstate->scan_hints +
1483                 hstate->num_hints[HINT_TYPE_SCAN_METHOD]);
1484         hstate->leading_hint = (LeadingHint **) (hstate->join_hints +
1485                 hstate->num_hints[HINT_TYPE_JOIN_METHOD]);
1486         hstate->set_hints = (SetHint **) (hstate->leading_hint +
1487                 hstate->num_hints[HINT_TYPE_LEADING]);
1488
1489         return hstate;
1490 }
1491
1492 /*
1493  * Parse inside of parentheses of scan-method hints.
1494  */
1495 static const char *
1496 ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
1497                                         const char *str)
1498 {
1499         const char         *keyword = hint->base.keyword;
1500         HintKeyword             hint_keyword = hint->base.hint_keyword;
1501         List               *name_list = NIL;
1502         int                             length;
1503
1504         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
1505                 return NULL;
1506
1507         /* Parse relation name and index name(s) if given hint accepts. */
1508         length = list_length(name_list);
1509         if (length > 0)
1510         {
1511                 hint->relname = linitial(name_list);
1512                 hint->indexnames = list_delete_first(name_list);
1513
1514                 /* check whether the hint accepts index name(s). */
1515                 if (length != 1 &&
1516                         hint_keyword != HINT_KEYWORD_INDEXSCAN &&
1517                         hint_keyword != HINT_KEYWORD_INDEXSCANREGEXP &&
1518 #if PG_VERSION_NUM >= 90200
1519                         hint_keyword != HINT_KEYWORD_INDEXONLYSCAN &&
1520                         hint_keyword != HINT_KEYWORD_INDEXONLYSCANREGEXP &&
1521 #endif
1522                         hint_keyword != HINT_KEYWORD_BITMAPSCAN &&
1523                         hint_keyword != HINT_KEYWORD_BITMAPSCANREGEXP)
1524                 {
1525                         hint_ereport(str,
1526                                                  ("%s hint accepts only one relation.",
1527                                                   hint->base.keyword));
1528                         hint->base.state = HINT_STATE_ERROR;
1529                         return str;
1530                 }
1531         }
1532         else
1533         {
1534                 hint_ereport(str,
1535                                          ("%s hint requires a relation.",
1536                                           hint->base.keyword));
1537                 hint->base.state = HINT_STATE_ERROR;
1538                 return str;
1539         }
1540
1541         /* Set a bit for specified hint. */
1542         switch (hint_keyword)
1543         {
1544                 case HINT_KEYWORD_SEQSCAN:
1545                         hint->enforce_mask = ENABLE_SEQSCAN;
1546                         break;
1547                 case HINT_KEYWORD_INDEXSCAN:
1548                         hint->enforce_mask = ENABLE_INDEXSCAN;
1549                         break;
1550                 case HINT_KEYWORD_INDEXSCANREGEXP:
1551                         hint->enforce_mask = ENABLE_INDEXSCAN;
1552                         hint->regexp = true;
1553                         break;
1554                 case HINT_KEYWORD_BITMAPSCAN:
1555                         hint->enforce_mask = ENABLE_BITMAPSCAN;
1556                         break;
1557                 case HINT_KEYWORD_BITMAPSCANREGEXP:
1558                         hint->enforce_mask = ENABLE_BITMAPSCAN;
1559                         hint->regexp = true;
1560                         break;
1561                 case HINT_KEYWORD_TIDSCAN:
1562                         hint->enforce_mask = ENABLE_TIDSCAN;
1563                         break;
1564                 case HINT_KEYWORD_NOSEQSCAN:
1565                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_SEQSCAN;
1566                         break;
1567                 case HINT_KEYWORD_NOINDEXSCAN:
1568                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXSCAN;
1569                         break;
1570                 case HINT_KEYWORD_NOBITMAPSCAN:
1571                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_BITMAPSCAN;
1572                         break;
1573                 case HINT_KEYWORD_NOTIDSCAN:
1574                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_TIDSCAN;
1575                         break;
1576 #if PG_VERSION_NUM >= 90200
1577                 case HINT_KEYWORD_INDEXONLYSCAN:
1578                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
1579                         break;
1580                 case HINT_KEYWORD_INDEXONLYSCANREGEXP:
1581                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
1582                         hint->regexp = true;
1583                         break;
1584                 case HINT_KEYWORD_NOINDEXONLYSCAN:
1585                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXONLYSCAN;
1586                         break;
1587 #endif
1588                 default:
1589                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
1590                         return NULL;
1591                         break;
1592         }
1593
1594         return str;
1595 }
1596
1597 static const char *
1598 JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate, Query *parse,
1599                                         const char *str)
1600 {
1601         const char         *keyword = hint->base.keyword;
1602         HintKeyword             hint_keyword = hint->base.hint_keyword;
1603         List               *name_list = NIL;
1604
1605         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
1606                 return NULL;
1607
1608         hint->nrels = list_length(name_list);
1609
1610         if (hint->nrels > 0)
1611         {
1612                 ListCell   *l;
1613                 int                     i = 0;
1614
1615                 /*
1616                  * Transform relation names from list to array to sort them with qsort
1617                  * after.
1618                  */
1619                 hint->relnames = palloc(sizeof(char *) * hint->nrels);
1620                 foreach (l, name_list)
1621                 {
1622                         hint->relnames[i] = lfirst(l);
1623                         i++;
1624                 }
1625         }
1626
1627         list_free(name_list);
1628
1629         /* A join hint requires at least two relations */
1630         if (hint->nrels < 2)
1631         {
1632                 hint_ereport(str,
1633                                          ("%s hint requires at least two relations.",
1634                                           hint->base.keyword));
1635                 hint->base.state = HINT_STATE_ERROR;
1636                 return str;
1637         }
1638
1639         /* Sort hints in alphabetical order of relation names. */
1640         qsort(hint->relnames, hint->nrels, sizeof(char *), RelnameCmp);
1641
1642         switch (hint_keyword)
1643         {
1644                 case HINT_KEYWORD_NESTLOOP:
1645                         hint->enforce_mask = ENABLE_NESTLOOP;
1646                         break;
1647                 case HINT_KEYWORD_MERGEJOIN:
1648                         hint->enforce_mask = ENABLE_MERGEJOIN;
1649                         break;
1650                 case HINT_KEYWORD_HASHJOIN:
1651                         hint->enforce_mask = ENABLE_HASHJOIN;
1652                         break;
1653                 case HINT_KEYWORD_NONESTLOOP:
1654                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_NESTLOOP;
1655                         break;
1656                 case HINT_KEYWORD_NOMERGEJOIN:
1657                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_MERGEJOIN;
1658                         break;
1659                 case HINT_KEYWORD_NOHASHJOIN:
1660                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_HASHJOIN;
1661                         break;
1662                 default:
1663                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
1664                         return NULL;
1665                         break;
1666         }
1667
1668         return str;
1669 }
1670
1671 static bool
1672 OuterInnerPairCheck(OuterInnerRels *outer_inner)
1673 {
1674         ListCell *l;
1675         if (outer_inner->outer_inner_pair == NIL)
1676         {
1677                 if (outer_inner->relation)
1678                         return true;
1679                 else
1680                         return false;
1681         }
1682
1683         if (list_length(outer_inner->outer_inner_pair) == 2)
1684         {
1685                 foreach(l, outer_inner->outer_inner_pair)
1686                 {
1687                         if (!OuterInnerPairCheck(lfirst(l)))
1688                                 return false;
1689                 }
1690         }
1691         else
1692                 return false;
1693
1694         return true;
1695 }
1696
1697 static List *
1698 OuterInnerList(OuterInnerRels *outer_inner)
1699 {
1700         List               *outer_inner_list = NIL;
1701         ListCell           *l;
1702         OuterInnerRels *outer_inner_rels;
1703
1704         foreach(l, outer_inner->outer_inner_pair)
1705         {
1706                 outer_inner_rels = (OuterInnerRels *)(lfirst(l));
1707
1708                 if (outer_inner_rels->relation != NULL)
1709                         outer_inner_list = lappend(outer_inner_list,
1710                                                                            outer_inner_rels->relation);
1711                 else
1712                         outer_inner_list = list_concat(outer_inner_list,
1713                                                                                    OuterInnerList(outer_inner_rels));
1714         }
1715         return outer_inner_list;
1716 }
1717
1718 static const char *
1719 LeadingHintParse(LeadingHint *hint, HintState *hstate, Query *parse,
1720                                  const char *str)
1721 {
1722         List               *name_list = NIL;
1723         OuterInnerRels *outer_inner = NULL;
1724
1725         if ((str = parse_parentheses_Leading(str, &name_list, &outer_inner)) ==
1726                 NULL)
1727                 return NULL;
1728
1729         if (outer_inner != NULL)
1730                 name_list = OuterInnerList(outer_inner);
1731
1732         hint->relations = name_list;
1733         hint->outer_inner = outer_inner;
1734
1735         /* A Leading hint requires at least two relations */
1736         if ( hint->outer_inner == NULL && list_length(hint->relations) < 2)
1737         {
1738                 hint_ereport(hint->base.hint_str,
1739                                          ("%s hint requires at least two relations.",
1740                                           HINT_LEADING));
1741                 hint->base.state = HINT_STATE_ERROR;
1742         }
1743         else if (hint->outer_inner != NULL &&
1744                          !OuterInnerPairCheck(hint->outer_inner))
1745         {
1746                 hint_ereport(hint->base.hint_str,
1747                                          ("%s hint requires two sets of relations when parentheses nests.",
1748                                           HINT_LEADING));
1749                 hint->base.state = HINT_STATE_ERROR;
1750         }
1751
1752         return str;
1753 }
1754
1755 static const char *
1756 SetHintParse(SetHint *hint, HintState *hstate, Query *parse, const char *str)
1757 {
1758         List   *name_list = NIL;
1759
1760         if ((str = parse_parentheses(str, &name_list, hint->base.hint_keyword))
1761                 == NULL)
1762                 return NULL;
1763
1764         hint->words = name_list;
1765
1766         /* We need both name and value to set GUC parameter. */
1767         if (list_length(name_list) == 2)
1768         {
1769                 hint->name = linitial(name_list);
1770                 hint->value = lsecond(name_list);
1771         }
1772         else
1773         {
1774                 hint_ereport(hint->base.hint_str,
1775                                          ("%s hint requires name and value of GUC parameter.",
1776                                           HINT_SET));
1777                 hint->base.state = HINT_STATE_ERROR;
1778         }
1779
1780         return str;
1781 }
1782
1783 /*
1784  * set GUC parameter functions
1785  */
1786
1787 static int
1788 set_config_option_wrapper(const char *name, const char *value,
1789                                                   GucContext context, GucSource source,
1790                                                   GucAction action, bool changeVal, int elevel)
1791 {
1792         int                             result = 0;
1793         MemoryContext   ccxt = CurrentMemoryContext;
1794
1795         PG_TRY();
1796         {
1797 #if PG_VERSION_NUM >= 90200
1798                 result = set_config_option(name, value, context, source,
1799                                                                    action, changeVal, 0);
1800 #else
1801                 result = set_config_option(name, value, context, source,
1802                                                                    action, changeVal);
1803 #endif
1804         }
1805         PG_CATCH();
1806         {
1807                 ErrorData          *errdata;
1808
1809                 /* Save error info */
1810                 MemoryContextSwitchTo(ccxt);
1811                 errdata = CopyErrorData();
1812                 FlushErrorState();
1813
1814                 ereport(elevel, (errcode(errdata->sqlerrcode),
1815                                 errmsg("%s", errdata->message),
1816                                 errdata->detail ? errdetail("%s", errdata->detail) : 0,
1817                                 errdata->hint ? errhint("%s", errdata->hint) : 0));
1818                 FreeErrorData(errdata);
1819         }
1820         PG_END_TRY();
1821
1822         return result;
1823 }
1824
1825 static int
1826 set_config_options(SetHint **options, int noptions, GucContext context)
1827 {
1828         int     i;
1829         int     save_nestlevel;
1830
1831         save_nestlevel = NewGUCNestLevel();
1832
1833         for (i = 0; i < noptions; i++)
1834         {
1835                 SetHint    *hint = options[i];
1836                 int                     result;
1837
1838                 if (!hint_state_enabled(hint))
1839                         continue;
1840
1841                 result = set_config_option_wrapper(hint->name, hint->value, context,
1842                                                                                    PGC_S_SESSION, GUC_ACTION_SAVE, true,
1843                                                                                    pg_hint_plan_parse_messages);
1844                 if (result != 0)
1845                         hint->base.state = HINT_STATE_USED;
1846                 else
1847                         hint->base.state = HINT_STATE_ERROR;
1848         }
1849
1850         return save_nestlevel;
1851 }
1852
1853 #define SET_CONFIG_OPTION(name, type_bits) \
1854         set_config_option_wrapper((name), \
1855                 (mask & (type_bits)) ? "true" : "false", \
1856                 context, PGC_S_SESSION, GUC_ACTION_SAVE, true, ERROR)
1857
1858 static void
1859 set_scan_config_options(unsigned char enforce_mask, GucContext context)
1860 {
1861         unsigned char   mask;
1862
1863         if (enforce_mask == ENABLE_SEQSCAN || enforce_mask == ENABLE_INDEXSCAN ||
1864                 enforce_mask == ENABLE_BITMAPSCAN || enforce_mask == ENABLE_TIDSCAN
1865 #if PG_VERSION_NUM >= 90200
1866                 || enforce_mask == (ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN)
1867 #endif
1868                 )
1869                 mask = enforce_mask;
1870         else
1871                 mask = enforce_mask & current_hint->init_scan_mask;
1872
1873         SET_CONFIG_OPTION("enable_seqscan", ENABLE_SEQSCAN);
1874         SET_CONFIG_OPTION("enable_indexscan", ENABLE_INDEXSCAN);
1875         SET_CONFIG_OPTION("enable_bitmapscan", ENABLE_BITMAPSCAN);
1876         SET_CONFIG_OPTION("enable_tidscan", ENABLE_TIDSCAN);
1877 #if PG_VERSION_NUM >= 90200
1878         SET_CONFIG_OPTION("enable_indexonlyscan", ENABLE_INDEXONLYSCAN);
1879 #endif
1880 }
1881
1882 static void
1883 set_join_config_options(unsigned char enforce_mask, GucContext context)
1884 {
1885         unsigned char   mask;
1886
1887         if (enforce_mask == ENABLE_NESTLOOP || enforce_mask == ENABLE_MERGEJOIN ||
1888                 enforce_mask == ENABLE_HASHJOIN)
1889                 mask = enforce_mask;
1890         else
1891                 mask = enforce_mask & current_hint->init_join_mask;
1892
1893         SET_CONFIG_OPTION("enable_nestloop", ENABLE_NESTLOOP);
1894         SET_CONFIG_OPTION("enable_mergejoin", ENABLE_MERGEJOIN);
1895         SET_CONFIG_OPTION("enable_hashjoin", ENABLE_HASHJOIN);
1896 }
1897
1898 /*
1899  * pg_hint_plan hook functions
1900  */
1901
1902 static void
1903 pg_hint_plan_ProcessUtility(Node *parsetree, const char *queryString,
1904                                                         ParamListInfo params, bool isTopLevel,
1905                                                         DestReceiver *dest, char *completionTag)
1906 {
1907         Node                               *node;
1908
1909         if (!pg_hint_plan_enable_hint)
1910         {
1911                 if (prev_ProcessUtility)
1912                         (*prev_ProcessUtility) (parsetree, queryString, params,
1913                                                                         isTopLevel, dest, completionTag);
1914                 else
1915                         standard_ProcessUtility(parsetree, queryString, params,
1916                                                                         isTopLevel, dest, completionTag);
1917
1918                 return;
1919         }
1920
1921         node = parsetree;
1922         if (IsA(node, ExplainStmt))
1923         {
1924                 /*
1925                  * Draw out parse tree of actual query from Query struct of EXPLAIN
1926                  * statement.
1927                  */
1928                 ExplainStmt        *stmt;
1929                 Query              *query;
1930
1931                 stmt = (ExplainStmt *) node;
1932
1933                 Assert(IsA(stmt->query, Query));
1934                 query = (Query *) stmt->query;
1935
1936                 if (query->commandType == CMD_UTILITY && query->utilityStmt != NULL)
1937                         node = query->utilityStmt;
1938         }
1939
1940         /*
1941          * If the query was a EXECUTE or CREATE TABLE AS EXECUTE, get query string
1942          * specified to preceding PREPARE command to use it as source of hints.
1943          */
1944         if (IsA(node, ExecuteStmt))
1945         {
1946                 ExecuteStmt        *stmt;
1947
1948                 stmt = (ExecuteStmt *) node;
1949                 stmt_name = stmt->name;
1950         }
1951 #if PG_VERSION_NUM >= 90200
1952         /*
1953          * CREATE AS EXECUTE behavior has changed since 9.2, so we must handle it
1954          * specially here.
1955          */
1956         if (IsA(node, CreateTableAsStmt))
1957         {
1958                 CreateTableAsStmt          *stmt;
1959                 Query              *query;
1960
1961                 stmt = (CreateTableAsStmt *) node;
1962                 Assert(IsA(stmt->query, Query));
1963                 query = (Query *) stmt->query;
1964
1965                 if (query->commandType == CMD_UTILITY &&
1966                         IsA(query->utilityStmt, ExecuteStmt))
1967                 {
1968                         ExecuteStmt *estmt = (ExecuteStmt *) query->utilityStmt;
1969                         stmt_name = estmt->name;
1970                 }
1971         }
1972 #endif
1973         if (stmt_name)
1974         {
1975                 PG_TRY();
1976                 {
1977                         if (prev_ProcessUtility)
1978                                 (*prev_ProcessUtility) (parsetree, queryString, params,
1979                                                                                 isTopLevel, dest, completionTag);
1980                         else
1981                                 standard_ProcessUtility(parsetree, queryString, params,
1982                                                                                 isTopLevel, dest, completionTag);
1983                 }
1984                 PG_CATCH();
1985                 {
1986                         stmt_name = NULL;
1987                         PG_RE_THROW();
1988                 }
1989                 PG_END_TRY();
1990
1991                 stmt_name = NULL;
1992
1993                 return;
1994         }
1995
1996         if (prev_ProcessUtility)
1997                 (*prev_ProcessUtility) (parsetree, queryString, params,
1998                                                                 isTopLevel, dest, completionTag);
1999         else
2000                 standard_ProcessUtility(parsetree, queryString, params,
2001                                                                 isTopLevel, dest, completionTag);
2002 }
2003
2004 /*
2005  * Push a hint into hint stack which is implemented with List struct.  Head of
2006  * list is top of stack.
2007  */
2008 static void
2009 push_hint(HintState *hstate)
2010 {
2011         /* Prepend new hint to the list means pushing to stack. */
2012         HintStateStack = lcons(hstate, HintStateStack);
2013
2014         /* Pushed hint is the one which should be used hereafter. */
2015         current_hint = hstate;
2016 }
2017
2018 /* Pop a hint from hint stack.  Popped hint is automatically discarded. */
2019 static void
2020 pop_hint(void)
2021 {
2022         /* Hint stack must not be empty. */
2023         if(HintStateStack == NIL)
2024                 elog(ERROR, "hint stack is empty");
2025
2026         /*
2027          * Take a hint at the head from the list, and free it.  Switch current_hint
2028          * to point new head (NULL if the list is empty).
2029          */
2030         HintStateStack = list_delete_first(HintStateStack);
2031         HintStateDelete(current_hint);
2032         if(HintStateStack == NIL)
2033                 current_hint = NULL;
2034         else
2035                 current_hint = (HintState *) lfirst(list_head(HintStateStack));
2036 }
2037
2038 static PlannedStmt *
2039 pg_hint_plan_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
2040 {
2041         const char         *hints;
2042         int                             save_nestlevel;
2043         PlannedStmt        *result;
2044         HintState          *hstate;
2045
2046         /*
2047          * Use standard planner if pg_hint_plan is disabled.  Other hook functions
2048          * try to change plan with current_hint if any, so set it to NULL.
2049          */
2050         if (!pg_hint_plan_enable_hint)
2051         {
2052                 current_hint = NULL;
2053
2054                 if (prev_planner)
2055                         return (*prev_planner) (parse, cursorOptions, boundParams);
2056                 else
2057                         return standard_planner(parse, cursorOptions, boundParams);
2058         }
2059
2060         /* Create hint struct from parse tree. */
2061         /*
2062          *      ヒント用テーブル方式を実装する前段階として、
2063          *      parse_head_comment()をクエリに記述されたヒントを見つける処理と
2064          *      ヒントをパースする処理に分割した。
2065          */
2066         hints = find_hints_comment();
2067         elog(LOG, "pg_hint_plan: [%s] => [%s]", debug_query_string
2068                                                                                   , hints ? hints : "(none)");
2069         hstate = get_hintstate(parse, hints);
2070
2071         /*
2072          * Use standard planner if the statement has not valid hint.  Other hook
2073          * functions try to change plan with current_hint if any, so set it to
2074          * NULL.
2075          */
2076         if (!hstate)
2077         {
2078                 current_hint = NULL;
2079
2080                 if (prev_planner)
2081                         return (*prev_planner) (parse, cursorOptions, boundParams);
2082                 else
2083                         return standard_planner(parse, cursorOptions, boundParams);
2084         }
2085
2086         /*
2087          * Push new hint struct to the hint stack to disable previous hint context.
2088          */
2089         push_hint(hstate);
2090
2091         /* Set GUC parameters which are specified with Set hint. */
2092         save_nestlevel = set_config_options(current_hint->set_hints,
2093                                                                                 current_hint->num_hints[HINT_TYPE_SET],
2094                                                                                 current_hint->context);
2095
2096         if (enable_seqscan)
2097                 current_hint->init_scan_mask |= ENABLE_SEQSCAN;
2098         if (enable_indexscan)
2099                 current_hint->init_scan_mask |= ENABLE_INDEXSCAN;
2100         if (enable_bitmapscan)
2101                 current_hint->init_scan_mask |= ENABLE_BITMAPSCAN;
2102         if (enable_tidscan)
2103                 current_hint->init_scan_mask |= ENABLE_TIDSCAN;
2104 #if PG_VERSION_NUM >= 90200
2105         if (enable_indexonlyscan)
2106                 current_hint->init_scan_mask |= ENABLE_INDEXONLYSCAN;
2107 #endif
2108         if (enable_nestloop)
2109                 current_hint->init_join_mask |= ENABLE_NESTLOOP;
2110         if (enable_mergejoin)
2111                 current_hint->init_join_mask |= ENABLE_MERGEJOIN;
2112         if (enable_hashjoin)
2113                 current_hint->init_join_mask |= ENABLE_HASHJOIN;
2114
2115         /*
2116          * Use PG_TRY mechanism to recover GUC parameters and current_hint to the
2117          * state when this planner started when error occurred in planner.
2118          */
2119         PG_TRY();
2120         {
2121                 if (prev_planner)
2122                         result = (*prev_planner) (parse, cursorOptions, boundParams);
2123                 else
2124                         result = standard_planner(parse, cursorOptions, boundParams);
2125         }
2126         PG_CATCH();
2127         {
2128                 /*
2129                  * Rollback changes of GUC parameters, and pop current hint context
2130                  * from hint stack to rewind the state.
2131                  */
2132                 AtEOXact_GUC(true, save_nestlevel);
2133                 pop_hint();
2134                 PG_RE_THROW();
2135         }
2136         PG_END_TRY();
2137
2138         /* Print hint in debug mode. */
2139         if (pg_hint_plan_debug_print)
2140                 HintStateDump(current_hint);
2141
2142         /*
2143          * Rollback changes of GUC parameters, and pop current hint context from
2144          * hint stack to rewind the state.
2145          */
2146         AtEOXact_GUC(true, save_nestlevel);
2147         pop_hint();
2148
2149         return result;
2150 }
2151
2152 /*
2153  * Return scan method hint which matches given aliasname.
2154  */
2155 static ScanMethodHint *
2156 find_scan_hint(PlannerInfo *root, RelOptInfo *rel)
2157 {
2158         RangeTblEntry  *rte;
2159         int                             i;
2160
2161         /*
2162          * We can't apply scan method hint if the relation is:
2163          *   - not a base relation
2164          *   - not an ordinary relation (such as join and subquery)
2165          */
2166         if (rel->reloptkind != RELOPT_BASEREL || rel->rtekind != RTE_RELATION)
2167                 return NULL;
2168
2169         rte = root->simple_rte_array[rel->relid];
2170
2171         /* We can't force scan method of foreign tables */
2172         if (rte->relkind == RELKIND_FOREIGN_TABLE)
2173                 return NULL;
2174
2175         /* Find scan method hint, which matches given names, from the list. */
2176         for (i = 0; i < current_hint->num_hints[HINT_TYPE_SCAN_METHOD]; i++)
2177         {
2178                 ScanMethodHint *hint = current_hint->scan_hints[i];
2179
2180                 /* We ignore disabled hints. */
2181                 if (!hint_state_enabled(hint))
2182                         continue;
2183
2184                 if (RelnameCmp(&rte->eref->aliasname, &hint->relname) == 0)
2185                         return hint;
2186         }
2187
2188         return NULL;
2189 }
2190
2191 /*
2192  * regexeq
2193  *
2194  * Returns TRUE on match, FALSE on no match.
2195  *
2196  *   s1 --- the data to match against
2197  *   s2 --- the pattern
2198  *
2199  * Because we copy s1 to NameData, make the size of s1 less than NAMEDATALEN.
2200  */
2201 static bool
2202 regexpeq(const char *s1, const char *s2)
2203 {
2204         NameData        name;
2205         text       *regexp;
2206         Datum           result;
2207
2208         strcpy(name.data, s1);
2209         regexp = cstring_to_text(s2);
2210
2211         result = DirectFunctionCall2Coll(nameregexeq,
2212                                                                          DEFAULT_COLLATION_OID,
2213                                                                          NameGetDatum(&name),
2214                                                                          PointerGetDatum(regexp));
2215         return DatumGetBool(result);
2216 }
2217
2218 static void
2219 delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
2220 {
2221         ListCell           *cell;
2222         ListCell           *prev;
2223         ListCell           *next;
2224         StringInfoData  buf;
2225
2226         /*
2227          * We delete all the IndexOptInfo list and prevent you from being usable by
2228          * a scan.
2229          */
2230         if (hint->enforce_mask == ENABLE_SEQSCAN ||
2231                 hint->enforce_mask == ENABLE_TIDSCAN)
2232         {
2233                 list_free_deep(rel->indexlist);
2234                 rel->indexlist = NIL;
2235                 hint->base.state = HINT_STATE_USED;
2236
2237                 return;
2238         }
2239
2240         /*
2241          * When a list of indexes is not specified, we just use all indexes.
2242          */
2243         if (hint->indexnames == NIL)
2244                 return;
2245
2246         /*
2247          * Leaving only an specified index, we delete it from a IndexOptInfo list
2248          * other than it.
2249          */
2250         prev = NULL;
2251         if (pg_hint_plan_debug_print)
2252                 initStringInfo(&buf);
2253
2254         for (cell = list_head(rel->indexlist); cell; cell = next)
2255         {
2256                 IndexOptInfo   *info = (IndexOptInfo *) lfirst(cell);
2257                 char               *indexname = get_rel_name(info->indexoid);
2258                 ListCell           *l;
2259                 bool                    use_index = false;
2260
2261                 next = lnext(cell);
2262
2263                 foreach(l, hint->indexnames)
2264                 {
2265                         char   *hintname = (char *) lfirst(l);
2266                         bool    result;
2267
2268                         if (hint->regexp)
2269                                 result = regexpeq(indexname, hintname);
2270                         else
2271                                 result = RelnameCmp(&indexname, &hintname) == 0;
2272
2273                         if (result)
2274                         {
2275                                 use_index = true;
2276                                 if (pg_hint_plan_debug_print)
2277                                 {
2278                                         appendStringInfoCharMacro(&buf, ' ');
2279                                         quote_value(&buf, indexname);
2280                                 }
2281
2282                                 break;
2283                         }
2284                 }
2285
2286                 /*
2287                  * to make the index a candidate when definition of this index is
2288                  * matched with the index's definition of current_hint.
2289                  */
2290                 if (OidIsValid(relationObjectId) && !use_index)
2291                 {
2292                         foreach(l, current_hint->parent_index_infos)
2293                         {
2294                                 int                                     i;
2295                                 HeapTuple                       ht_idx;
2296                                 ParentIndexInfo    *p_info = (ParentIndexInfo *)lfirst(l);
2297
2298                                 /* check to match the parameter of unique */
2299                                 if (p_info->indisunique != info->unique)
2300                                         continue;
2301
2302                                 /* check to match the parameter of index's method */
2303                                 if (p_info->method != info->relam)
2304                                         continue;
2305
2306                                 /* to check to match the indexkey's configuration */
2307                                 if ((list_length(p_info->column_names)) !=
2308                                          info->ncolumns)
2309                                         continue;
2310
2311                                 /* check to match the indexkey's configuration */
2312                                 for (i = 0; i < info->ncolumns; i++)
2313                                 {
2314                                         char       *c_attname = NULL;
2315                                         char       *p_attname = NULL;
2316
2317                                         p_attname =
2318                                                 list_nth(p_info->column_names, i);
2319
2320                                         /* both are expressions */
2321                                         if (info->indexkeys[i] == 0 && !p_attname)
2322                                                 continue;
2323
2324                                         /* one's column is expression, the other is not */
2325                                         if (info->indexkeys[i] == 0 || !p_attname)
2326                                                 break;
2327
2328                                         c_attname = get_attname(relationObjectId,
2329                                                                                                 info->indexkeys[i]);
2330
2331                                         if (strcmp(p_attname, c_attname) != 0)
2332                                                 break;
2333
2334                                         if (p_info->indcollation[i] != info->indexcollations[i])
2335                                                 break;
2336
2337                                         if (p_info->opclass[i] != info->opcintype[i])
2338                                                 break;
2339
2340                                         if (((p_info->indoption[i] & INDOPTION_DESC) != 0) !=
2341                                                 info->reverse_sort[i])
2342                                                 break;
2343
2344                                         if (((p_info->indoption[i] & INDOPTION_NULLS_FIRST) != 0) !=
2345                                                 info->nulls_first[i])
2346                                                 break;
2347
2348                                 }
2349
2350                                 if (i != info->ncolumns)
2351                                         continue;
2352
2353                                 if ((p_info->expression_str && (info->indexprs != NIL)) ||
2354                                         (p_info->indpred_str && (info->indpred != NIL)))
2355                                 {
2356                                         /*
2357                                          * Fetch the pg_index tuple by the Oid of the index
2358                                          */
2359                                         ht_idx = SearchSysCache1(INDEXRELID,
2360                                                                                          ObjectIdGetDatum(info->indexoid));
2361
2362                                         /* check to match the expression's parameter of index */
2363                                         if (p_info->expression_str &&
2364                                                 !heap_attisnull(ht_idx, Anum_pg_index_indexprs))
2365                                         {
2366                                                 Datum       exprsDatum;
2367                                                 bool        isnull;
2368                                                 Datum       result;
2369
2370                                                 /*
2371                                                  * to change the expression's parameter of child's
2372                                                  * index to strings
2373                                                  */
2374                                                 exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
2375                                                                                                          Anum_pg_index_indexprs,
2376                                                                                                          &isnull);
2377
2378                                                 result = DirectFunctionCall2(pg_get_expr,
2379                                                                                                          exprsDatum,
2380                                                                                                          ObjectIdGetDatum(
2381                                                                                                                  relationObjectId));
2382
2383                                                 if (strcmp(p_info->expression_str,
2384                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
2385                                                 {
2386                                                         /* Clean up */
2387                                                         ReleaseSysCache(ht_idx);
2388
2389                                                         continue;
2390                                                 }
2391                                         }
2392
2393                                         /* Check to match the predicate's paraameter of index */
2394                                         if (p_info->indpred_str &&
2395                                                 !heap_attisnull(ht_idx, Anum_pg_index_indpred))
2396                                         {
2397                                                 Datum       predDatum;
2398                                                 bool        isnull;
2399                                                 Datum       result;
2400
2401                                                 /*
2402                                                  * to change the predicate's parabeter of child's
2403                                                  * index to strings
2404                                                  */
2405                                                 predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
2406                                                                                                          Anum_pg_index_indpred,
2407                                                                                                          &isnull);
2408
2409                                                 result = DirectFunctionCall2(pg_get_expr,
2410                                                                                                          predDatum,
2411                                                                                                          ObjectIdGetDatum(
2412                                                                                                                  relationObjectId));
2413
2414                                                 if (strcmp(p_info->indpred_str,
2415                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
2416                                                 {
2417                                                         /* Clean up */
2418                                                         ReleaseSysCache(ht_idx);
2419
2420                                                         continue;
2421                                                 }
2422                                         }
2423
2424                                         /* Clean up */
2425                                         ReleaseSysCache(ht_idx);
2426                                 }
2427                                 else if (p_info->expression_str || (info->indexprs != NIL))
2428                                         continue;
2429                                 else if (p_info->indpred_str || (info->indpred != NIL))
2430                                         continue;
2431
2432                                 use_index = true;
2433
2434                                 /* to log the candidate of index */
2435                                 if (pg_hint_plan_debug_print)
2436                                 {
2437                                         appendStringInfoCharMacro(&buf, ' ');
2438                                         quote_value(&buf, indexname);
2439                                 }
2440
2441                                 break;
2442                         }
2443                 }
2444
2445                 if (!use_index)
2446                         rel->indexlist = list_delete_cell(rel->indexlist, cell, prev);
2447                 else
2448                         prev = cell;
2449
2450                 pfree(indexname);
2451         }
2452
2453         if (pg_hint_plan_debug_print)
2454         {
2455                 char   *relname;
2456                 StringInfoData  rel_buf;
2457
2458                 if (OidIsValid(relationObjectId))
2459                         relname = get_rel_name(relationObjectId);
2460                 else
2461                         relname = hint->relname;
2462
2463                 initStringInfo(&rel_buf);
2464                 quote_value(&rel_buf, relname);
2465
2466                 ereport(LOG,
2467                                 (errmsg("available indexes for %s(%s):%s",
2468                                          hint->base.keyword,
2469                                          rel_buf.data,
2470                                          buf.data)));
2471                 pfree(buf.data);
2472                 pfree(rel_buf.data);
2473         }
2474 }
2475
2476 /*
2477  * Return information of index definition.
2478  */
2479 static ParentIndexInfo *
2480 get_parent_index_info(Oid indexoid, Oid relid)
2481 {
2482         ParentIndexInfo *p_info = palloc(sizeof(ParentIndexInfo));
2483         Relation            indexRelation;
2484         Form_pg_index   index;
2485         char               *attname;
2486         int                             i;
2487
2488         indexRelation = index_open(indexoid, RowExclusiveLock);
2489
2490         index = indexRelation->rd_index;
2491
2492         p_info->indisunique = index->indisunique;
2493         p_info->method = indexRelation->rd_rel->relam;
2494
2495         p_info->column_names = NIL;
2496         p_info->indcollation = (Oid *) palloc(sizeof(Oid) * index->indnatts);
2497         p_info->opclass = (Oid *) palloc(sizeof(Oid) * index->indnatts);
2498         p_info->indoption = (int16 *) palloc(sizeof(Oid) * index->indnatts);
2499
2500         for (i = 0; i < index->indnatts; i++)
2501         {
2502                 attname = get_attname(relid, index->indkey.values[i]);
2503                 p_info->column_names = lappend(p_info->column_names, attname);
2504
2505                 p_info->indcollation[i] = indexRelation->rd_indcollation[i];
2506                 p_info->opclass[i] = indexRelation->rd_opcintype[i];
2507                 p_info->indoption[i] = indexRelation->rd_indoption[i];
2508         }
2509
2510         /*
2511          * to check to match the expression's paraameter of index with child indexes
2512          */
2513         p_info->expression_str = NULL;
2514         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indexprs))
2515         {
2516                 Datum       exprsDatum;
2517                 bool            isnull;
2518                 Datum           result;
2519
2520                 exprsDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
2521                                                                          Anum_pg_index_indexprs, &isnull);
2522
2523                 result = DirectFunctionCall2(pg_get_expr,
2524                                                                          exprsDatum,
2525                                                                          ObjectIdGetDatum(relid));
2526
2527                 p_info->expression_str = text_to_cstring(DatumGetTextP(result));
2528         }
2529
2530         /*
2531          * to check to match the predicate's paraameter of index with child indexes
2532          */
2533         p_info->indpred_str = NULL;
2534         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indpred))
2535         {
2536                 Datum       predDatum;
2537                 bool            isnull;
2538                 Datum           result;
2539
2540                 predDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
2541                                                                          Anum_pg_index_indpred, &isnull);
2542
2543                 result = DirectFunctionCall2(pg_get_expr,
2544                                                                          predDatum,
2545                                                                          ObjectIdGetDatum(relid));
2546
2547                 p_info->indpred_str = text_to_cstring(DatumGetTextP(result));
2548         }
2549
2550         index_close(indexRelation, NoLock);
2551
2552         return p_info;
2553 }
2554
2555 static void
2556 pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
2557                                                            bool inhparent, RelOptInfo *rel)
2558 {
2559         ScanMethodHint *hint;
2560
2561         if (prev_get_relation_info)
2562                 (*prev_get_relation_info) (root, relationObjectId, inhparent, rel);
2563
2564         /* Do nothing if we don't have valid hint in this context. */
2565         if (!current_hint)
2566                 return;
2567
2568         if (inhparent)
2569         {
2570                 /* store does relids of parent table. */
2571                 current_hint->parent_relid = rel->relid;
2572                 current_hint->parent_rel_oid = relationObjectId;
2573         }
2574         else if (current_hint->parent_relid != 0)
2575         {
2576                 /*
2577                  * We use the same GUC parameter if this table is the child table of a
2578                  * table called pg_hint_plan_get_relation_info just before that.
2579                  */
2580                 ListCell   *l;
2581
2582                 /* append_rel_list contains all append rels; ignore others */
2583                 foreach(l, root->append_rel_list)
2584                 {
2585                         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
2586
2587                         /* This rel is child table. */
2588                         if (appinfo->parent_relid == current_hint->parent_relid &&
2589                                 appinfo->child_relid == rel->relid)
2590                         {
2591                                 if (current_hint->parent_hint)
2592                                         delete_indexes(current_hint->parent_hint, rel,
2593                                                                    relationObjectId);
2594
2595                                 return;
2596                         }
2597                 }
2598
2599                 /* This rel is not inherit table. */
2600                 current_hint->parent_relid = 0;
2601                 current_hint->parent_rel_oid = InvalidOid;
2602                 current_hint->parent_hint = NULL;
2603         }
2604
2605         /*
2606          * If scan method hint was given, reset GUC parameters which control
2607          * planner behavior about choosing scan methods.
2608          */
2609         if ((hint = find_scan_hint(root, rel)) == NULL)
2610         {
2611                 set_scan_config_options(current_hint->init_scan_mask,
2612                                                                 current_hint->context);
2613                 return;
2614         }
2615         set_scan_config_options(hint->enforce_mask, current_hint->context);
2616         hint->base.state = HINT_STATE_USED;
2617
2618         if (inhparent)
2619         {
2620                 Relation    relation;
2621                 List       *indexoidlist;
2622                 ListCell   *l;
2623
2624                 current_hint->parent_hint = hint;
2625
2626                 relation = heap_open(relationObjectId, NoLock);
2627                 indexoidlist = RelationGetIndexList(relation);
2628
2629                 foreach(l, indexoidlist)
2630                 {
2631                         Oid         indexoid = lfirst_oid(l);
2632                         char       *indexname = get_rel_name(indexoid);
2633                         bool        use_index = false;
2634                         ListCell   *lc;
2635                         ParentIndexInfo *parent_index_info;
2636
2637                         foreach(lc, hint->indexnames)
2638                         {
2639                                 if (RelnameCmp(&indexname, &lfirst(lc)) == 0)
2640                                 {
2641                                         use_index = true;
2642                                         break;
2643                                 }
2644                         }
2645                         if (!use_index)
2646                                 continue;
2647
2648                         parent_index_info = get_parent_index_info(indexoid,
2649                                                                                                           relationObjectId);
2650                         current_hint->parent_index_infos =
2651                                 lappend(current_hint->parent_index_infos, parent_index_info);
2652                 }
2653                 heap_close(relation, NoLock);
2654         }
2655         else
2656                 delete_indexes(hint, rel, InvalidOid);
2657 }
2658
2659 /*
2660  * Return index of relation which matches given aliasname, or 0 if not found.
2661  * If same aliasname was used multiple times in a query, return -1.
2662  */
2663 static int
2664 find_relid_aliasname(PlannerInfo *root, char *aliasname, List *initial_rels,
2665                                          const char *str)
2666 {
2667         int             i;
2668         Index   found = 0;
2669
2670         for (i = 1; i < root->simple_rel_array_size; i++)
2671         {
2672                 ListCell   *l;
2673
2674                 if (root->simple_rel_array[i] == NULL)
2675                         continue;
2676
2677                 Assert(i == root->simple_rel_array[i]->relid);
2678
2679                 if (RelnameCmp(&aliasname,
2680                                            &root->simple_rte_array[i]->eref->aliasname) != 0)
2681                         continue;
2682
2683                 foreach(l, initial_rels)
2684                 {
2685                         RelOptInfo *rel = (RelOptInfo *) lfirst(l);
2686
2687                         if (rel->reloptkind == RELOPT_BASEREL)
2688                         {
2689                                 if (rel->relid != i)
2690                                         continue;
2691                         }
2692                         else
2693                         {
2694                                 Assert(rel->reloptkind == RELOPT_JOINREL);
2695
2696                                 if (!bms_is_member(i, rel->relids))
2697                                         continue;
2698                         }
2699
2700                         if (found != 0)
2701                         {
2702                                 hint_ereport(str,
2703                                                          ("Relation name \"%s\" is ambiguous.",
2704                                                           aliasname));
2705                                 return -1;
2706                         }
2707
2708                         found = i;
2709                         break;
2710                 }
2711
2712         }
2713
2714         return found;
2715 }
2716
2717 /*
2718  * Return join hint which matches given joinrelids.
2719  */
2720 static JoinMethodHint *
2721 find_join_hint(Relids joinrelids)
2722 {
2723         List       *join_hint;
2724         ListCell   *l;
2725
2726         join_hint = current_hint->join_hint_level[bms_num_members(joinrelids)];
2727
2728         foreach(l, join_hint)
2729         {
2730                 JoinMethodHint *hint = (JoinMethodHint *) lfirst(l);
2731
2732                 if (bms_equal(joinrelids, hint->joinrelids))
2733                         return hint;
2734         }
2735
2736         return NULL;
2737 }
2738
2739 static Relids
2740 OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
2741         PlannerInfo *root, List *initial_rels, HintState *hstate, int nbaserel)
2742 {
2743         OuterInnerRels *outer_rels;
2744         OuterInnerRels *inner_rels;
2745         Relids                  outer_relids;
2746         Relids                  inner_relids;
2747         Relids                  join_relids;
2748         JoinMethodHint *hint;
2749
2750         if (outer_inner->relation != NULL)
2751         {
2752                 return bms_make_singleton(
2753                                         find_relid_aliasname(root, outer_inner->relation,
2754                                                                                  initial_rels,
2755                                                                                  leading_hint->base.hint_str));
2756         }
2757
2758         outer_rels = lfirst(outer_inner->outer_inner_pair->head);
2759         inner_rels = lfirst(outer_inner->outer_inner_pair->tail);
2760
2761         outer_relids = OuterInnerJoinCreate(outer_rels,
2762                                                                                 leading_hint,
2763                                                                                 root,
2764                                                                                 initial_rels,
2765                                                                                 hstate,
2766                                                                                 nbaserel);
2767         inner_relids = OuterInnerJoinCreate(inner_rels,
2768                                                                                 leading_hint,
2769                                                                                 root,
2770                                                                                 initial_rels,
2771                                                                                 hstate,
2772                                                                                 nbaserel);
2773
2774         join_relids = bms_add_members(outer_relids, inner_relids);
2775
2776         if (bms_num_members(join_relids) > nbaserel)
2777                 return join_relids;
2778
2779         /*
2780          * If we don't have join method hint, create new one for the
2781          * join combination with all join methods are enabled.
2782          */
2783         hint = find_join_hint(join_relids);
2784         if (hint == NULL)
2785         {
2786                 /*
2787                  * Here relnames is not set, since Relids bitmap is sufficient to
2788                  * control paths of this query afterward.
2789                  */
2790                 hint = (JoinMethodHint *) JoinMethodHintCreate(
2791                                         leading_hint->base.hint_str,
2792                                         HINT_LEADING,
2793                                         HINT_KEYWORD_LEADING);
2794                 hint->base.state = HINT_STATE_USED;
2795                 hint->nrels = bms_num_members(join_relids);
2796                 hint->enforce_mask = ENABLE_ALL_JOIN;
2797                 hint->joinrelids = bms_copy(join_relids);
2798                 hint->inner_nrels = bms_num_members(inner_relids);
2799                 hint->inner_joinrelids = bms_copy(inner_relids);
2800
2801                 hstate->join_hint_level[hint->nrels] =
2802                         lappend(hstate->join_hint_level[hint->nrels], hint);
2803         }
2804         else
2805         {
2806                 hint->inner_nrels = bms_num_members(inner_relids);
2807                 hint->inner_joinrelids = bms_copy(inner_relids);
2808         }
2809
2810         return join_relids;
2811 }
2812
2813 /*
2814  * Transform join method hint into handy form.
2815  *
2816  *   - create bitmap of relids from alias names, to make it easier to check
2817  *     whether a join path matches a join method hint.
2818  *   - add join method hints which are necessary to enforce join order
2819  *     specified by Leading hint
2820  */
2821 static bool
2822 transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
2823                 List *initial_rels, JoinMethodHint **join_method_hints)
2824 {
2825         int                             i;
2826         int                             relid;
2827         Relids                  joinrelids;
2828         int                             njoinrels;
2829         ListCell           *l;
2830         char               *relname;
2831         LeadingHint        *lhint = NULL;
2832
2833         /*
2834          * Create bitmap of relids from alias names for each join method hint.
2835          * Bitmaps are more handy than strings in join searching.
2836          */
2837         for (i = 0; i < hstate->num_hints[HINT_TYPE_JOIN_METHOD]; i++)
2838         {
2839                 JoinMethodHint *hint = hstate->join_hints[i];
2840                 int     j;
2841
2842                 if (!hint_state_enabled(hint) || hint->nrels > nbaserel)
2843                         continue;
2844
2845                 bms_free(hint->joinrelids);
2846                 hint->joinrelids = NULL;
2847                 relid = 0;
2848                 for (j = 0; j < hint->nrels; j++)
2849                 {
2850                         relname = hint->relnames[j];
2851
2852                         relid = find_relid_aliasname(root, relname, initial_rels,
2853                                                                                  hint->base.hint_str);
2854
2855                         if (relid == -1)
2856                                 hint->base.state = HINT_STATE_ERROR;
2857
2858                         if (relid <= 0)
2859                                 break;
2860
2861                         if (bms_is_member(relid, hint->joinrelids))
2862                         {
2863                                 hint_ereport(hint->base.hint_str,
2864                                                          ("Relation name \"%s\" is duplicated.", relname));
2865                                 hint->base.state = HINT_STATE_ERROR;
2866                                 break;
2867                         }
2868
2869                         hint->joinrelids = bms_add_member(hint->joinrelids, relid);
2870                 }
2871
2872                 if (relid <= 0 || hint->base.state == HINT_STATE_ERROR)
2873                         continue;
2874
2875                 hstate->join_hint_level[hint->nrels] =
2876                         lappend(hstate->join_hint_level[hint->nrels], hint);
2877         }
2878
2879         /* Do nothing if no Leading hint was supplied. */
2880         if (hstate->num_hints[HINT_TYPE_LEADING] == 0)
2881                 return false;
2882
2883         /*
2884          * Decide to use Leading hint。
2885          */
2886         for (i = 0; i < hstate->num_hints[HINT_TYPE_LEADING]; i++)
2887         {
2888                 LeadingHint        *leading_hint = (LeadingHint *)hstate->leading_hint[i];
2889                 Relids                  relids;
2890
2891                 if (leading_hint->base.state == HINT_STATE_ERROR)
2892                         continue;
2893
2894                 relid = 0;
2895                 relids = NULL;
2896
2897                 foreach(l, leading_hint->relations)
2898                 {
2899                         relname = (char *)lfirst(l);;
2900
2901                         relid = find_relid_aliasname(root, relname, initial_rels,
2902                                                                                  leading_hint->base.hint_str);
2903                         if (relid == -1)
2904                                 leading_hint->base.state = HINT_STATE_ERROR;
2905
2906                         if (relid <= 0)
2907                                 break;
2908
2909                         if (bms_is_member(relid, relids))
2910                         {
2911                                 hint_ereport(leading_hint->base.hint_str,
2912                                                          ("Relation name \"%s\" is duplicated.", relname));
2913                                 leading_hint->base.state = HINT_STATE_ERROR;
2914                                 break;
2915                         }
2916
2917                         relids = bms_add_member(relids, relid);
2918                 }
2919
2920                 if (relid <= 0 || leading_hint->base.state == HINT_STATE_ERROR)
2921                         continue;
2922
2923                 if (lhint != NULL)
2924                 {
2925                         hint_ereport(lhint->base.hint_str,
2926                                  ("Conflict %s hint.", HintTypeName[lhint->base.type]));
2927                         lhint->base.state = HINT_STATE_DUPLICATION;
2928                 }
2929                 leading_hint->base.state = HINT_STATE_USED;
2930                 lhint = leading_hint;
2931         }
2932
2933         /* check to exist Leading hint marked with 'used'. */
2934         if (lhint == NULL)
2935                 return false;
2936
2937         /*
2938          * We need join method hints which fit specified join order in every join
2939          * level.  For example, Leading(A B C) virtually requires following join
2940          * method hints, if no join method hint supplied:
2941          *   - level 1: none
2942          *   - level 2: NestLoop(A B), MergeJoin(A B), HashJoin(A B)
2943          *   - level 3: NestLoop(A B C), MergeJoin(A B C), HashJoin(A B C)
2944          *
2945          * If we already have join method hint which fits specified join order in
2946          * that join level, we leave it as-is and don't add new hints.
2947          */
2948         joinrelids = NULL;
2949         njoinrels = 0;
2950         if (lhint->outer_inner == NULL)
2951         {
2952                 foreach(l, lhint->relations)
2953                 {
2954                         JoinMethodHint *hint;
2955
2956                         relname = (char *)lfirst(l);
2957
2958                         /*
2959                          * Find relid of the relation which has given name.  If we have the
2960                          * name given in Leading hint multiple times in the join, nothing to
2961                          * do.
2962                          */
2963                         relid = find_relid_aliasname(root, relname, initial_rels,
2964                                                                                  hstate->hint_str);
2965
2966                         /* Create bitmap of relids for current join level. */
2967                         joinrelids = bms_add_member(joinrelids, relid);
2968                         njoinrels++;
2969
2970                         /* We never have join method hint for single relation. */
2971                         if (njoinrels < 2)
2972                                 continue;
2973
2974                         /*
2975                          * If we don't have join method hint, create new one for the
2976                          * join combination with all join methods are enabled.
2977                          */
2978                         hint = find_join_hint(joinrelids);
2979                         if (hint == NULL)
2980                         {
2981                                 /*
2982                                  * Here relnames is not set, since Relids bitmap is sufficient
2983                                  * to control paths of this query afterward.
2984                                  */
2985                                 hint = (JoinMethodHint *) JoinMethodHintCreate(
2986                                                                                         lhint->base.hint_str,
2987                                                                                         HINT_LEADING,
2988                                                                                         HINT_KEYWORD_LEADING);
2989                                 hint->base.state = HINT_STATE_USED;
2990                                 hint->nrels = njoinrels;
2991                                 hint->enforce_mask = ENABLE_ALL_JOIN;
2992                                 hint->joinrelids = bms_copy(joinrelids);
2993                         }
2994
2995                         join_method_hints[njoinrels] = hint;
2996
2997                         if (njoinrels >= nbaserel)
2998                                 break;
2999                 }
3000                 bms_free(joinrelids);
3001
3002                 if (njoinrels < 2)
3003                         return false;
3004
3005                 /*
3006                  * Delete all join hints which have different combination from Leading
3007                  * hint.
3008                  */
3009                 for (i = 2; i <= njoinrels; i++)
3010                 {
3011                         list_free(hstate->join_hint_level[i]);
3012
3013                         hstate->join_hint_level[i] = lappend(NIL, join_method_hints[i]);
3014                 }
3015         }
3016         else
3017         {
3018                 joinrelids = OuterInnerJoinCreate(lhint->outer_inner,
3019                                                                                   lhint,
3020                                           root,
3021                                           initial_rels,
3022                                                                                   hstate,
3023                                                                                   nbaserel);
3024
3025                 njoinrels = bms_num_members(joinrelids);
3026                 Assert(njoinrels >= 2);
3027
3028                 /*
3029                  * Delete all join hints which have different combination from Leading
3030                  * hint.
3031                  */
3032                 for (i = 2;i <= njoinrels; i++)
3033                 {
3034                         if (hstate->join_hint_level[i] != NIL)
3035                         {
3036                                 ListCell *prev = NULL;
3037                                 ListCell *next = NULL;
3038                                 for(l = list_head(hstate->join_hint_level[i]); l; l = next)
3039                                 {
3040
3041                                         JoinMethodHint *hint = (JoinMethodHint *)lfirst(l);
3042
3043                                         next = lnext(l);
3044
3045                                         if (hint->inner_nrels == 0 &&
3046                                                 !(bms_intersect(hint->joinrelids, joinrelids) == NULL ||
3047                                                   bms_equal(bms_union(hint->joinrelids, joinrelids),
3048                                                   hint->joinrelids)))
3049                                         {
3050                                                 hstate->join_hint_level[i] =
3051                                                         list_delete_cell(hstate->join_hint_level[i], l,
3052                                                                                          prev);
3053                                         }
3054                                         else
3055                                                 prev = l;
3056                                 }
3057                         }
3058                 }
3059
3060                 bms_free(joinrelids);
3061         }
3062
3063         if (hint_state_enabled(lhint))
3064         {
3065                 set_join_config_options(DISABLE_ALL_JOIN, current_hint->context);
3066                 return true;
3067         }
3068         return false;
3069 }
3070
3071 /*
3072  * set_plain_rel_pathlist
3073  *        Build access paths for a plain relation (no subquery, no inheritance)
3074  *
3075  * This function was copied and edited from set_plain_rel_pathlist() in
3076  * src/backend/optimizer/path/allpaths.c
3077  */
3078 static void
3079 set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
3080 {
3081         /* Consider sequential scan */
3082 #if PG_VERSION_NUM >= 90200
3083         add_path(rel, create_seqscan_path(root, rel, NULL));
3084 #else
3085         add_path(rel, create_seqscan_path(root, rel));
3086 #endif
3087
3088         /* Consider index scans */
3089         create_index_paths(root, rel);
3090
3091         /* Consider TID scans */
3092         create_tidscan_paths(root, rel);
3093
3094         /* Now find the cheapest of the paths for this rel */
3095         set_cheapest(rel);
3096 }
3097
3098 static void
3099 rebuild_scan_path(HintState *hstate, PlannerInfo *root, int level,
3100                                   List *initial_rels)
3101 {
3102         ListCell   *l;
3103
3104         foreach(l, initial_rels)
3105         {
3106                 RelOptInfo         *rel = (RelOptInfo *) lfirst(l);
3107                 RangeTblEntry  *rte;
3108                 ScanMethodHint *hint;
3109
3110                 /* Skip relations which we can't choose scan method. */
3111                 if (rel->reloptkind != RELOPT_BASEREL || rel->rtekind != RTE_RELATION)
3112                         continue;
3113
3114                 rte = root->simple_rte_array[rel->relid];
3115
3116                 /* We can't force scan method of foreign tables */
3117                 if (rte->relkind == RELKIND_FOREIGN_TABLE)
3118                         continue;
3119
3120                 /*
3121                  * Create scan paths with GUC parameters which are at the beginning of
3122                  * planner if scan method hint is not specified, otherwise use
3123                  * specified hints and mark the hint as used.
3124                  */
3125                 if ((hint = find_scan_hint(root, rel)) == NULL)
3126                         set_scan_config_options(hstate->init_scan_mask,
3127                                                                         hstate->context);
3128                 else
3129                 {
3130                         set_scan_config_options(hint->enforce_mask, hstate->context);
3131                         hint->base.state = HINT_STATE_USED;
3132                 }
3133
3134                 list_free_deep(rel->pathlist);
3135                 rel->pathlist = NIL;
3136                 if (rte->inh)
3137                 {
3138                         /* It's an "append relation", process accordingly */
3139                         set_append_rel_pathlist(root, rel, rel->relid, rte);
3140                 }
3141                 else
3142                 {
3143                         set_plain_rel_pathlist(root, rel, rte);
3144                 }
3145         }
3146
3147         /*
3148          * Restore the GUC variables we set above.
3149          */
3150         set_scan_config_options(hstate->init_scan_mask, hstate->context);
3151 }
3152
3153 /*
3154  * wrapper of make_join_rel()
3155  *
3156  * call make_join_rel() after changing enable_* parameters according to given
3157  * hints.
3158  */
3159 static RelOptInfo *
3160 make_join_rel_wrapper(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
3161 {
3162         Relids                  joinrelids;
3163         JoinMethodHint *hint;
3164         RelOptInfo         *rel;
3165         int                             save_nestlevel;
3166
3167         joinrelids = bms_union(rel1->relids, rel2->relids);
3168         hint = find_join_hint(joinrelids);
3169         bms_free(joinrelids);
3170
3171         if (!hint)
3172                 return pg_hint_plan_make_join_rel(root, rel1, rel2);
3173
3174         if (hint->inner_nrels == 0)
3175         {
3176                 save_nestlevel = NewGUCNestLevel();
3177
3178                 set_join_config_options(hint->enforce_mask, current_hint->context);
3179
3180                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
3181                 hint->base.state = HINT_STATE_USED;
3182
3183                 /*
3184                  * Restore the GUC variables we set above.
3185                  */
3186                 AtEOXact_GUC(true, save_nestlevel);
3187         }
3188         else
3189                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
3190
3191         return rel;
3192 }
3193
3194 /*
3195  * TODO : comment
3196  */
3197 static void
3198 add_paths_to_joinrel_wrapper(PlannerInfo *root,
3199                                                          RelOptInfo *joinrel,
3200                                                          RelOptInfo *outerrel,
3201                                                          RelOptInfo *innerrel,
3202                                                          JoinType jointype,
3203                                                          SpecialJoinInfo *sjinfo,
3204                                                          List *restrictlist)
3205 {
3206         ScanMethodHint *scan_hint = NULL;
3207         Relids                  joinrelids;
3208         JoinMethodHint *join_hint;
3209         int                             save_nestlevel;
3210
3211         if ((scan_hint = find_scan_hint(root, innerrel)) != NULL)
3212         {
3213                 set_scan_config_options(scan_hint->enforce_mask, current_hint->context);
3214                 scan_hint->base.state = HINT_STATE_USED;
3215         }
3216
3217         joinrelids = bms_union(outerrel->relids, innerrel->relids);
3218         join_hint = find_join_hint(joinrelids);
3219         bms_free(joinrelids);
3220
3221         if (join_hint && join_hint->inner_nrels != 0)
3222         {
3223                 save_nestlevel = NewGUCNestLevel();
3224
3225                 if (bms_equal(join_hint->inner_joinrelids, innerrel->relids))
3226                 {
3227
3228                         set_join_config_options(join_hint->enforce_mask,
3229                                                                         current_hint->context);
3230
3231                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3232                                                                  sjinfo, restrictlist);
3233                         join_hint->base.state = HINT_STATE_USED;
3234                 }
3235                 else
3236                 {
3237                         set_join_config_options(DISABLE_ALL_JOIN, current_hint->context);
3238                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3239                                                                  sjinfo, restrictlist);
3240                 }
3241
3242                 /*
3243                  * Restore the GUC variables we set above.
3244                  */
3245                 AtEOXact_GUC(true, save_nestlevel);
3246         }
3247         else
3248                 add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3249                                                          sjinfo, restrictlist);
3250
3251         if (scan_hint != NULL)
3252                 set_scan_config_options(current_hint->init_scan_mask,
3253                                                                 current_hint->context);
3254 }
3255
3256 static int
3257 get_num_baserels(List *initial_rels)
3258 {
3259         int                     nbaserel = 0;
3260         ListCell   *l;
3261
3262         foreach(l, initial_rels)
3263         {
3264                 RelOptInfo *rel = (RelOptInfo *) lfirst(l);
3265
3266                 if (rel->reloptkind == RELOPT_BASEREL)
3267                         nbaserel++;
3268                 else if (rel->reloptkind ==RELOPT_JOINREL)
3269                         nbaserel+= bms_num_members(rel->relids);
3270                 else
3271                 {
3272                         /* other values not expected here */
3273                         elog(ERROR, "unrecognized reloptkind type: %d", rel->reloptkind);
3274                 }
3275         }
3276
3277         return nbaserel;
3278 }
3279
3280 static RelOptInfo *
3281 pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
3282                                                  List *initial_rels)
3283 {
3284         JoinMethodHint    **join_method_hints;
3285         int                                     nbaserel;
3286         RelOptInfo                 *rel;
3287         int                                     i;
3288         bool                            leading_hint_enable;
3289
3290         /*
3291          * Use standard planner (or geqo planner) if pg_hint_plan is disabled or no
3292          * valid hint is supplied.
3293          */
3294         if (!current_hint)
3295         {
3296                 if (prev_join_search)
3297                         return (*prev_join_search) (root, levels_needed, initial_rels);
3298                 else if (enable_geqo && levels_needed >= geqo_threshold)
3299                         return geqo(root, levels_needed, initial_rels);
3300                 else
3301                         return standard_join_search(root, levels_needed, initial_rels);
3302         }
3303
3304         /* We apply scan method hint rebuild scan path. */
3305         rebuild_scan_path(current_hint, root, levels_needed, initial_rels);
3306
3307         /*
3308          * In the case using GEQO, only scan method hints and Set hints have
3309          * effect.  Join method and join order is not controllable by hints.
3310          */
3311         if (enable_geqo && levels_needed >= geqo_threshold)
3312                 return geqo(root, levels_needed, initial_rels);
3313
3314         nbaserel = get_num_baserels(initial_rels);
3315         current_hint->join_hint_level = palloc0(sizeof(List *) * (nbaserel + 1));
3316         join_method_hints = palloc0(sizeof(JoinMethodHint *) * (nbaserel + 1));
3317
3318         leading_hint_enable = transform_join_hints(current_hint, root, nbaserel,
3319                                                                                            initial_rels, join_method_hints);
3320
3321         rel = pg_hint_plan_standard_join_search(root, levels_needed, initial_rels);
3322
3323         for (i = 2; i <= nbaserel; i++)
3324         {
3325                 list_free(current_hint->join_hint_level[i]);
3326
3327                 /* free Leading hint only */
3328                 if (join_method_hints[i] != NULL &&
3329                         join_method_hints[i]->enforce_mask == ENABLE_ALL_JOIN)
3330                         JoinMethodHintDelete(join_method_hints[i]);
3331         }
3332         pfree(current_hint->join_hint_level);
3333         pfree(join_method_hints);
3334
3335         if (leading_hint_enable)
3336                 set_join_config_options(current_hint->init_join_mask,
3337                                                                 current_hint->context);
3338
3339         return rel;
3340 }
3341
3342 /*
3343  * set_rel_pathlist
3344  *        Build access paths for a base relation
3345  *
3346  * This function was copied and edited from set_rel_pathlist() in
3347  * src/backend/optimizer/path/allpaths.c
3348  */
3349 static void
3350 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
3351                                  Index rti, RangeTblEntry *rte)
3352 {
3353 #if PG_VERSION_NUM >= 90200
3354         if (IS_DUMMY_REL(rel))
3355         {
3356                 /* We already proved the relation empty, so nothing more to do */
3357         }
3358         else if (rte->inh)
3359 #else
3360         if (rte->inh)
3361 #endif
3362         {
3363                 /* It's an "append relation", process accordingly */
3364                 set_append_rel_pathlist(root, rel, rti, rte);
3365         }
3366         else
3367         {
3368                 if (rel->rtekind == RTE_RELATION)
3369                 {
3370                         if (rte->relkind == RELKIND_RELATION)
3371                         {
3372                                 /* Plain relation */
3373                                 set_plain_rel_pathlist(root, rel, rte);
3374                         }
3375                         else
3376                                 elog(ERROR, "unexpected relkind: %c", rte->relkind);
3377                 }
3378                 else
3379                         elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
3380         }
3381 }
3382
3383 #define standard_join_search pg_hint_plan_standard_join_search
3384 #define join_search_one_level pg_hint_plan_join_search_one_level
3385 #define make_join_rel make_join_rel_wrapper
3386 #include "core.c"
3387
3388 #undef make_join_rel
3389 #define make_join_rel pg_hint_plan_make_join_rel
3390 #define add_paths_to_joinrel add_paths_to_joinrel_wrapper
3391 #include "make_join_rel.c"