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 static HintState *
1327 parse_head_comment(Query *parse)
1328 {
1329         const char *p;
1330         const char *hint_head;
1331         char       *head;
1332         char       *tail;
1333         int                     len;
1334         int                     i;
1335         HintState   *hstate;
1336
1337         /* get client-supplied query string. */
1338         if (stmt_name)
1339         {
1340                 PreparedStatement  *entry;
1341
1342                 entry = FetchPreparedStatement(stmt_name, true);
1343                 p = entry->plansource->query_string;
1344         }
1345         else
1346                 p = debug_query_string;
1347
1348         if (p == NULL)
1349                 return NULL;
1350
1351         /* extract query head comment. */
1352         hint_head = strstr(p, HINT_START);
1353         if (hint_head == NULL)
1354                 return NULL;
1355         for (;p < hint_head; p++)
1356         {
1357                 /*
1358                  * Allow these characters precedes hint comment:
1359                  *   - digits
1360                  *   - alphabets which are in ASCII range
1361                  *   - space, tabs and new-lines
1362                  *   - underscores, for identifier
1363                  *   - commas, for SELECT clause, EXPLAIN and PREPARE
1364                  *   - parentheses, for EXPLAIN and PREPARE
1365                  *
1366                  * Note that we don't use isalpha() nor isalnum() in ctype.h here to
1367                  * avoid behavior which depends on locale setting.
1368                  */
1369                 if (!(*p >= '0' && *p <= '9') &&
1370                         !(*p >= 'A' && *p <= 'Z') &&
1371                         !(*p >= 'a' && *p <= 'z') &&
1372                         !isspace(*p) &&
1373                         *p != '_' &&
1374                         *p != ',' &&
1375                         *p != '(' && *p != ')')
1376                         return NULL;
1377         }
1378
1379         len = strlen(HINT_START);
1380         head = (char *) p;
1381         p += len;
1382         skip_space(p);
1383
1384         /* find hint end keyword. */
1385         if ((tail = strstr(p, HINT_END)) == NULL)
1386         {
1387                 hint_ereport(head, ("Unterminated block comment."));
1388                 return NULL;
1389         }
1390
1391         /* We don't support nested block comments. */
1392         if ((head = strstr(p, BLOCK_COMMENT_START)) != NULL && head < tail)
1393         {
1394                 hint_ereport(head, ("Nested block comments are not supported."));
1395                 return NULL;
1396         }
1397
1398         /* Make a copy of hint. */
1399         len = tail - p;
1400         head = palloc(len + 1);
1401         memcpy(head, p, len);
1402         head[len] = '\0';
1403         p = head;
1404
1405         hstate = HintStateCreate();
1406         hstate->hint_str = head;
1407
1408         /* parse each hint. */
1409         parse_hints(hstate, parse, p);
1410
1411         /* When nothing specified a hint, we free HintState and returns NULL. */
1412         if (hstate->nall_hints == 0)
1413         {
1414                 HintStateDelete(hstate);
1415                 return NULL;
1416         }
1417
1418         /* Sort hints in order of original position. */
1419         qsort(hstate->all_hints, hstate->nall_hints, sizeof(Hint *),
1420                   HintCmpWithPos);
1421
1422         /* Count number of hints per hint-type. */
1423         for (i = 0; i < hstate->nall_hints; i++)
1424         {
1425                 Hint   *cur_hint = hstate->all_hints[i];
1426                 hstate->num_hints[cur_hint->type]++;
1427         }
1428
1429         /*
1430          * If an object (or a set of objects) has multiple hints of same hint-type,
1431          * only the last hint is valid and others are igonred in planning.
1432          * Hints except the last are marked as 'duplicated' to remember the order.
1433          */
1434         for (i = 0; i < hstate->nall_hints - 1; i++)
1435         {
1436                 Hint   *cur_hint = hstate->all_hints[i];
1437                 Hint   *next_hint = hstate->all_hints[i + 1];
1438
1439                 /*
1440                  * Leading hint is marked as 'duplicated' in transform_join_hints.
1441                  */
1442                 if (cur_hint->type == HINT_TYPE_LEADING &&
1443                         next_hint->type == HINT_TYPE_LEADING)
1444                         continue;
1445
1446                 /*
1447                  * Note that we need to pass addresses of hint pointers, because
1448                  * HintCmp is designed to sort array of Hint* by qsort.
1449                  */
1450                 if (HintCmp(&cur_hint, &next_hint) == 0)
1451                 {
1452                         hint_ereport(cur_hint->hint_str,
1453                                                  ("Conflict %s hint.", HintTypeName[cur_hint->type]));
1454                         cur_hint->state = HINT_STATE_DUPLICATION;
1455                 }
1456         }
1457
1458         /*
1459          * Make sure that per-type array pointers point proper position in the
1460          * array which consists of all hints.
1461          */
1462         hstate->scan_hints = (ScanMethodHint **) hstate->all_hints;
1463         hstate->join_hints = (JoinMethodHint **) (hstate->scan_hints +
1464                 hstate->num_hints[HINT_TYPE_SCAN_METHOD]);
1465         hstate->leading_hint = (LeadingHint **) (hstate->join_hints +
1466                 hstate->num_hints[HINT_TYPE_JOIN_METHOD]);
1467         hstate->set_hints = (SetHint **) (hstate->leading_hint +
1468                 hstate->num_hints[HINT_TYPE_LEADING]);
1469
1470         return hstate;
1471 }
1472
1473 /*
1474  * Parse inside of parentheses of scan-method hints.
1475  */
1476 static const char *
1477 ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
1478                                         const char *str)
1479 {
1480         const char         *keyword = hint->base.keyword;
1481         HintKeyword             hint_keyword = hint->base.hint_keyword;
1482         List               *name_list = NIL;
1483         int                             length;
1484
1485         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
1486                 return NULL;
1487
1488         /* Parse relation name and index name(s) if given hint accepts. */
1489         length = list_length(name_list);
1490         if (length > 0)
1491         {
1492                 hint->relname = linitial(name_list);
1493                 hint->indexnames = list_delete_first(name_list);
1494
1495                 /* check whether the hint accepts index name(s). */
1496                 if (length != 1 &&
1497                         hint_keyword != HINT_KEYWORD_INDEXSCAN &&
1498                         hint_keyword != HINT_KEYWORD_INDEXSCANREGEXP &&
1499 #if PG_VERSION_NUM >= 90200
1500                         hint_keyword != HINT_KEYWORD_INDEXONLYSCAN &&
1501                         hint_keyword != HINT_KEYWORD_INDEXONLYSCANREGEXP &&
1502 #endif
1503                         hint_keyword != HINT_KEYWORD_BITMAPSCAN &&
1504                         hint_keyword != HINT_KEYWORD_BITMAPSCANREGEXP)
1505                 {
1506                         hint_ereport(str,
1507                                                  ("%s hint accepts only one relation.",
1508                                                   hint->base.keyword));
1509                         hint->base.state = HINT_STATE_ERROR;
1510                         return str;
1511                 }
1512         }
1513         else
1514         {
1515                 hint_ereport(str,
1516                                          ("%s hint requires a relation.",
1517                                           hint->base.keyword));
1518                 hint->base.state = HINT_STATE_ERROR;
1519                 return str;
1520         }
1521
1522         /* Set a bit for specified hint. */
1523         switch (hint_keyword)
1524         {
1525                 case HINT_KEYWORD_SEQSCAN:
1526                         hint->enforce_mask = ENABLE_SEQSCAN;
1527                         break;
1528                 case HINT_KEYWORD_INDEXSCAN:
1529                         hint->enforce_mask = ENABLE_INDEXSCAN;
1530                         break;
1531                 case HINT_KEYWORD_INDEXSCANREGEXP:
1532                         hint->enforce_mask = ENABLE_INDEXSCAN;
1533                         hint->regexp = true;
1534                         break;
1535                 case HINT_KEYWORD_BITMAPSCAN:
1536                         hint->enforce_mask = ENABLE_BITMAPSCAN;
1537                         break;
1538                 case HINT_KEYWORD_BITMAPSCANREGEXP:
1539                         hint->enforce_mask = ENABLE_BITMAPSCAN;
1540                         hint->regexp = true;
1541                         break;
1542                 case HINT_KEYWORD_TIDSCAN:
1543                         hint->enforce_mask = ENABLE_TIDSCAN;
1544                         break;
1545                 case HINT_KEYWORD_NOSEQSCAN:
1546                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_SEQSCAN;
1547                         break;
1548                 case HINT_KEYWORD_NOINDEXSCAN:
1549                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXSCAN;
1550                         break;
1551                 case HINT_KEYWORD_NOBITMAPSCAN:
1552                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_BITMAPSCAN;
1553                         break;
1554                 case HINT_KEYWORD_NOTIDSCAN:
1555                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_TIDSCAN;
1556                         break;
1557 #if PG_VERSION_NUM >= 90200
1558                 case HINT_KEYWORD_INDEXONLYSCAN:
1559                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
1560                         break;
1561                 case HINT_KEYWORD_INDEXONLYSCANREGEXP:
1562                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
1563                         hint->regexp = true;
1564                         break;
1565                 case HINT_KEYWORD_NOINDEXONLYSCAN:
1566                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXONLYSCAN;
1567                         break;
1568 #endif
1569                 default:
1570                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
1571                         return NULL;
1572                         break;
1573         }
1574
1575         return str;
1576 }
1577
1578 static const char *
1579 JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate, Query *parse,
1580                                         const char *str)
1581 {
1582         const char         *keyword = hint->base.keyword;
1583         HintKeyword             hint_keyword = hint->base.hint_keyword;
1584         List               *name_list = NIL;
1585
1586         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
1587                 return NULL;
1588
1589         hint->nrels = list_length(name_list);
1590
1591         if (hint->nrels > 0)
1592         {
1593                 ListCell   *l;
1594                 int                     i = 0;
1595
1596                 /*
1597                  * Transform relation names from list to array to sort them with qsort
1598                  * after.
1599                  */
1600                 hint->relnames = palloc(sizeof(char *) * hint->nrels);
1601                 foreach (l, name_list)
1602                 {
1603                         hint->relnames[i] = lfirst(l);
1604                         i++;
1605                 }
1606         }
1607
1608         list_free(name_list);
1609
1610         /* A join hint requires at least two relations */
1611         if (hint->nrels < 2)
1612         {
1613                 hint_ereport(str,
1614                                          ("%s hint requires at least two relations.",
1615                                           hint->base.keyword));
1616                 hint->base.state = HINT_STATE_ERROR;
1617                 return str;
1618         }
1619
1620         /* Sort hints in alphabetical order of relation names. */
1621         qsort(hint->relnames, hint->nrels, sizeof(char *), RelnameCmp);
1622
1623         switch (hint_keyword)
1624         {
1625                 case HINT_KEYWORD_NESTLOOP:
1626                         hint->enforce_mask = ENABLE_NESTLOOP;
1627                         break;
1628                 case HINT_KEYWORD_MERGEJOIN:
1629                         hint->enforce_mask = ENABLE_MERGEJOIN;
1630                         break;
1631                 case HINT_KEYWORD_HASHJOIN:
1632                         hint->enforce_mask = ENABLE_HASHJOIN;
1633                         break;
1634                 case HINT_KEYWORD_NONESTLOOP:
1635                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_NESTLOOP;
1636                         break;
1637                 case HINT_KEYWORD_NOMERGEJOIN:
1638                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_MERGEJOIN;
1639                         break;
1640                 case HINT_KEYWORD_NOHASHJOIN:
1641                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_HASHJOIN;
1642                         break;
1643                 default:
1644                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
1645                         return NULL;
1646                         break;
1647         }
1648
1649         return str;
1650 }
1651
1652 static bool
1653 OuterInnerPairCheck(OuterInnerRels *outer_inner)
1654 {
1655         ListCell *l;
1656         if (outer_inner->outer_inner_pair == NIL)
1657         {
1658                 if (outer_inner->relation)
1659                         return true;
1660                 else
1661                         return false;
1662         }
1663
1664         if (list_length(outer_inner->outer_inner_pair) == 2)
1665         {
1666                 foreach(l, outer_inner->outer_inner_pair)
1667                 {
1668                         if (!OuterInnerPairCheck(lfirst(l)))
1669                                 return false;
1670                 }
1671         }
1672         else
1673                 return false;
1674
1675         return true;
1676 }
1677
1678 static List *
1679 OuterInnerList(OuterInnerRels *outer_inner)
1680 {
1681         List               *outer_inner_list = NIL;
1682         ListCell           *l;
1683         OuterInnerRels *outer_inner_rels;
1684
1685         foreach(l, outer_inner->outer_inner_pair)
1686         {
1687                 outer_inner_rels = (OuterInnerRels *)(lfirst(l));
1688
1689                 if (outer_inner_rels->relation != NULL)
1690                         outer_inner_list = lappend(outer_inner_list,
1691                                                                            outer_inner_rels->relation);
1692                 else
1693                         outer_inner_list = list_concat(outer_inner_list,
1694                                                                                    OuterInnerList(outer_inner_rels));
1695         }
1696         return outer_inner_list;
1697 }
1698
1699 static const char *
1700 LeadingHintParse(LeadingHint *hint, HintState *hstate, Query *parse,
1701                                  const char *str)
1702 {
1703         List               *name_list = NIL;
1704         OuterInnerRels *outer_inner = NULL;
1705
1706         if ((str = parse_parentheses_Leading(str, &name_list, &outer_inner)) ==
1707                 NULL)
1708                 return NULL;
1709
1710         if (outer_inner != NULL)
1711                 name_list = OuterInnerList(outer_inner);
1712
1713         hint->relations = name_list;
1714         hint->outer_inner = outer_inner;
1715
1716         /* A Leading hint requires at least two relations */
1717         if ( hint->outer_inner == NULL && list_length(hint->relations) < 2)
1718         {
1719                 hint_ereport(hint->base.hint_str,
1720                                          ("%s hint requires at least two relations.",
1721                                           HINT_LEADING));
1722                 hint->base.state = HINT_STATE_ERROR;
1723         }
1724         else if (hint->outer_inner != NULL &&
1725                          !OuterInnerPairCheck(hint->outer_inner))
1726         {
1727                 hint_ereport(hint->base.hint_str,
1728                                          ("%s hint requires two sets of relations when parentheses nests.",
1729                                           HINT_LEADING));
1730                 hint->base.state = HINT_STATE_ERROR;
1731         }
1732
1733         return str;
1734 }
1735
1736 static const char *
1737 SetHintParse(SetHint *hint, HintState *hstate, Query *parse, const char *str)
1738 {
1739         List   *name_list = NIL;
1740
1741         if ((str = parse_parentheses(str, &name_list, hint->base.hint_keyword))
1742                 == NULL)
1743                 return NULL;
1744
1745         hint->words = name_list;
1746
1747         /* We need both name and value to set GUC parameter. */
1748         if (list_length(name_list) == 2)
1749         {
1750                 hint->name = linitial(name_list);
1751                 hint->value = lsecond(name_list);
1752         }
1753         else
1754         {
1755                 hint_ereport(hint->base.hint_str,
1756                                          ("%s hint requires name and value of GUC parameter.",
1757                                           HINT_SET));
1758                 hint->base.state = HINT_STATE_ERROR;
1759         }
1760
1761         return str;
1762 }
1763
1764 /*
1765  * set GUC parameter functions
1766  */
1767
1768 static int
1769 set_config_option_wrapper(const char *name, const char *value,
1770                                                   GucContext context, GucSource source,
1771                                                   GucAction action, bool changeVal, int elevel)
1772 {
1773         int                             result = 0;
1774         MemoryContext   ccxt = CurrentMemoryContext;
1775
1776         PG_TRY();
1777         {
1778 #if PG_VERSION_NUM >= 90200
1779                 result = set_config_option(name, value, context, source,
1780                                                                    action, changeVal, 0);
1781 #else
1782                 result = set_config_option(name, value, context, source,
1783                                                                    action, changeVal);
1784 #endif
1785         }
1786         PG_CATCH();
1787         {
1788                 ErrorData          *errdata;
1789
1790                 /* Save error info */
1791                 MemoryContextSwitchTo(ccxt);
1792                 errdata = CopyErrorData();
1793                 FlushErrorState();
1794
1795                 ereport(elevel, (errcode(errdata->sqlerrcode),
1796                                 errmsg("%s", errdata->message),
1797                                 errdata->detail ? errdetail("%s", errdata->detail) : 0,
1798                                 errdata->hint ? errhint("%s", errdata->hint) : 0));
1799                 FreeErrorData(errdata);
1800         }
1801         PG_END_TRY();
1802
1803         return result;
1804 }
1805
1806 static int
1807 set_config_options(SetHint **options, int noptions, GucContext context)
1808 {
1809         int     i;
1810         int     save_nestlevel;
1811
1812         save_nestlevel = NewGUCNestLevel();
1813
1814         for (i = 0; i < noptions; i++)
1815         {
1816                 SetHint    *hint = options[i];
1817                 int                     result;
1818
1819                 if (!hint_state_enabled(hint))
1820                         continue;
1821
1822                 result = set_config_option_wrapper(hint->name, hint->value, context,
1823                                                                                    PGC_S_SESSION, GUC_ACTION_SAVE, true,
1824                                                                                    pg_hint_plan_parse_messages);
1825                 if (result != 0)
1826                         hint->base.state = HINT_STATE_USED;
1827                 else
1828                         hint->base.state = HINT_STATE_ERROR;
1829         }
1830
1831         return save_nestlevel;
1832 }
1833
1834 #define SET_CONFIG_OPTION(name, type_bits) \
1835         set_config_option_wrapper((name), \
1836                 (mask & (type_bits)) ? "true" : "false", \
1837                 context, PGC_S_SESSION, GUC_ACTION_SAVE, true, ERROR)
1838
1839 static void
1840 set_scan_config_options(unsigned char enforce_mask, GucContext context)
1841 {
1842         unsigned char   mask;
1843
1844         if (enforce_mask == ENABLE_SEQSCAN || enforce_mask == ENABLE_INDEXSCAN ||
1845                 enforce_mask == ENABLE_BITMAPSCAN || enforce_mask == ENABLE_TIDSCAN
1846 #if PG_VERSION_NUM >= 90200
1847                 || enforce_mask == (ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN)
1848 #endif
1849                 )
1850                 mask = enforce_mask;
1851         else
1852                 mask = enforce_mask & current_hint->init_scan_mask;
1853
1854         SET_CONFIG_OPTION("enable_seqscan", ENABLE_SEQSCAN);
1855         SET_CONFIG_OPTION("enable_indexscan", ENABLE_INDEXSCAN);
1856         SET_CONFIG_OPTION("enable_bitmapscan", ENABLE_BITMAPSCAN);
1857         SET_CONFIG_OPTION("enable_tidscan", ENABLE_TIDSCAN);
1858 #if PG_VERSION_NUM >= 90200
1859         SET_CONFIG_OPTION("enable_indexonlyscan", ENABLE_INDEXONLYSCAN);
1860 #endif
1861 }
1862
1863 static void
1864 set_join_config_options(unsigned char enforce_mask, GucContext context)
1865 {
1866         unsigned char   mask;
1867
1868         if (enforce_mask == ENABLE_NESTLOOP || enforce_mask == ENABLE_MERGEJOIN ||
1869                 enforce_mask == ENABLE_HASHJOIN)
1870                 mask = enforce_mask;
1871         else
1872                 mask = enforce_mask & current_hint->init_join_mask;
1873
1874         SET_CONFIG_OPTION("enable_nestloop", ENABLE_NESTLOOP);
1875         SET_CONFIG_OPTION("enable_mergejoin", ENABLE_MERGEJOIN);
1876         SET_CONFIG_OPTION("enable_hashjoin", ENABLE_HASHJOIN);
1877 }
1878
1879 /*
1880  * pg_hint_plan hook functions
1881  */
1882
1883 static void
1884 pg_hint_plan_ProcessUtility(Node *parsetree, const char *queryString,
1885                                                         ParamListInfo params, bool isTopLevel,
1886                                                         DestReceiver *dest, char *completionTag)
1887 {
1888         Node                               *node;
1889
1890         if (!pg_hint_plan_enable_hint)
1891         {
1892                 if (prev_ProcessUtility)
1893                         (*prev_ProcessUtility) (parsetree, queryString, params,
1894                                                                         isTopLevel, dest, completionTag);
1895                 else
1896                         standard_ProcessUtility(parsetree, queryString, params,
1897                                                                         isTopLevel, dest, completionTag);
1898
1899                 return;
1900         }
1901
1902         node = parsetree;
1903         if (IsA(node, ExplainStmt))
1904         {
1905                 /*
1906                  * Draw out parse tree of actual query from Query struct of EXPLAIN
1907                  * statement.
1908                  */
1909                 ExplainStmt        *stmt;
1910                 Query              *query;
1911
1912                 stmt = (ExplainStmt *) node;
1913
1914                 Assert(IsA(stmt->query, Query));
1915                 query = (Query *) stmt->query;
1916
1917                 if (query->commandType == CMD_UTILITY && query->utilityStmt != NULL)
1918                         node = query->utilityStmt;
1919         }
1920
1921         /*
1922          * If the query was a EXECUTE or CREATE TABLE AS EXECUTE, get query string
1923          * specified to preceding PREPARE command to use it as source of hints.
1924          */
1925         if (IsA(node, ExecuteStmt))
1926         {
1927                 ExecuteStmt        *stmt;
1928
1929                 stmt = (ExecuteStmt *) node;
1930                 stmt_name = stmt->name;
1931         }
1932 #if PG_VERSION_NUM >= 90200
1933         /*
1934          * CREATE AS EXECUTE behavior has changed since 9.2, so we must handle it
1935          * specially here.
1936          */
1937         if (IsA(node, CreateTableAsStmt))
1938         {
1939                 CreateTableAsStmt          *stmt;
1940                 Query              *query;
1941
1942                 stmt = (CreateTableAsStmt *) node;
1943                 Assert(IsA(stmt->query, Query));
1944                 query = (Query *) stmt->query;
1945
1946                 if (query->commandType == CMD_UTILITY &&
1947                         IsA(query->utilityStmt, ExecuteStmt))
1948                 {
1949                         ExecuteStmt *estmt = (ExecuteStmt *) query->utilityStmt;
1950                         stmt_name = estmt->name;
1951                 }
1952         }
1953 #endif
1954         if (stmt_name)
1955         {
1956                 PG_TRY();
1957                 {
1958                         if (prev_ProcessUtility)
1959                                 (*prev_ProcessUtility) (parsetree, queryString, params,
1960                                                                                 isTopLevel, dest, completionTag);
1961                         else
1962                                 standard_ProcessUtility(parsetree, queryString, params,
1963                                                                                 isTopLevel, dest, completionTag);
1964                 }
1965                 PG_CATCH();
1966                 {
1967                         stmt_name = NULL;
1968                         PG_RE_THROW();
1969                 }
1970                 PG_END_TRY();
1971
1972                 stmt_name = NULL;
1973
1974                 return;
1975         }
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
1985 /*
1986  * Push a hint into hint stack which is implemented with List struct.  Head of
1987  * list is top of stack.
1988  */
1989 static void
1990 push_hint(HintState *hstate)
1991 {
1992         /* Prepend new hint to the list means pushing to stack. */
1993         HintStateStack = lcons(hstate, HintStateStack);
1994
1995         /* Pushed hint is the one which should be used hereafter. */
1996         current_hint = hstate;
1997 }
1998
1999 /* Pop a hint from hint stack.  Popped hint is automatically discarded. */
2000 static void
2001 pop_hint(void)
2002 {
2003         /* Hint stack must not be empty. */
2004         if(HintStateStack == NIL)
2005                 elog(ERROR, "hint stack is empty");
2006
2007         /*
2008          * Take a hint at the head from the list, and free it.  Switch current_hint
2009          * to point new head (NULL if the list is empty).
2010          */
2011         HintStateStack = list_delete_first(HintStateStack);
2012         HintStateDelete(current_hint);
2013         if(HintStateStack == NIL)
2014                 current_hint = NULL;
2015         else
2016                 current_hint = (HintState *) lfirst(list_head(HintStateStack));
2017 }
2018
2019 static PlannedStmt *
2020 pg_hint_plan_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
2021 {
2022         int                             save_nestlevel;
2023         PlannedStmt        *result;
2024         HintState          *hstate;
2025
2026         /*
2027          * Use standard planner if pg_hint_plan is disabled.  Other hook functions
2028          * try to change plan with current_hint if any, so set it to NULL.
2029          */
2030         if (!pg_hint_plan_enable_hint)
2031         {
2032                 current_hint = NULL;
2033
2034                 if (prev_planner)
2035                         return (*prev_planner) (parse, cursorOptions, boundParams);
2036                 else
2037                         return standard_planner(parse, cursorOptions, boundParams);
2038         }
2039
2040         /* Create hint struct from parse tree. */
2041         hstate = parse_head_comment(parse);
2042
2043         /*
2044          * Use standard planner if the statement has not valid hint.  Other hook
2045          * functions try to change plan with current_hint if any, so set it to
2046          * NULL.
2047          */
2048         if (!hstate)
2049         {
2050                 current_hint = NULL;
2051
2052                 if (prev_planner)
2053                         return (*prev_planner) (parse, cursorOptions, boundParams);
2054                 else
2055                         return standard_planner(parse, cursorOptions, boundParams);
2056         }
2057
2058         /*
2059          * Push new hint struct to the hint stack to disable previous hint context.
2060          */
2061         push_hint(hstate);
2062
2063         /* Set GUC parameters which are specified with Set hint. */
2064         save_nestlevel = set_config_options(current_hint->set_hints,
2065                                                                                 current_hint->num_hints[HINT_TYPE_SET],
2066                                                                                 current_hint->context);
2067
2068         if (enable_seqscan)
2069                 current_hint->init_scan_mask |= ENABLE_SEQSCAN;
2070         if (enable_indexscan)
2071                 current_hint->init_scan_mask |= ENABLE_INDEXSCAN;
2072         if (enable_bitmapscan)
2073                 current_hint->init_scan_mask |= ENABLE_BITMAPSCAN;
2074         if (enable_tidscan)
2075                 current_hint->init_scan_mask |= ENABLE_TIDSCAN;
2076 #if PG_VERSION_NUM >= 90200
2077         if (enable_indexonlyscan)
2078                 current_hint->init_scan_mask |= ENABLE_INDEXONLYSCAN;
2079 #endif
2080         if (enable_nestloop)
2081                 current_hint->init_join_mask |= ENABLE_NESTLOOP;
2082         if (enable_mergejoin)
2083                 current_hint->init_join_mask |= ENABLE_MERGEJOIN;
2084         if (enable_hashjoin)
2085                 current_hint->init_join_mask |= ENABLE_HASHJOIN;
2086
2087         /*
2088          * Use PG_TRY mechanism to recover GUC parameters and current_hint to the
2089          * state when this planner started when error occurred in planner.
2090          */
2091         PG_TRY();
2092         {
2093                 if (prev_planner)
2094                         result = (*prev_planner) (parse, cursorOptions, boundParams);
2095                 else
2096                         result = standard_planner(parse, cursorOptions, boundParams);
2097         }
2098         PG_CATCH();
2099         {
2100                 /*
2101                  * Rollback changes of GUC parameters, and pop current hint context
2102                  * from hint stack to rewind the state.
2103                  */
2104                 AtEOXact_GUC(true, save_nestlevel);
2105                 pop_hint();
2106                 PG_RE_THROW();
2107         }
2108         PG_END_TRY();
2109
2110         /* Print hint in debug mode. */
2111         if (pg_hint_plan_debug_print)
2112                 HintStateDump(current_hint);
2113
2114         /*
2115          * Rollback changes of GUC parameters, and pop current hint context from
2116          * hint stack to rewind the state.
2117          */
2118         AtEOXact_GUC(true, save_nestlevel);
2119         pop_hint();
2120
2121         return result;
2122 }
2123
2124 /*
2125  * Return scan method hint which matches given aliasname.
2126  */
2127 static ScanMethodHint *
2128 find_scan_hint(PlannerInfo *root, RelOptInfo *rel)
2129 {
2130         RangeTblEntry  *rte;
2131         int                             i;
2132
2133         /*
2134          * We can't apply scan method hint if the relation is:
2135          *   - not a base relation
2136          *   - not an ordinary relation (such as join and subquery)
2137          */
2138         if (rel->reloptkind != RELOPT_BASEREL || rel->rtekind != RTE_RELATION)
2139                 return NULL;
2140
2141         rte = root->simple_rte_array[rel->relid];
2142
2143         /* We can't force scan method of foreign tables */
2144         if (rte->relkind == RELKIND_FOREIGN_TABLE)
2145                 return NULL;
2146
2147         /* Find scan method hint, which matches given names, from the list. */
2148         for (i = 0; i < current_hint->num_hints[HINT_TYPE_SCAN_METHOD]; i++)
2149         {
2150                 ScanMethodHint *hint = current_hint->scan_hints[i];
2151
2152                 /* We ignore disabled hints. */
2153                 if (!hint_state_enabled(hint))
2154                         continue;
2155
2156                 if (RelnameCmp(&rte->eref->aliasname, &hint->relname) == 0)
2157                         return hint;
2158         }
2159
2160         return NULL;
2161 }
2162
2163 /*
2164  * regexeq
2165  *
2166  * Returns TRUE on match, FALSE on no match.
2167  *
2168  *   s1 --- the data to match against
2169  *   s2 --- the pattern
2170  *
2171  * Because we copy s1 to NameData, make the size of s1 less than NAMEDATALEN.
2172  */
2173 static bool
2174 regexpeq(const char *s1, const char *s2)
2175 {
2176         NameData        name;
2177         text       *regexp;
2178         Datum           result;
2179
2180         strcpy(name.data, s1);
2181         regexp = cstring_to_text(s2);
2182
2183         result = DirectFunctionCall2Coll(nameregexeq,
2184                                                                          DEFAULT_COLLATION_OID,
2185                                                                          NameGetDatum(&name),
2186                                                                          PointerGetDatum(regexp));
2187         return DatumGetBool(result);
2188 }
2189
2190 static void
2191 delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
2192 {
2193         ListCell           *cell;
2194         ListCell           *prev;
2195         ListCell           *next;
2196         StringInfoData  buf;
2197
2198         /*
2199          * We delete all the IndexOptInfo list and prevent you from being usable by
2200          * a scan.
2201          */
2202         if (hint->enforce_mask == ENABLE_SEQSCAN ||
2203                 hint->enforce_mask == ENABLE_TIDSCAN)
2204         {
2205                 list_free_deep(rel->indexlist);
2206                 rel->indexlist = NIL;
2207                 hint->base.state = HINT_STATE_USED;
2208
2209                 return;
2210         }
2211
2212         /*
2213          * When a list of indexes is not specified, we just use all indexes.
2214          */
2215         if (hint->indexnames == NIL)
2216                 return;
2217
2218         /*
2219          * Leaving only an specified index, we delete it from a IndexOptInfo list
2220          * other than it.
2221          */
2222         prev = NULL;
2223         if (pg_hint_plan_debug_print)
2224                 initStringInfo(&buf);
2225
2226         for (cell = list_head(rel->indexlist); cell; cell = next)
2227         {
2228                 IndexOptInfo   *info = (IndexOptInfo *) lfirst(cell);
2229                 char               *indexname = get_rel_name(info->indexoid);
2230                 ListCell           *l;
2231                 bool                    use_index = false;
2232
2233                 next = lnext(cell);
2234
2235                 foreach(l, hint->indexnames)
2236                 {
2237                         char   *hintname = (char *) lfirst(l);
2238                         bool    result;
2239
2240                         if (hint->regexp)
2241                                 result = regexpeq(indexname, hintname);
2242                         else
2243                                 result = RelnameCmp(&indexname, &hintname) == 0;
2244
2245                         if (result)
2246                         {
2247                                 use_index = true;
2248                                 if (pg_hint_plan_debug_print)
2249                                 {
2250                                         appendStringInfoCharMacro(&buf, ' ');
2251                                         quote_value(&buf, indexname);
2252                                 }
2253
2254                                 break;
2255                         }
2256                 }
2257
2258                 /*
2259                  * to make the index a candidate when definition of this index is
2260                  * matched with the index's definition of current_hint.
2261                  */
2262                 if (OidIsValid(relationObjectId) && !use_index)
2263                 {
2264                         foreach(l, current_hint->parent_index_infos)
2265                         {
2266                                 int                                     i;
2267                                 HeapTuple                       ht_idx;
2268                                 ParentIndexInfo    *p_info = (ParentIndexInfo *)lfirst(l);
2269
2270                                 /* check to match the parameter of unique */
2271                                 if (p_info->indisunique != info->unique)
2272                                         continue;
2273
2274                                 /* check to match the parameter of index's method */
2275                                 if (p_info->method != info->relam)
2276                                         continue;
2277
2278                                 /* to check to match the indexkey's configuration */
2279                                 if ((list_length(p_info->column_names)) !=
2280                                          info->ncolumns)
2281                                         continue;
2282
2283                                 /* check to match the indexkey's configuration */
2284                                 for (i = 0; i < info->ncolumns; i++)
2285                                 {
2286                                         char       *c_attname = NULL;
2287                                         char       *p_attname = NULL;
2288
2289                                         p_attname =
2290                                                 list_nth(p_info->column_names, i);
2291
2292                                         /* both are expressions */
2293                                         if (info->indexkeys[i] == 0 && !p_attname)
2294                                                 continue;
2295
2296                                         /* one's column is expression, the other is not */
2297                                         if (info->indexkeys[i] == 0 || !p_attname)
2298                                                 break;
2299
2300                                         c_attname = get_attname(relationObjectId,
2301                                                                                                 info->indexkeys[i]);
2302
2303                                         if (strcmp(p_attname, c_attname) != 0)
2304                                                 break;
2305
2306                                         if (p_info->indcollation[i] != info->indexcollations[i])
2307                                                 break;
2308
2309                                         if (p_info->opclass[i] != info->opcintype[i])
2310                                                 break;
2311
2312                                         if (((p_info->indoption[i] & INDOPTION_DESC) != 0) !=
2313                                                 info->reverse_sort[i])
2314                                                 break;
2315
2316                                         if (((p_info->indoption[i] & INDOPTION_NULLS_FIRST) != 0) !=
2317                                                 info->nulls_first[i])
2318                                                 break;
2319
2320                                 }
2321
2322                                 if (i != info->ncolumns)
2323                                         continue;
2324
2325                                 if ((p_info->expression_str && (info->indexprs != NIL)) ||
2326                                         (p_info->indpred_str && (info->indpred != NIL)))
2327                                 {
2328                                         /*
2329                                          * Fetch the pg_index tuple by the Oid of the index
2330                                          */
2331                                         ht_idx = SearchSysCache1(INDEXRELID,
2332                                                                                          ObjectIdGetDatum(info->indexoid));
2333
2334                                         /* check to match the expression's parameter of index */
2335                                         if (p_info->expression_str &&
2336                                                 !heap_attisnull(ht_idx, Anum_pg_index_indexprs))
2337                                         {
2338                                                 Datum       exprsDatum;
2339                                                 bool        isnull;
2340                                                 Datum       result;
2341
2342                                                 /*
2343                                                  * to change the expression's parameter of child's
2344                                                  * index to strings
2345                                                  */
2346                                                 exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
2347                                                                                                          Anum_pg_index_indexprs,
2348                                                                                                          &isnull);
2349
2350                                                 result = DirectFunctionCall2(pg_get_expr,
2351                                                                                                          exprsDatum,
2352                                                                                                          ObjectIdGetDatum(
2353                                                                                                                  relationObjectId));
2354
2355                                                 if (strcmp(p_info->expression_str,
2356                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
2357                                                 {
2358                                                         /* Clean up */
2359                                                         ReleaseSysCache(ht_idx);
2360
2361                                                         continue;
2362                                                 }
2363                                         }
2364
2365                                         /* Check to match the predicate's paraameter of index */
2366                                         if (p_info->indpred_str &&
2367                                                 !heap_attisnull(ht_idx, Anum_pg_index_indpred))
2368                                         {
2369                                                 Datum       predDatum;
2370                                                 bool        isnull;
2371                                                 Datum       result;
2372
2373                                                 /*
2374                                                  * to change the predicate's parabeter of child's
2375                                                  * index to strings
2376                                                  */
2377                                                 predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
2378                                                                                                          Anum_pg_index_indpred,
2379                                                                                                          &isnull);
2380
2381                                                 result = DirectFunctionCall2(pg_get_expr,
2382                                                                                                          predDatum,
2383                                                                                                          ObjectIdGetDatum(
2384                                                                                                                  relationObjectId));
2385
2386                                                 if (strcmp(p_info->indpred_str,
2387                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
2388                                                 {
2389                                                         /* Clean up */
2390                                                         ReleaseSysCache(ht_idx);
2391
2392                                                         continue;
2393                                                 }
2394                                         }
2395
2396                                         /* Clean up */
2397                                         ReleaseSysCache(ht_idx);
2398                                 }
2399                                 else if (p_info->expression_str || (info->indexprs != NIL))
2400                                         continue;
2401                                 else if (p_info->indpred_str || (info->indpred != NIL))
2402                                         continue;
2403
2404                                 use_index = true;
2405
2406                                 /* to log the candidate of index */
2407                                 if (pg_hint_plan_debug_print)
2408                                 {
2409                                         appendStringInfoCharMacro(&buf, ' ');
2410                                         quote_value(&buf, indexname);
2411                                 }
2412
2413                                 break;
2414                         }
2415                 }
2416
2417                 if (!use_index)
2418                         rel->indexlist = list_delete_cell(rel->indexlist, cell, prev);
2419                 else
2420                         prev = cell;
2421
2422                 pfree(indexname);
2423         }
2424
2425         if (pg_hint_plan_debug_print)
2426         {
2427                 char   *relname;
2428                 StringInfoData  rel_buf;
2429
2430                 if (OidIsValid(relationObjectId))
2431                         relname = get_rel_name(relationObjectId);
2432                 else
2433                         relname = hint->relname;
2434
2435                 initStringInfo(&rel_buf);
2436                 quote_value(&rel_buf, relname);
2437
2438                 ereport(LOG,
2439                                 (errmsg("available indexes for %s(%s):%s",
2440                                          hint->base.keyword,
2441                                          rel_buf.data,
2442                                          buf.data)));
2443                 pfree(buf.data);
2444                 pfree(rel_buf.data);
2445         }
2446 }
2447
2448 /*
2449  * Return information of index definition.
2450  */
2451 static ParentIndexInfo *
2452 get_parent_index_info(Oid indexoid, Oid relid)
2453 {
2454         ParentIndexInfo *p_info = palloc(sizeof(ParentIndexInfo));
2455         Relation            indexRelation;
2456         Form_pg_index   index;
2457         char               *attname;
2458         int                             i;
2459
2460         indexRelation = index_open(indexoid, RowExclusiveLock);
2461
2462         index = indexRelation->rd_index;
2463
2464         p_info->indisunique = index->indisunique;
2465         p_info->method = indexRelation->rd_rel->relam;
2466
2467         p_info->column_names = NIL;
2468         p_info->indcollation = (Oid *) palloc(sizeof(Oid) * index->indnatts);
2469         p_info->opclass = (Oid *) palloc(sizeof(Oid) * index->indnatts);
2470         p_info->indoption = (int16 *) palloc(sizeof(Oid) * index->indnatts);
2471
2472         for (i = 0; i < index->indnatts; i++)
2473         {
2474                 attname = get_attname(relid, index->indkey.values[i]);
2475                 p_info->column_names = lappend(p_info->column_names, attname);
2476
2477                 p_info->indcollation[i] = indexRelation->rd_indcollation[i];
2478                 p_info->opclass[i] = indexRelation->rd_opcintype[i];
2479                 p_info->indoption[i] = indexRelation->rd_indoption[i];
2480         }
2481
2482         /*
2483          * to check to match the expression's paraameter of index with child indexes
2484          */
2485         p_info->expression_str = NULL;
2486         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indexprs))
2487         {
2488                 Datum       exprsDatum;
2489                 bool            isnull;
2490                 Datum           result;
2491
2492                 exprsDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
2493                                                                          Anum_pg_index_indexprs, &isnull);
2494
2495                 result = DirectFunctionCall2(pg_get_expr,
2496                                                                          exprsDatum,
2497                                                                          ObjectIdGetDatum(relid));
2498
2499                 p_info->expression_str = text_to_cstring(DatumGetTextP(result));
2500         }
2501
2502         /*
2503          * to check to match the predicate's paraameter of index with child indexes
2504          */
2505         p_info->indpred_str = NULL;
2506         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indpred))
2507         {
2508                 Datum       predDatum;
2509                 bool            isnull;
2510                 Datum           result;
2511
2512                 predDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
2513                                                                          Anum_pg_index_indpred, &isnull);
2514
2515                 result = DirectFunctionCall2(pg_get_expr,
2516                                                                          predDatum,
2517                                                                          ObjectIdGetDatum(relid));
2518
2519                 p_info->indpred_str = text_to_cstring(DatumGetTextP(result));
2520         }
2521
2522         index_close(indexRelation, NoLock);
2523
2524         return p_info;
2525 }
2526
2527 static void
2528 pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
2529                                                            bool inhparent, RelOptInfo *rel)
2530 {
2531         ScanMethodHint *hint;
2532
2533         if (prev_get_relation_info)
2534                 (*prev_get_relation_info) (root, relationObjectId, inhparent, rel);
2535
2536         /* Do nothing if we don't have valid hint in this context. */
2537         if (!current_hint)
2538                 return;
2539
2540         if (inhparent)
2541         {
2542                 /* store does relids of parent table. */
2543                 current_hint->parent_relid = rel->relid;
2544                 current_hint->parent_rel_oid = relationObjectId;
2545         }
2546         else if (current_hint->parent_relid != 0)
2547         {
2548                 /*
2549                  * We use the same GUC parameter if this table is the child table of a
2550                  * table called pg_hint_plan_get_relation_info just before that.
2551                  */
2552                 ListCell   *l;
2553
2554                 /* append_rel_list contains all append rels; ignore others */
2555                 foreach(l, root->append_rel_list)
2556                 {
2557                         AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
2558
2559                         /* This rel is child table. */
2560                         if (appinfo->parent_relid == current_hint->parent_relid &&
2561                                 appinfo->child_relid == rel->relid)
2562                         {
2563                                 if (current_hint->parent_hint)
2564                                         delete_indexes(current_hint->parent_hint, rel,
2565                                                                    relationObjectId);
2566
2567                                 return;
2568                         }
2569                 }
2570
2571                 /* This rel is not inherit table. */
2572                 current_hint->parent_relid = 0;
2573                 current_hint->parent_rel_oid = InvalidOid;
2574                 current_hint->parent_hint = NULL;
2575         }
2576
2577         /*
2578          * If scan method hint was given, reset GUC parameters which control
2579          * planner behavior about choosing scan methods.
2580          */
2581         if ((hint = find_scan_hint(root, rel)) == NULL)
2582         {
2583                 set_scan_config_options(current_hint->init_scan_mask,
2584                                                                 current_hint->context);
2585                 return;
2586         }
2587         set_scan_config_options(hint->enforce_mask, current_hint->context);
2588         hint->base.state = HINT_STATE_USED;
2589
2590         if (inhparent)
2591         {
2592                 Relation    relation;
2593                 List       *indexoidlist;
2594                 ListCell   *l;
2595
2596                 current_hint->parent_hint = hint;
2597
2598                 relation = heap_open(relationObjectId, NoLock);
2599                 indexoidlist = RelationGetIndexList(relation);
2600
2601                 foreach(l, indexoidlist)
2602                 {
2603                         Oid         indexoid = lfirst_oid(l);
2604                         char       *indexname = get_rel_name(indexoid);
2605                         bool        use_index = false;
2606                         ListCell   *lc;
2607                         ParentIndexInfo *parent_index_info;
2608
2609                         foreach(lc, hint->indexnames)
2610                         {
2611                                 if (RelnameCmp(&indexname, &lfirst(lc)) == 0)
2612                                 {
2613                                         use_index = true;
2614                                         break;
2615                                 }
2616                         }
2617                         if (!use_index)
2618                                 continue;
2619
2620                         parent_index_info = get_parent_index_info(indexoid,
2621                                                                                                           relationObjectId);
2622                         current_hint->parent_index_infos =
2623                                 lappend(current_hint->parent_index_infos, parent_index_info);
2624                 }
2625                 heap_close(relation, NoLock);
2626         }
2627         else
2628                 delete_indexes(hint, rel, InvalidOid);
2629 }
2630
2631 /*
2632  * Return index of relation which matches given aliasname, or 0 if not found.
2633  * If same aliasname was used multiple times in a query, return -1.
2634  */
2635 static int
2636 find_relid_aliasname(PlannerInfo *root, char *aliasname, List *initial_rels,
2637                                          const char *str)
2638 {
2639         int             i;
2640         Index   found = 0;
2641
2642         for (i = 1; i < root->simple_rel_array_size; i++)
2643         {
2644                 ListCell   *l;
2645
2646                 if (root->simple_rel_array[i] == NULL)
2647                         continue;
2648
2649                 Assert(i == root->simple_rel_array[i]->relid);
2650
2651                 if (RelnameCmp(&aliasname,
2652                                            &root->simple_rte_array[i]->eref->aliasname) != 0)
2653                         continue;
2654
2655                 foreach(l, initial_rels)
2656                 {
2657                         RelOptInfo *rel = (RelOptInfo *) lfirst(l);
2658
2659                         if (rel->reloptkind == RELOPT_BASEREL)
2660                         {
2661                                 if (rel->relid != i)
2662                                         continue;
2663                         }
2664                         else
2665                         {
2666                                 Assert(rel->reloptkind == RELOPT_JOINREL);
2667
2668                                 if (!bms_is_member(i, rel->relids))
2669                                         continue;
2670                         }
2671
2672                         if (found != 0)
2673                         {
2674                                 hint_ereport(str,
2675                                                          ("Relation name \"%s\" is ambiguous.",
2676                                                           aliasname));
2677                                 return -1;
2678                         }
2679
2680                         found = i;
2681                         break;
2682                 }
2683
2684         }
2685
2686         return found;
2687 }
2688
2689 /*
2690  * Return join hint which matches given joinrelids.
2691  */
2692 static JoinMethodHint *
2693 find_join_hint(Relids joinrelids)
2694 {
2695         List       *join_hint;
2696         ListCell   *l;
2697
2698         join_hint = current_hint->join_hint_level[bms_num_members(joinrelids)];
2699
2700         foreach(l, join_hint)
2701         {
2702                 JoinMethodHint *hint = (JoinMethodHint *) lfirst(l);
2703
2704                 if (bms_equal(joinrelids, hint->joinrelids))
2705                         return hint;
2706         }
2707
2708         return NULL;
2709 }
2710
2711 static Relids
2712 OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
2713         PlannerInfo *root, List *initial_rels, HintState *hstate, int nbaserel)
2714 {
2715         OuterInnerRels *outer_rels;
2716         OuterInnerRels *inner_rels;
2717         Relids                  outer_relids;
2718         Relids                  inner_relids;
2719         Relids                  join_relids;
2720         JoinMethodHint *hint;
2721
2722         if (outer_inner->relation != NULL)
2723         {
2724                 return bms_make_singleton(
2725                                         find_relid_aliasname(root, outer_inner->relation,
2726                                                                                  initial_rels,
2727                                                                                  leading_hint->base.hint_str));
2728         }
2729
2730         outer_rels = lfirst(outer_inner->outer_inner_pair->head);
2731         inner_rels = lfirst(outer_inner->outer_inner_pair->tail);
2732
2733         outer_relids = OuterInnerJoinCreate(outer_rels,
2734                                                                                 leading_hint,
2735                                                                                 root,
2736                                                                                 initial_rels,
2737                                                                                 hstate,
2738                                                                                 nbaserel);
2739         inner_relids = OuterInnerJoinCreate(inner_rels,
2740                                                                                 leading_hint,
2741                                                                                 root,
2742                                                                                 initial_rels,
2743                                                                                 hstate,
2744                                                                                 nbaserel);
2745
2746         join_relids = bms_add_members(outer_relids, inner_relids);
2747
2748         if (bms_num_members(join_relids) > nbaserel)
2749                 return join_relids;
2750
2751         /*
2752          * If we don't have join method hint, create new one for the
2753          * join combination with all join methods are enabled.
2754          */
2755         hint = find_join_hint(join_relids);
2756         if (hint == NULL)
2757         {
2758                 /*
2759                  * Here relnames is not set, since Relids bitmap is sufficient to
2760                  * control paths of this query afterward.
2761                  */
2762                 hint = (JoinMethodHint *) JoinMethodHintCreate(
2763                                         leading_hint->base.hint_str,
2764                                         HINT_LEADING,
2765                                         HINT_KEYWORD_LEADING);
2766                 hint->base.state = HINT_STATE_USED;
2767                 hint->nrels = bms_num_members(join_relids);
2768                 hint->enforce_mask = ENABLE_ALL_JOIN;
2769                 hint->joinrelids = bms_copy(join_relids);
2770                 hint->inner_nrels = bms_num_members(inner_relids);
2771                 hint->inner_joinrelids = bms_copy(inner_relids);
2772
2773                 hstate->join_hint_level[hint->nrels] =
2774                         lappend(hstate->join_hint_level[hint->nrels], hint);
2775         }
2776         else
2777         {
2778                 hint->inner_nrels = bms_num_members(inner_relids);
2779                 hint->inner_joinrelids = bms_copy(inner_relids);
2780         }
2781
2782         return join_relids;
2783 }
2784
2785 /*
2786  * Transform join method hint into handy form.
2787  *
2788  *   - create bitmap of relids from alias names, to make it easier to check
2789  *     whether a join path matches a join method hint.
2790  *   - add join method hints which are necessary to enforce join order
2791  *     specified by Leading hint
2792  */
2793 static bool
2794 transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
2795                 List *initial_rels, JoinMethodHint **join_method_hints)
2796 {
2797         int                             i;
2798         int                             relid;
2799         Relids                  joinrelids;
2800         int                             njoinrels;
2801         ListCell           *l;
2802         char               *relname;
2803         LeadingHint        *lhint = NULL;
2804
2805         /*
2806          * Create bitmap of relids from alias names for each join method hint.
2807          * Bitmaps are more handy than strings in join searching.
2808          */
2809         for (i = 0; i < hstate->num_hints[HINT_TYPE_JOIN_METHOD]; i++)
2810         {
2811                 JoinMethodHint *hint = hstate->join_hints[i];
2812                 int     j;
2813
2814                 if (!hint_state_enabled(hint) || hint->nrels > nbaserel)
2815                         continue;
2816
2817                 bms_free(hint->joinrelids);
2818                 hint->joinrelids = NULL;
2819                 relid = 0;
2820                 for (j = 0; j < hint->nrels; j++)
2821                 {
2822                         relname = hint->relnames[j];
2823
2824                         relid = find_relid_aliasname(root, relname, initial_rels,
2825                                                                                  hint->base.hint_str);
2826
2827                         if (relid == -1)
2828                                 hint->base.state = HINT_STATE_ERROR;
2829
2830                         if (relid <= 0)
2831                                 break;
2832
2833                         if (bms_is_member(relid, hint->joinrelids))
2834                         {
2835                                 hint_ereport(hint->base.hint_str,
2836                                                          ("Relation name \"%s\" is duplicated.", relname));
2837                                 hint->base.state = HINT_STATE_ERROR;
2838                                 break;
2839                         }
2840
2841                         hint->joinrelids = bms_add_member(hint->joinrelids, relid);
2842                 }
2843
2844                 if (relid <= 0 || hint->base.state == HINT_STATE_ERROR)
2845                         continue;
2846
2847                 hstate->join_hint_level[hint->nrels] =
2848                         lappend(hstate->join_hint_level[hint->nrels], hint);
2849         }
2850
2851         /* Do nothing if no Leading hint was supplied. */
2852         if (hstate->num_hints[HINT_TYPE_LEADING] == 0)
2853                 return false;
2854
2855         /*
2856          * Decide to use Leading hint。
2857          */
2858         for (i = 0; i < hstate->num_hints[HINT_TYPE_LEADING]; i++)
2859         {
2860                 LeadingHint        *leading_hint = (LeadingHint *)hstate->leading_hint[i];
2861                 Relids                  relids;
2862
2863                 if (leading_hint->base.state == HINT_STATE_ERROR)
2864                         continue;
2865
2866                 relid = 0;
2867                 relids = NULL;
2868
2869                 foreach(l, leading_hint->relations)
2870                 {
2871                         relname = (char *)lfirst(l);;
2872
2873                         relid = find_relid_aliasname(root, relname, initial_rels,
2874                                                                                  leading_hint->base.hint_str);
2875                         if (relid == -1)
2876                                 leading_hint->base.state = HINT_STATE_ERROR;
2877
2878                         if (relid <= 0)
2879                                 break;
2880
2881                         if (bms_is_member(relid, relids))
2882                         {
2883                                 hint_ereport(leading_hint->base.hint_str,
2884                                                          ("Relation name \"%s\" is duplicated.", relname));
2885                                 leading_hint->base.state = HINT_STATE_ERROR;
2886                                 break;
2887                         }
2888
2889                         relids = bms_add_member(relids, relid);
2890                 }
2891
2892                 if (relid <= 0 || leading_hint->base.state == HINT_STATE_ERROR)
2893                         continue;
2894
2895                 if (lhint != NULL)
2896                 {
2897                         hint_ereport(lhint->base.hint_str,
2898                                  ("Conflict %s hint.", HintTypeName[lhint->base.type]));
2899                         lhint->base.state = HINT_STATE_DUPLICATION;
2900                 }
2901                 leading_hint->base.state = HINT_STATE_USED;
2902                 lhint = leading_hint;
2903         }
2904
2905         /* check to exist Leading hint marked with 'used'. */
2906         if (lhint == NULL)
2907                 return false;
2908
2909         /*
2910          * We need join method hints which fit specified join order in every join
2911          * level.  For example, Leading(A B C) virtually requires following join
2912          * method hints, if no join method hint supplied:
2913          *   - level 1: none
2914          *   - level 2: NestLoop(A B), MergeJoin(A B), HashJoin(A B)
2915          *   - level 3: NestLoop(A B C), MergeJoin(A B C), HashJoin(A B C)
2916          *
2917          * If we already have join method hint which fits specified join order in
2918          * that join level, we leave it as-is and don't add new hints.
2919          */
2920         joinrelids = NULL;
2921         njoinrels = 0;
2922         if (lhint->outer_inner == NULL)
2923         {
2924                 foreach(l, lhint->relations)
2925                 {
2926                         JoinMethodHint *hint;
2927
2928                         relname = (char *)lfirst(l);
2929
2930                         /*
2931                          * Find relid of the relation which has given name.  If we have the
2932                          * name given in Leading hint multiple times in the join, nothing to
2933                          * do.
2934                          */
2935                         relid = find_relid_aliasname(root, relname, initial_rels,
2936                                                                                  hstate->hint_str);
2937
2938                         /* Create bitmap of relids for current join level. */
2939                         joinrelids = bms_add_member(joinrelids, relid);
2940                         njoinrels++;
2941
2942                         /* We never have join method hint for single relation. */
2943                         if (njoinrels < 2)
2944                                 continue;
2945
2946                         /*
2947                          * If we don't have join method hint, create new one for the
2948                          * join combination with all join methods are enabled.
2949                          */
2950                         hint = find_join_hint(joinrelids);
2951                         if (hint == NULL)
2952                         {
2953                                 /*
2954                                  * Here relnames is not set, since Relids bitmap is sufficient
2955                                  * to control paths of this query afterward.
2956                                  */
2957                                 hint = (JoinMethodHint *) JoinMethodHintCreate(
2958                                                                                         lhint->base.hint_str,
2959                                                                                         HINT_LEADING,
2960                                                                                         HINT_KEYWORD_LEADING);
2961                                 hint->base.state = HINT_STATE_USED;
2962                                 hint->nrels = njoinrels;
2963                                 hint->enforce_mask = ENABLE_ALL_JOIN;
2964                                 hint->joinrelids = bms_copy(joinrelids);
2965                         }
2966
2967                         join_method_hints[njoinrels] = hint;
2968
2969                         if (njoinrels >= nbaserel)
2970                                 break;
2971                 }
2972                 bms_free(joinrelids);
2973
2974                 if (njoinrels < 2)
2975                         return false;
2976
2977                 /*
2978                  * Delete all join hints which have different combination from Leading
2979                  * hint.
2980                  */
2981                 for (i = 2; i <= njoinrels; i++)
2982                 {
2983                         list_free(hstate->join_hint_level[i]);
2984
2985                         hstate->join_hint_level[i] = lappend(NIL, join_method_hints[i]);
2986                 }
2987         }
2988         else
2989         {
2990                 joinrelids = OuterInnerJoinCreate(lhint->outer_inner,
2991                                                                                   lhint,
2992                                           root,
2993                                           initial_rels,
2994                                                                                   hstate,
2995                                                                                   nbaserel);
2996
2997                 njoinrels = bms_num_members(joinrelids);
2998                 Assert(njoinrels >= 2);
2999
3000                 /*
3001                  * Delete all join hints which have different combination from Leading
3002                  * hint.
3003                  */
3004                 for (i = 2;i <= njoinrels; i++)
3005                 {
3006                         if (hstate->join_hint_level[i] != NIL)
3007                         {
3008                                 ListCell *prev = NULL;
3009                                 ListCell *next = NULL;
3010                                 for(l = list_head(hstate->join_hint_level[i]); l; l = next)
3011                                 {
3012
3013                                         JoinMethodHint *hint = (JoinMethodHint *)lfirst(l);
3014
3015                                         next = lnext(l);
3016
3017                                         if (hint->inner_nrels == 0 &&
3018                                                 !(bms_intersect(hint->joinrelids, joinrelids) == NULL ||
3019                                                   bms_equal(bms_union(hint->joinrelids, joinrelids),
3020                                                   hint->joinrelids)))
3021                                         {
3022                                                 hstate->join_hint_level[i] =
3023                                                         list_delete_cell(hstate->join_hint_level[i], l,
3024                                                                                          prev);
3025                                         }
3026                                         else
3027                                                 prev = l;
3028                                 }
3029                         }
3030                 }
3031
3032                 bms_free(joinrelids);
3033         }
3034
3035         if (hint_state_enabled(lhint))
3036         {
3037                 set_join_config_options(DISABLE_ALL_JOIN, current_hint->context);
3038                 return true;
3039         }
3040         return false;
3041 }
3042
3043 /*
3044  * set_plain_rel_pathlist
3045  *        Build access paths for a plain relation (no subquery, no inheritance)
3046  *
3047  * This function was copied and edited from set_plain_rel_pathlist() in
3048  * src/backend/optimizer/path/allpaths.c
3049  */
3050 static void
3051 set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
3052 {
3053         /* Consider sequential scan */
3054 #if PG_VERSION_NUM >= 90200
3055         add_path(rel, create_seqscan_path(root, rel, NULL));
3056 #else
3057         add_path(rel, create_seqscan_path(root, rel));
3058 #endif
3059
3060         /* Consider index scans */
3061         create_index_paths(root, rel);
3062
3063         /* Consider TID scans */
3064         create_tidscan_paths(root, rel);
3065
3066         /* Now find the cheapest of the paths for this rel */
3067         set_cheapest(rel);
3068 }
3069
3070 static void
3071 rebuild_scan_path(HintState *hstate, PlannerInfo *root, int level,
3072                                   List *initial_rels)
3073 {
3074         ListCell   *l;
3075
3076         foreach(l, initial_rels)
3077         {
3078                 RelOptInfo         *rel = (RelOptInfo *) lfirst(l);
3079                 RangeTblEntry  *rte;
3080                 ScanMethodHint *hint;
3081
3082                 /* Skip relations which we can't choose scan method. */
3083                 if (rel->reloptkind != RELOPT_BASEREL || rel->rtekind != RTE_RELATION)
3084                         continue;
3085
3086                 rte = root->simple_rte_array[rel->relid];
3087
3088                 /* We can't force scan method of foreign tables */
3089                 if (rte->relkind == RELKIND_FOREIGN_TABLE)
3090                         continue;
3091
3092                 /*
3093                  * Create scan paths with GUC parameters which are at the beginning of
3094                  * planner if scan method hint is not specified, otherwise use
3095                  * specified hints and mark the hint as used.
3096                  */
3097                 if ((hint = find_scan_hint(root, rel)) == NULL)
3098                         set_scan_config_options(hstate->init_scan_mask,
3099                                                                         hstate->context);
3100                 else
3101                 {
3102                         set_scan_config_options(hint->enforce_mask, hstate->context);
3103                         hint->base.state = HINT_STATE_USED;
3104                 }
3105
3106                 list_free_deep(rel->pathlist);
3107                 rel->pathlist = NIL;
3108                 if (rte->inh)
3109                 {
3110                         /* It's an "append relation", process accordingly */
3111                         set_append_rel_pathlist(root, rel, rel->relid, rte);
3112                 }
3113                 else
3114                 {
3115                         set_plain_rel_pathlist(root, rel, rte);
3116                 }
3117         }
3118
3119         /*
3120          * Restore the GUC variables we set above.
3121          */
3122         set_scan_config_options(hstate->init_scan_mask, hstate->context);
3123 }
3124
3125 /*
3126  * wrapper of make_join_rel()
3127  *
3128  * call make_join_rel() after changing enable_* parameters according to given
3129  * hints.
3130  */
3131 static RelOptInfo *
3132 make_join_rel_wrapper(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
3133 {
3134         Relids                  joinrelids;
3135         JoinMethodHint *hint;
3136         RelOptInfo         *rel;
3137         int                             save_nestlevel;
3138
3139         joinrelids = bms_union(rel1->relids, rel2->relids);
3140         hint = find_join_hint(joinrelids);
3141         bms_free(joinrelids);
3142
3143         if (!hint)
3144                 return pg_hint_plan_make_join_rel(root, rel1, rel2);
3145
3146         if (hint->inner_nrels == 0)
3147         {
3148                 save_nestlevel = NewGUCNestLevel();
3149
3150                 set_join_config_options(hint->enforce_mask, current_hint->context);
3151
3152                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
3153                 hint->base.state = HINT_STATE_USED;
3154
3155                 /*
3156                  * Restore the GUC variables we set above.
3157                  */
3158                 AtEOXact_GUC(true, save_nestlevel);
3159         }
3160         else
3161                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
3162
3163         return rel;
3164 }
3165
3166 /*
3167  * TODO : comment
3168  */
3169 static void
3170 add_paths_to_joinrel_wrapper(PlannerInfo *root,
3171                                                          RelOptInfo *joinrel,
3172                                                          RelOptInfo *outerrel,
3173                                                          RelOptInfo *innerrel,
3174                                                          JoinType jointype,
3175                                                          SpecialJoinInfo *sjinfo,
3176                                                          List *restrictlist)
3177 {
3178         ScanMethodHint *scan_hint = NULL;
3179         Relids                  joinrelids;
3180         JoinMethodHint *join_hint;
3181         int                             save_nestlevel;
3182
3183         if ((scan_hint = find_scan_hint(root, innerrel)) != NULL)
3184         {
3185                 set_scan_config_options(scan_hint->enforce_mask, current_hint->context);
3186                 scan_hint->base.state = HINT_STATE_USED;
3187         }
3188
3189         joinrelids = bms_union(outerrel->relids, innerrel->relids);
3190         join_hint = find_join_hint(joinrelids);
3191         bms_free(joinrelids);
3192
3193         if (join_hint && join_hint->inner_nrels != 0)
3194         {
3195                 save_nestlevel = NewGUCNestLevel();
3196
3197                 if (bms_equal(join_hint->inner_joinrelids, innerrel->relids))
3198                 {
3199
3200                         set_join_config_options(join_hint->enforce_mask,
3201                                                                         current_hint->context);
3202
3203                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3204                                                                  sjinfo, restrictlist);
3205                         join_hint->base.state = HINT_STATE_USED;
3206                 }
3207                 else
3208                 {
3209                         set_join_config_options(DISABLE_ALL_JOIN, current_hint->context);
3210                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3211                                                                  sjinfo, restrictlist);
3212                 }
3213
3214                 /*
3215                  * Restore the GUC variables we set above.
3216                  */
3217                 AtEOXact_GUC(true, save_nestlevel);
3218         }
3219         else
3220                 add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
3221                                                          sjinfo, restrictlist);
3222
3223         if (scan_hint != NULL)
3224                 set_scan_config_options(current_hint->init_scan_mask,
3225                                                                 current_hint->context);
3226 }
3227
3228 static int
3229 get_num_baserels(List *initial_rels)
3230 {
3231         int                     nbaserel = 0;
3232         ListCell   *l;
3233
3234         foreach(l, initial_rels)
3235         {
3236                 RelOptInfo *rel = (RelOptInfo *) lfirst(l);
3237
3238                 if (rel->reloptkind == RELOPT_BASEREL)
3239                         nbaserel++;
3240                 else if (rel->reloptkind ==RELOPT_JOINREL)
3241                         nbaserel+= bms_num_members(rel->relids);
3242                 else
3243                 {
3244                         /* other values not expected here */
3245                         elog(ERROR, "unrecognized reloptkind type: %d", rel->reloptkind);
3246                 }
3247         }
3248
3249         return nbaserel;
3250 }
3251
3252 static RelOptInfo *
3253 pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
3254                                                  List *initial_rels)
3255 {
3256         JoinMethodHint    **join_method_hints;
3257         int                                     nbaserel;
3258         RelOptInfo                 *rel;
3259         int                                     i;
3260         bool                            leading_hint_enable;
3261
3262         /*
3263          * Use standard planner (or geqo planner) if pg_hint_plan is disabled or no
3264          * valid hint is supplied.
3265          */
3266         if (!current_hint)
3267         {
3268                 if (prev_join_search)
3269                         return (*prev_join_search) (root, levels_needed, initial_rels);
3270                 else if (enable_geqo && levels_needed >= geqo_threshold)
3271                         return geqo(root, levels_needed, initial_rels);
3272                 else
3273                         return standard_join_search(root, levels_needed, initial_rels);
3274         }
3275
3276         /* We apply scan method hint rebuild scan path. */
3277         rebuild_scan_path(current_hint, root, levels_needed, initial_rels);
3278
3279         /*
3280          * In the case using GEQO, only scan method hints and Set hints have
3281          * effect.  Join method and join order is not controllable by hints.
3282          */
3283         if (enable_geqo && levels_needed >= geqo_threshold)
3284                 return geqo(root, levels_needed, initial_rels);
3285
3286         nbaserel = get_num_baserels(initial_rels);
3287         current_hint->join_hint_level = palloc0(sizeof(List *) * (nbaserel + 1));
3288         join_method_hints = palloc0(sizeof(JoinMethodHint *) * (nbaserel + 1));
3289
3290         leading_hint_enable = transform_join_hints(current_hint, root, nbaserel,
3291                                                                                            initial_rels, join_method_hints);
3292
3293         rel = pg_hint_plan_standard_join_search(root, levels_needed, initial_rels);
3294
3295         for (i = 2; i <= nbaserel; i++)
3296         {
3297                 list_free(current_hint->join_hint_level[i]);
3298
3299                 /* free Leading hint only */
3300                 if (join_method_hints[i] != NULL &&
3301                         join_method_hints[i]->enforce_mask == ENABLE_ALL_JOIN)
3302                         JoinMethodHintDelete(join_method_hints[i]);
3303         }
3304         pfree(current_hint->join_hint_level);
3305         pfree(join_method_hints);
3306
3307         if (leading_hint_enable)
3308                 set_join_config_options(current_hint->init_join_mask,
3309                                                                 current_hint->context);
3310
3311         return rel;
3312 }
3313
3314 /*
3315  * set_rel_pathlist
3316  *        Build access paths for a base relation
3317  *
3318  * This function was copied and edited from set_rel_pathlist() in
3319  * src/backend/optimizer/path/allpaths.c
3320  */
3321 static void
3322 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
3323                                  Index rti, RangeTblEntry *rte)
3324 {
3325 #if PG_VERSION_NUM >= 90200
3326         if (IS_DUMMY_REL(rel))
3327         {
3328                 /* We already proved the relation empty, so nothing more to do */
3329         }
3330         else if (rte->inh)
3331 #else
3332         if (rte->inh)
3333 #endif
3334         {
3335                 /* It's an "append relation", process accordingly */
3336                 set_append_rel_pathlist(root, rel, rti, rte);
3337         }
3338         else
3339         {
3340                 if (rel->rtekind == RTE_RELATION)
3341                 {
3342                         if (rte->relkind == RELKIND_RELATION)
3343                         {
3344                                 /* Plain relation */
3345                                 set_plain_rel_pathlist(root, rel, rte);
3346                         }
3347                         else
3348                                 elog(ERROR, "unexpected relkind: %c", rte->relkind);
3349                 }
3350                 else
3351                         elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
3352         }
3353 }
3354
3355 #define standard_join_search pg_hint_plan_standard_join_search
3356 #define join_search_one_level pg_hint_plan_join_search_one_level
3357 #define make_join_rel make_join_rel_wrapper
3358 #include "core.c"
3359
3360 #undef make_join_rel
3361 #define make_join_rel pg_hint_plan_make_join_rel
3362 #define add_paths_to_joinrel add_paths_to_joinrel_wrapper
3363 #include "make_join_rel.c"