pg_hint_plan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * pg_hint_plan.c
   4  *                hinting on how to execute a query for PostgreSQL
   5  *
   6  * Copyright (c) 2012-2017, NIPPON TELEGRAPH AND TELEPHONE CORPORATION
   7  *
   8  *-------------------------------------------------------------------------
   9  */
  10 #include <string.h>
  11
  12 #include "postgres.h"
  13 #include "catalog/pg_collation.h"
  14 #include "catalog/pg_index.h"
  15 #include "commands/prepare.h"
  16 #include "mb/pg_wchar.h"
  17 #include "miscadmin.h"
  18 #include "nodes/nodeFuncs.h"
  19 #include "nodes/params.h"
  20 #include "nodes/relation.h"
  21 #include "optimizer/clauses.h"
  22 #include "optimizer/cost.h"
  23 #include "optimizer/geqo.h"
  24 #include "optimizer/joininfo.h"
  25 #include "optimizer/pathnode.h"
  26 #include "optimizer/paths.h"
  27 #include "optimizer/plancat.h"
  28 #include "optimizer/planner.h"
  29 #include "optimizer/prep.h"
  30 #include "optimizer/restrictinfo.h"
  31 #include "parser/analyze.h"
  32 #include "parser/parsetree.h"
  33 #include "parser/scansup.h"
  34 #include "tcop/utility.h"
  35 #include "utils/builtins.h"
  36 #include "utils/lsyscache.h"
  37 #include "utils/memutils.h"
  38 #include "utils/rel.h"
  39 #include "utils/snapmgr.h"
  40 #include "utils/syscache.h"
  41 #include "utils/resowner.h"
  42
  43 #include "catalog/pg_class.h"
  44
  45 #include "executor/spi.h"
  46 #include "catalog/pg_type.h"
  47
  48 #include "plpgsql.h"
  49
  50 /* partially copied from pg_stat_statements */
  51 #include "normalize_query.h"
  52
  53 /* PostgreSQL */
  54 #include "access/htup_details.h"
  55
  56 #ifdef PG_MODULE_MAGIC
  57 PG_MODULE_MAGIC;
  58 #endif
  59
  60 #define BLOCK_COMMENT_START             "/*"
  61 #define BLOCK_COMMENT_END               "*/"
  62 #define HINT_COMMENT_KEYWORD    "+"
  63 #define HINT_START                              BLOCK_COMMENT_START HINT_COMMENT_KEYWORD
  64 #define HINT_END                                BLOCK_COMMENT_END
  65
  66 /* hint keywords */
  67 #define HINT_SEQSCAN                    "SeqScan"
  68 #define HINT_INDEXSCAN                  "IndexScan"
  69 #define HINT_INDEXSCANREGEXP    "IndexScanRegexp"
  70 #define HINT_BITMAPSCAN                 "BitmapScan"
  71 #define HINT_BITMAPSCANREGEXP   "BitmapScanRegexp"
  72 #define HINT_TIDSCAN                    "TidScan"
  73 #define HINT_NOSEQSCAN                  "NoSeqScan"
  74 #define HINT_NOINDEXSCAN                "NoIndexScan"
  75 #define HINT_NOBITMAPSCAN               "NoBitmapScan"
  76 #define HINT_NOTIDSCAN                  "NoTidScan"
  77 #define HINT_INDEXONLYSCAN              "IndexOnlyScan"
  78 #define HINT_INDEXONLYSCANREGEXP        "IndexOnlyScanRegexp"
  79 #define HINT_NOINDEXONLYSCAN    "NoIndexOnlyScan"
  80 #define HINT_PARALLEL                   "Parallel"
  81
  82 #define HINT_NESTLOOP                   "NestLoop"
  83 #define HINT_MERGEJOIN                  "MergeJoin"
  84 #define HINT_HASHJOIN                   "HashJoin"
  85 #define HINT_NONESTLOOP                 "NoNestLoop"
  86 #define HINT_NOMERGEJOIN                "NoMergeJoin"
  87 #define HINT_NOHASHJOIN                 "NoHashJoin"
  88 #define HINT_LEADING                    "Leading"
  89 #define HINT_SET                                "Set"
  90 #define HINT_ROWS                               "Rows"
  91
  92 #define HINT_ARRAY_DEFAULT_INITSIZE 8
  93
  94 #define hint_ereport(str, detail) \
  95         do { \
  96                 ereport(pg_hint_plan_message_level,             \
  97                         (errmsg("pg_hint_plan%s: hint syntax error at or near \"%s\"", qnostr, (str)), \
  98                          errdetail detail)); \
  99                 msgqno = qno; \
 100         } while(0)
 101
 102 #define skip_space(str) \
 103         while (isspace(*str)) \
 104                 str++;
 105
 106 enum
 107 {
 108         ENABLE_SEQSCAN = 0x01,
 109         ENABLE_INDEXSCAN = 0x02,
 110         ENABLE_BITMAPSCAN = 0x04,
 111         ENABLE_TIDSCAN = 0x08,
 112         ENABLE_INDEXONLYSCAN = 0x10
 113 } SCAN_TYPE_BITS;
 114
 115 enum
 116 {
 117         ENABLE_NESTLOOP = 0x01,
 118         ENABLE_MERGEJOIN = 0x02,
 119         ENABLE_HASHJOIN = 0x04
 120 } JOIN_TYPE_BITS;
 121
 122 #define ENABLE_ALL_SCAN (ENABLE_SEQSCAN | ENABLE_INDEXSCAN | \
 123                                                  ENABLE_BITMAPSCAN | ENABLE_TIDSCAN | \
 124                                                  ENABLE_INDEXONLYSCAN)
 125 #define ENABLE_ALL_JOIN (ENABLE_NESTLOOP | ENABLE_MERGEJOIN | ENABLE_HASHJOIN)
 126 #define DISABLE_ALL_SCAN 0
 127 #define DISABLE_ALL_JOIN 0
 128
 129 /* hint keyword of enum type*/
 130 typedef enum HintKeyword
 131 {
 132         HINT_KEYWORD_SEQSCAN,
 133         HINT_KEYWORD_INDEXSCAN,
 134         HINT_KEYWORD_INDEXSCANREGEXP,
 135         HINT_KEYWORD_BITMAPSCAN,
 136         HINT_KEYWORD_BITMAPSCANREGEXP,
 137         HINT_KEYWORD_TIDSCAN,
 138         HINT_KEYWORD_NOSEQSCAN,
 139         HINT_KEYWORD_NOINDEXSCAN,
 140         HINT_KEYWORD_NOBITMAPSCAN,
 141         HINT_KEYWORD_NOTIDSCAN,
 142         HINT_KEYWORD_INDEXONLYSCAN,
 143         HINT_KEYWORD_INDEXONLYSCANREGEXP,
 144         HINT_KEYWORD_NOINDEXONLYSCAN,
 145
 146         HINT_KEYWORD_NESTLOOP,
 147         HINT_KEYWORD_MERGEJOIN,
 148         HINT_KEYWORD_HASHJOIN,
 149         HINT_KEYWORD_NONESTLOOP,
 150         HINT_KEYWORD_NOMERGEJOIN,
 151         HINT_KEYWORD_NOHASHJOIN,
 152
 153         HINT_KEYWORD_LEADING,
 154         HINT_KEYWORD_SET,
 155         HINT_KEYWORD_ROWS,
 156         HINT_KEYWORD_PARALLEL,
 157
 158         HINT_KEYWORD_UNRECOGNIZED
 159 } HintKeyword;
 160
 161 #define SCAN_HINT_ACCEPTS_INDEX_NAMES(kw) \
 162         (kw == HINT_KEYWORD_INDEXSCAN ||                        \
 163          kw == HINT_KEYWORD_INDEXSCANREGEXP ||          \
 164          kw == HINT_KEYWORD_INDEXONLYSCAN ||            \
 165          kw == HINT_KEYWORD_INDEXONLYSCANREGEXP ||      \
 166          kw == HINT_KEYWORD_BITMAPSCAN ||                               \
 167          kw == HINT_KEYWORD_BITMAPSCANREGEXP)
 168
 169
 170 typedef struct Hint Hint;
 171 typedef struct HintState HintState;
 172
 173 typedef Hint *(*HintCreateFunction) (const char *hint_str,
 174                                                                          const char *keyword,
 175                                                                          HintKeyword hint_keyword);
 176 typedef void (*HintDeleteFunction) (Hint *hint);
 177 typedef void (*HintDescFunction) (Hint *hint, StringInfo buf, bool nolf);
 178 typedef int (*HintCmpFunction) (const Hint *a, const Hint *b);
 179 typedef const char *(*HintParseFunction) (Hint *hint, HintState *hstate,
 180                                                                                   Query *parse, const char *str);
 181
 182 /* hint types */
 183 #define NUM_HINT_TYPE   6
 184 typedef enum HintType
 185 {
 186         HINT_TYPE_SCAN_METHOD,
 187         HINT_TYPE_JOIN_METHOD,
 188         HINT_TYPE_LEADING,
 189         HINT_TYPE_SET,
 190         HINT_TYPE_ROWS,
 191         HINT_TYPE_PARALLEL
 192 } HintType;
 193
 194 typedef enum HintTypeBitmap
 195 {
 196         HINT_BM_SCAN_METHOD = 1,
 197         HINT_BM_PARALLEL = 2
 198 } HintTypeBitmap;
 199
 200 static const char *HintTypeName[] = {
 201         "scan method",
 202         "join method",
 203         "leading",
 204         "set",
 205         "rows",
 206         "parallel"
 207 };
 208
 209 /* hint status */
 210 typedef enum HintStatus
 211 {
 212         HINT_STATE_NOTUSED = 0,         /* specified relation not used in query */
 213         HINT_STATE_USED,                        /* hint is used */
 214         HINT_STATE_DUPLICATION,         /* specified hint duplication */
 215         HINT_STATE_ERROR                        /* execute error (parse error does not include
 216                                                                  * it) */
 217 } HintStatus;
 218
 219 #define hint_state_enabled(hint) ((hint)->base.state == HINT_STATE_NOTUSED || \
 220                                                                   (hint)->base.state == HINT_STATE_USED)
 221
 222 static unsigned int qno = 0;
 223 static unsigned int msgqno = 0;
 224 static char qnostr[32];
 225 static const char *current_hint_str = NULL;
 226
 227 /* common data for all hints. */
 228 struct Hint
 229 {
 230         const char                 *hint_str;           /* must not do pfree */
 231         const char                 *keyword;            /* must not do pfree */
 232         HintKeyword                     hint_keyword;
 233         HintType                        type;
 234         HintStatus                      state;
 235         HintDeleteFunction      delete_func;
 236         HintDescFunction        desc_func;
 237         HintCmpFunction         cmp_func;
 238         HintParseFunction       parse_func;
 239 };
 240
 241 /* scan method hints */
 242 typedef struct ScanMethodHint
 243 {
 244         Hint                    base;
 245         char               *relname;
 246         List               *indexnames;
 247         bool                    regexp;
 248         unsigned char   enforce_mask;
 249 } ScanMethodHint;
 250
 251 typedef struct ParentIndexInfo
 252 {
 253         bool            indisunique;
 254         Oid                     method;
 255         List       *column_names;
 256         char       *expression_str;
 257         Oid                *indcollation;
 258         Oid                *opclass;
 259         int16      *indoption;
 260         char       *indpred_str;
 261 } ParentIndexInfo;
 262
 263 /* join method hints */
 264 typedef struct JoinMethodHint
 265 {
 266         Hint                    base;
 267         int                             nrels;
 268         int                             inner_nrels;
 269         char              **relnames;
 270         unsigned char   enforce_mask;
 271         Relids                  joinrelids;
 272         Relids                  inner_joinrelids;
 273 } JoinMethodHint;
 274
 275 /* join order hints */
 276 typedef struct OuterInnerRels
 277 {
 278         char   *relation;
 279         List   *outer_inner_pair;
 280 } OuterInnerRels;
 281
 282 typedef struct LeadingHint
 283 {
 284         Hint                    base;
 285         List               *relations;  /* relation names specified in Leading hint */
 286         OuterInnerRels *outer_inner;
 287 } LeadingHint;
 288
 289 /* change a run-time parameter hints */
 290 typedef struct SetHint
 291 {
 292         Hint    base;
 293         char   *name;                           /* name of variable */
 294         char   *value;
 295         List   *words;
 296 } SetHint;
 297
 298 /* rows hints */
 299 typedef enum RowsValueType {
 300         RVT_ABSOLUTE,           /* Rows(... #1000) */
 301         RVT_ADD,                        /* Rows(... +1000) */
 302         RVT_SUB,                        /* Rows(... -1000) */
 303         RVT_MULTI,                      /* Rows(... *1.2) */
 304 } RowsValueType;
 305 typedef struct RowsHint
 306 {
 307         Hint                    base;
 308         int                             nrels;
 309         int                             inner_nrels;
 310         char              **relnames;
 311         Relids                  joinrelids;
 312         Relids                  inner_joinrelids;
 313         char               *rows_str;
 314         RowsValueType   value_type;
 315         double                  rows;
 316 } RowsHint;
 317
 318 /* parallel hints */
 319 typedef struct ParallelHint
 320 {
 321         Hint                    base;
 322         char               *relname;
 323         char               *nworkers_str;       /* original string of nworkers */
 324         int                             nworkers;               /* num of workers specified by Worker */
 325         bool                    force_parallel; /* force parallel scan */
 326 } ParallelHint;
 327
 328 /*
 329  * Describes a context of hint processing.
 330  */
 331 struct HintState
 332 {
 333         char               *hint_str;                   /* original hint string */
 334
 335         /* all hint */
 336         int                             nall_hints;                     /* # of valid all hints */
 337         int                             max_all_hints;          /* # of slots for all hints */
 338         Hint              **all_hints;                  /* parsed all hints */
 339
 340         /* # of each hints */
 341         int                             num_hints[NUM_HINT_TYPE];
 342
 343         /* for scan method hints */
 344         ScanMethodHint **scan_hints;            /* parsed scan hints */
 345
 346         /* Initial values of parameters  */
 347         int                             init_scan_mask;         /* enable_* mask */
 348         int                             init_nworkers;          /* max_parallel_workers_per_gather */
 349         /* min_parallel_table_scan_size*/
 350         int                             init_min_para_tablescan_size;
 351         /* min_parallel_index_scan_size*/
 352         int                             init_min_para_indexscan_size;
 353         int                             init_paratup_cost;      /* parallel_tuple_cost */
 354         int                             init_parasetup_cost;/* parallel_setup_cost */
 355
 356         Index                   parent_relid;           /* inherit parent of table relid */
 357         ScanMethodHint *parent_scan_hint;       /* scan hint for the parent */
 358         ParallelHint   *parent_parallel_hint; /* parallel hint for the parent */
 359         List               *parent_index_infos; /* list of parent table's index */
 360
 361         JoinMethodHint **join_hints;            /* parsed join hints */
 362         int                             init_join_mask;         /* initial value join parameter */
 363         List              **join_hint_level;
 364         LeadingHint       **leading_hint;               /* parsed Leading hints */
 365         SetHint           **set_hints;                  /* parsed Set hints */
 366         GucContext              context;                        /* which GUC parameters can we set? */
 367         RowsHint          **rows_hints;                 /* parsed Rows hints */
 368         ParallelHint  **parallel_hints;         /* parsed Parallel hints */
 369 };
 370
 371 /*
 372  * Describes a hint parser module which is bound with particular hint keyword.
 373  */
 374 typedef struct HintParser
 375 {
 376         char                       *keyword;
 377         HintCreateFunction      create_func;
 378         HintKeyword                     hint_keyword;
 379 } HintParser;
 380
 381 /* Module callbacks */
 382 void            _PG_init(void);
 383 void            _PG_fini(void);
 384
 385 static void push_hint(HintState *hstate);
 386 static void pop_hint(void);
 387
 388 static void pg_hint_plan_post_parse_analyze(ParseState *pstate, Query *query);
 389 static PlannedStmt *pg_hint_plan_planner(Query *parse, int cursorOptions,
 390                                                                                  ParamListInfo boundParams);
 391 static RelOptInfo *pg_hint_plan_join_search(PlannerInfo *root,
 392                                                                                         int levels_needed,
 393                                                                                         List *initial_rels);
 394
 395 /* Scan method hint callbacks */
 396 static Hint *ScanMethodHintCreate(const char *hint_str, const char *keyword,
 397                                                                   HintKeyword hint_keyword);
 398 static void ScanMethodHintDelete(ScanMethodHint *hint);
 399 static void ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf, bool nolf);
 400 static int ScanMethodHintCmp(const ScanMethodHint *a, const ScanMethodHint *b);
 401 static const char *ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate,
 402                                                                            Query *parse, const char *str);
 403
 404 /* Join method hint callbacks */
 405 static Hint *JoinMethodHintCreate(const char *hint_str, const char *keyword,
 406                                                                   HintKeyword hint_keyword);
 407 static void JoinMethodHintDelete(JoinMethodHint *hint);
 408 static void JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf, bool nolf);
 409 static int JoinMethodHintCmp(const JoinMethodHint *a, const JoinMethodHint *b);
 410 static const char *JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate,
 411                                                                            Query *parse, const char *str);
 412
 413 /* Leading hint callbacks */
 414 static Hint *LeadingHintCreate(const char *hint_str, const char *keyword,
 415                                                            HintKeyword hint_keyword);
 416 static void LeadingHintDelete(LeadingHint *hint);
 417 static void LeadingHintDesc(LeadingHint *hint, StringInfo buf, bool nolf);
 418 static int LeadingHintCmp(const LeadingHint *a, const LeadingHint *b);
 419 static const char *LeadingHintParse(LeadingHint *hint, HintState *hstate,
 420                                                                         Query *parse, const char *str);
 421
 422 /* Set hint callbacks */
 423 static Hint *SetHintCreate(const char *hint_str, const char *keyword,
 424                                                    HintKeyword hint_keyword);
 425 static void SetHintDelete(SetHint *hint);
 426 static void SetHintDesc(SetHint *hint, StringInfo buf, bool nolf);
 427 static int SetHintCmp(const SetHint *a, const SetHint *b);
 428 static const char *SetHintParse(SetHint *hint, HintState *hstate, Query *parse,
 429                                                                 const char *str);
 430
 431 /* Rows hint callbacks */
 432 static Hint *RowsHintCreate(const char *hint_str, const char *keyword,
 433                                                         HintKeyword hint_keyword);
 434 static void RowsHintDelete(RowsHint *hint);
 435 static void RowsHintDesc(RowsHint *hint, StringInfo buf, bool nolf);
 436 static int RowsHintCmp(const RowsHint *a, const RowsHint *b);
 437 static const char *RowsHintParse(RowsHint *hint, HintState *hstate,
 438                                                                  Query *parse, const char *str);
 439
 440 /* Parallel hint callbacks */
 441 static Hint *ParallelHintCreate(const char *hint_str, const char *keyword,
 442                                                                 HintKeyword hint_keyword);
 443 static void ParallelHintDelete(ParallelHint *hint);
 444 static void ParallelHintDesc(ParallelHint *hint, StringInfo buf, bool nolf);
 445 static int ParallelHintCmp(const ParallelHint *a, const ParallelHint *b);
 446 static const char *ParallelHintParse(ParallelHint *hint, HintState *hstate,
 447                                                                          Query *parse, const char *str);
 448
 449 static void quote_value(StringInfo buf, const char *value);
 450
 451 static const char *parse_quoted_value(const char *str, char **word,
 452                                                                           bool truncate);
 453
 454 RelOptInfo *pg_hint_plan_standard_join_search(PlannerInfo *root,
 455                                                                                           int levels_needed,
 456                                                                                           List *initial_rels);
 457 void pg_hint_plan_join_search_one_level(PlannerInfo *root, int level);
 458 void pg_hint_plan_set_rel_pathlist(PlannerInfo * root, RelOptInfo *rel,
 459                                                                    Index rti, RangeTblEntry *rte);
 460 static void create_plain_partial_paths(PlannerInfo *root,
 461                                                                                                         RelOptInfo *rel);
 462 static void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
 463                                                                         List *live_childrels);
 464 static void make_rels_by_clause_joins(PlannerInfo *root, RelOptInfo *old_rel,
 465                                                                           ListCell *other_rels);
 466 static void make_rels_by_clauseless_joins(PlannerInfo *root,
 467                                                                                   RelOptInfo *old_rel,
 468                                                                                   ListCell *other_rels);
 469 static bool has_join_restriction(PlannerInfo *root, RelOptInfo *rel);
 470 static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 471                                                                    RangeTblEntry *rte);
 472 static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 473                                                                         Index rti, RangeTblEntry *rte);
 474 static void generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
 475                                                                            List *live_childrels,
 476                                                                            List *all_child_pathkeys,
 477                                                                            List *partitioned_rels);
 478 static Path *get_cheapest_parameterized_child_path(PlannerInfo *root,
 479                                                                           RelOptInfo *rel,
 480                                                                           Relids required_outer);
 481 static List *accumulate_append_subpath(List *subpaths, Path *path);
 482 RelOptInfo *pg_hint_plan_make_join_rel(PlannerInfo *root, RelOptInfo *rel1,
 483                                                                            RelOptInfo *rel2);
 484
 485 static void pg_hint_plan_plpgsql_stmt_beg(PLpgSQL_execstate *estate,
 486                                                                                   PLpgSQL_stmt *stmt);
 487 static void pg_hint_plan_plpgsql_stmt_end(PLpgSQL_execstate *estate,
 488                                                                                   PLpgSQL_stmt *stmt);
 489 static void plpgsql_query_erase_callback(ResourceReleasePhase phase,
 490                                                                                  bool isCommit,
 491                                                                                  bool isTopLevel,
 492                                                                                  void *arg);
 493 static int set_config_option_noerror(const char *name, const char *value,
 494                                                   GucContext context, GucSource source,
 495                                                   GucAction action, bool changeVal, int elevel);
 496 static void setup_scan_method_enforcement(ScanMethodHint *scanhint,
 497                                                                                   HintState *state);
 498 static int set_config_int32_option(const char *name, int32 value,
 499                                                                         GucContext context);
 500
 501 /* GUC variables */
 502 static bool     pg_hint_plan_enable_hint = true;
 503 static int debug_level = 0;
 504 static int      pg_hint_plan_message_level = INFO;
 505 /* Default is off, to keep backward compatibility. */
 506 static bool     pg_hint_plan_enable_hint_table = false;
 507
 508 static int plpgsql_recurse_level = 0;           /* PLpgSQL recursion level            */
 509 static int hint_inhibit_level = 0;                      /* Inhibit hinting if this is above 0 */
 510                                                                                         /* (This could not be above 1)        */
 511 static int max_hint_nworkers = -1;              /* Maximum nworkers of Workers hints */
 512
 513 static const struct config_enum_entry parse_messages_level_options[] = {
 514         {"debug", DEBUG2, true},
 515         {"debug5", DEBUG5, false},
 516         {"debug4", DEBUG4, false},
 517         {"debug3", DEBUG3, false},
 518         {"debug2", DEBUG2, false},
 519         {"debug1", DEBUG1, false},
 520         {"log", LOG, false},
 521         {"info", INFO, false},
 522         {"notice", NOTICE, false},
 523         {"warning", WARNING, false},
 524         {"error", ERROR, false},
 525         /*
 526          * {"fatal", FATAL, true},
 527          * {"panic", PANIC, true},
 528          */
 529         {NULL, 0, false}
 530 };
 531
 532 static const struct config_enum_entry parse_debug_level_options[] = {
 533         {"off", 0, false},
 534         {"on", 1, false},
 535         {"detailed", 2, false},
 536         {"verbose", 3, false},
 537         {"0", 0, true},
 538         {"1", 1, true},
 539         {"2", 2, true},
 540         {"3", 3, true},
 541         {"no", 0, true},
 542         {"yes", 1, true},
 543         {"false", 0, true},
 544         {"true", 1, true},
 545         {NULL, 0, false}
 546 };
 547
 548 /* Saved hook values in case of unload */
 549 static post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL;
 550 static planner_hook_type prev_planner = NULL;
 551 static join_search_hook_type prev_join_search = NULL;
 552 static set_rel_pathlist_hook_type prev_set_rel_pathlist = NULL;
 553
 554 /* Hold reference to currently active hint */
 555 static HintState *current_hint_state = NULL;
 556
 557 /*
 558  * List of hint contexts.  We treat the head of the list as the Top of the
 559  * context stack, so current_hint_state always points the first element of this
 560  * list.
 561  */
 562 static List *HintStateStack = NIL;
 563
 564 /*
 565  * Holds statement name during executing EXECUTE command.  NULL for other
 566  * statements.
 567  */
 568 static char        *stmt_name = NULL;
 569
 570 static const HintParser parsers[] = {
 571         {HINT_SEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_SEQSCAN},
 572         {HINT_INDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCAN},
 573         {HINT_INDEXSCANREGEXP, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCANREGEXP},
 574         {HINT_BITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_BITMAPSCAN},
 575         {HINT_BITMAPSCANREGEXP, ScanMethodHintCreate,
 576          HINT_KEYWORD_BITMAPSCANREGEXP},
 577         {HINT_TIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_TIDSCAN},
 578         {HINT_NOSEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOSEQSCAN},
 579         {HINT_NOINDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXSCAN},
 580         {HINT_NOBITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOBITMAPSCAN},
 581         {HINT_NOTIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOTIDSCAN},
 582         {HINT_INDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXONLYSCAN},
 583         {HINT_INDEXONLYSCANREGEXP, ScanMethodHintCreate,
 584          HINT_KEYWORD_INDEXONLYSCANREGEXP},
 585         {HINT_NOINDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXONLYSCAN},
 586
 587         {HINT_NESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NESTLOOP},
 588         {HINT_MERGEJOIN, JoinMethodHintCreate, HINT_KEYWORD_MERGEJOIN},
 589         {HINT_HASHJOIN, JoinMethodHintCreate, HINT_KEYWORD_HASHJOIN},
 590         {HINT_NONESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NONESTLOOP},
 591         {HINT_NOMERGEJOIN, JoinMethodHintCreate, HINT_KEYWORD_NOMERGEJOIN},
 592         {HINT_NOHASHJOIN, JoinMethodHintCreate, HINT_KEYWORD_NOHASHJOIN},
 593
 594         {HINT_LEADING, LeadingHintCreate, HINT_KEYWORD_LEADING},
 595         {HINT_SET, SetHintCreate, HINT_KEYWORD_SET},
 596         {HINT_ROWS, RowsHintCreate, HINT_KEYWORD_ROWS},
 597         {HINT_PARALLEL, ParallelHintCreate, HINT_KEYWORD_PARALLEL},
 598
 599         {NULL, NULL, HINT_KEYWORD_UNRECOGNIZED}
 600 };
 601
 602 PLpgSQL_plugin  plugin_funcs = {
 603         NULL,
 604         NULL,
 605         NULL,
 606         pg_hint_plan_plpgsql_stmt_beg,
 607         pg_hint_plan_plpgsql_stmt_end,
 608         NULL,
 609         NULL,
 610 };
 611
 612 /*
 613  * Module load callbacks
 614  */
 615 void
 616 _PG_init(void)
 617 {
 618         PLpgSQL_plugin  **var_ptr;
 619
 620         /* Define custom GUC variables. */
 621         DefineCustomBoolVariable("pg_hint_plan.enable_hint",
 622                          "Force planner to use plans specified in the hint comment preceding to the query.",
 623                                                          NULL,
 624                                                          &pg_hint_plan_enable_hint,
 625                                                          true,
 626                                                      PGC_USERSET,
 627                                                          0,
 628                                                          NULL,
 629                                                          NULL,
 630                                                          NULL);
 631
 632         DefineCustomEnumVariable("pg_hint_plan.debug_print",
 633                                                          "Logs results of hint parsing.",
 634                                                          NULL,
 635                                                          &debug_level,
 636                                                          false,
 637                                                          parse_debug_level_options,
 638                                                          PGC_USERSET,
 639                                                          0,
 640                                                          NULL,
 641                                                          NULL,
 642                                                          NULL);
 643
 644         DefineCustomEnumVariable("pg_hint_plan.parse_messages",
 645                                                          "Message level of parse errors.",
 646                                                          NULL,
 647                                                          &pg_hint_plan_message_level,
 648                                                          INFO,
 649                                                          parse_messages_level_options,
 650                                                          PGC_USERSET,
 651                                                          0,
 652                                                          NULL,
 653                                                          NULL,
 654                                                          NULL);
 655
 656         DefineCustomEnumVariable("pg_hint_plan.message_level",
 657                                                          "Message level of debug messages.",
 658                                                          NULL,
 659                                                          &pg_hint_plan_message_level,
 660                                                          INFO,
 661                                                          parse_messages_level_options,
 662                                                          PGC_USERSET,
 663                                                          0,
 664                                                          NULL,
 665                                                          NULL,
 666                                                          NULL);
 667
 668         DefineCustomBoolVariable("pg_hint_plan.enable_hint_table",
 669                                                          "Let pg_hint_plan look up the hint table.",
 670                                                          NULL,
 671                                                          &pg_hint_plan_enable_hint_table,
 672                                                          false,
 673                                                          PGC_USERSET,
 674                                                          0,
 675                                                          NULL,
 676                                                          NULL,
 677                                                          NULL);
 678
 679         /* Install hooks. */
 680         prev_post_parse_analyze_hook = post_parse_analyze_hook;
 681         post_parse_analyze_hook = pg_hint_plan_post_parse_analyze;
 682         prev_planner = planner_hook;
 683         planner_hook = pg_hint_plan_planner;
 684         prev_join_search = join_search_hook;
 685         join_search_hook = pg_hint_plan_join_search;
 686         prev_set_rel_pathlist = set_rel_pathlist_hook;
 687         set_rel_pathlist_hook = pg_hint_plan_set_rel_pathlist;
 688
 689         /* setup PL/pgSQL plugin hook */
 690         var_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin");
 691         *var_ptr = &plugin_funcs;
 692
 693         RegisterResourceReleaseCallback(plpgsql_query_erase_callback, NULL);
 694 }
 695
 696 /*
 697  * Module unload callback
 698  * XXX never called
 699  */
 700 void
 701 _PG_fini(void)
 702 {
 703         PLpgSQL_plugin  **var_ptr;
 704
 705         /* Uninstall hooks. */
 706         post_parse_analyze_hook = prev_post_parse_analyze_hook;
 707         planner_hook = prev_planner;
 708         join_search_hook = prev_join_search;
 709         set_rel_pathlist_hook = prev_set_rel_pathlist;
 710
 711         /* uninstall PL/pgSQL plugin hook */
 712         var_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin");
 713         *var_ptr = NULL;
 714 }
 715
 716 /*
 717  * create and delete functions the hint object
 718  */
 719
 720 static Hint *
 721 ScanMethodHintCreate(const char *hint_str, const char *keyword,
 722                                          HintKeyword hint_keyword)
 723 {
 724         ScanMethodHint *hint;
 725
 726         hint = palloc(sizeof(ScanMethodHint));
 727         hint->base.hint_str = hint_str;
 728         hint->base.keyword = keyword;
 729         hint->base.hint_keyword = hint_keyword;
 730         hint->base.type = HINT_TYPE_SCAN_METHOD;
 731         hint->base.state = HINT_STATE_NOTUSED;
 732         hint->base.delete_func = (HintDeleteFunction) ScanMethodHintDelete;
 733         hint->base.desc_func = (HintDescFunction) ScanMethodHintDesc;
 734         hint->base.cmp_func = (HintCmpFunction) ScanMethodHintCmp;
 735         hint->base.parse_func = (HintParseFunction) ScanMethodHintParse;
 736         hint->relname = NULL;
 737         hint->indexnames = NIL;
 738         hint->regexp = false;
 739         hint->enforce_mask = 0;
 740
 741         return (Hint *) hint;
 742 }
 743
 744 static void
 745 ScanMethodHintDelete(ScanMethodHint *hint)
 746 {
 747         if (!hint)
 748                 return;
 749
 750         if (hint->relname)
 751                 pfree(hint->relname);
 752         list_free_deep(hint->indexnames);
 753         pfree(hint);
 754 }
 755
 756 static Hint *
 757 JoinMethodHintCreate(const char *hint_str, const char *keyword,
 758                                          HintKeyword hint_keyword)
 759 {
 760         JoinMethodHint *hint;
 761
 762         hint = palloc(sizeof(JoinMethodHint));
 763         hint->base.hint_str = hint_str;
 764         hint->base.keyword = keyword;
 765         hint->base.hint_keyword = hint_keyword;
 766         hint->base.type = HINT_TYPE_JOIN_METHOD;
 767         hint->base.state = HINT_STATE_NOTUSED;
 768         hint->base.delete_func = (HintDeleteFunction) JoinMethodHintDelete;
 769         hint->base.desc_func = (HintDescFunction) JoinMethodHintDesc;
 770         hint->base.cmp_func = (HintCmpFunction) JoinMethodHintCmp;
 771         hint->base.parse_func = (HintParseFunction) JoinMethodHintParse;
 772         hint->nrels = 0;
 773         hint->inner_nrels = 0;
 774         hint->relnames = NULL;
 775         hint->enforce_mask = 0;
 776         hint->joinrelids = NULL;
 777         hint->inner_joinrelids = NULL;
 778
 779         return (Hint *) hint;
 780 }
 781
 782 static void
 783 JoinMethodHintDelete(JoinMethodHint *hint)
 784 {
 785         if (!hint)
 786                 return;
 787
 788         if (hint->relnames)
 789         {
 790                 int     i;
 791
 792                 for (i = 0; i < hint->nrels; i++)
 793                         pfree(hint->relnames[i]);
 794                 pfree(hint->relnames);
 795         }
 796
 797         bms_free(hint->joinrelids);
 798         bms_free(hint->inner_joinrelids);
 799         pfree(hint);
 800 }
 801
 802 static Hint *
 803 LeadingHintCreate(const char *hint_str, const char *keyword,
 804                                   HintKeyword hint_keyword)
 805 {
 806         LeadingHint        *hint;
 807
 808         hint = palloc(sizeof(LeadingHint));
 809         hint->base.hint_str = hint_str;
 810         hint->base.keyword = keyword;
 811         hint->base.hint_keyword = hint_keyword;
 812         hint->base.type = HINT_TYPE_LEADING;
 813         hint->base.state = HINT_STATE_NOTUSED;
 814         hint->base.delete_func = (HintDeleteFunction)LeadingHintDelete;
 815         hint->base.desc_func = (HintDescFunction) LeadingHintDesc;
 816         hint->base.cmp_func = (HintCmpFunction) LeadingHintCmp;
 817         hint->base.parse_func = (HintParseFunction) LeadingHintParse;
 818         hint->relations = NIL;
 819         hint->outer_inner = NULL;
 820
 821         return (Hint *) hint;
 822 }
 823
 824 static void
 825 LeadingHintDelete(LeadingHint *hint)
 826 {
 827         if (!hint)
 828                 return;
 829
 830         list_free_deep(hint->relations);
 831         if (hint->outer_inner)
 832                 pfree(hint->outer_inner);
 833         pfree(hint);
 834 }
 835
 836 static Hint *
 837 SetHintCreate(const char *hint_str, const char *keyword,
 838                           HintKeyword hint_keyword)
 839 {
 840         SetHint    *hint;
 841
 842         hint = palloc(sizeof(SetHint));
 843         hint->base.hint_str = hint_str;
 844         hint->base.keyword = keyword;
 845         hint->base.hint_keyword = hint_keyword;
 846         hint->base.type = HINT_TYPE_SET;
 847         hint->base.state = HINT_STATE_NOTUSED;
 848         hint->base.delete_func = (HintDeleteFunction) SetHintDelete;
 849         hint->base.desc_func = (HintDescFunction) SetHintDesc;
 850         hint->base.cmp_func = (HintCmpFunction) SetHintCmp;
 851         hint->base.parse_func = (HintParseFunction) SetHintParse;
 852         hint->name = NULL;
 853         hint->value = NULL;
 854         hint->words = NIL;
 855
 856         return (Hint *) hint;
 857 }
 858
 859 static void
 860 SetHintDelete(SetHint *hint)
 861 {
 862         if (!hint)
 863                 return;
 864
 865         if (hint->name)
 866                 pfree(hint->name);
 867         if (hint->value)
 868                 pfree(hint->value);
 869         if (hint->words)
 870                 list_free(hint->words);
 871         pfree(hint);
 872 }
 873
 874 static Hint *
 875 RowsHintCreate(const char *hint_str, const char *keyword,
 876                            HintKeyword hint_keyword)
 877 {
 878         RowsHint *hint;
 879
 880         hint = palloc(sizeof(RowsHint));
 881         hint->base.hint_str = hint_str;
 882         hint->base.keyword = keyword;
 883         hint->base.hint_keyword = hint_keyword;
 884         hint->base.type = HINT_TYPE_ROWS;
 885         hint->base.state = HINT_STATE_NOTUSED;
 886         hint->base.delete_func = (HintDeleteFunction) RowsHintDelete;
 887         hint->base.desc_func = (HintDescFunction) RowsHintDesc;
 888         hint->base.cmp_func = (HintCmpFunction) RowsHintCmp;
 889         hint->base.parse_func = (HintParseFunction) RowsHintParse;
 890         hint->nrels = 0;
 891         hint->inner_nrels = 0;
 892         hint->relnames = NULL;
 893         hint->joinrelids = NULL;
 894         hint->inner_joinrelids = NULL;
 895         hint->rows_str = NULL;
 896         hint->value_type = RVT_ABSOLUTE;
 897         hint->rows = 0;
 898
 899         return (Hint *) hint;
 900 }
 901
 902 static void
 903 RowsHintDelete(RowsHint *hint)
 904 {
 905         if (!hint)
 906                 return;
 907
 908         if (hint->relnames)
 909         {
 910                 int     i;
 911
 912                 for (i = 0; i < hint->nrels; i++)
 913                         pfree(hint->relnames[i]);
 914                 pfree(hint->relnames);
 915         }
 916
 917         bms_free(hint->joinrelids);
 918         bms_free(hint->inner_joinrelids);
 919         pfree(hint);
 920 }
 921
 922 static Hint *
 923 ParallelHintCreate(const char *hint_str, const char *keyword,
 924                                   HintKeyword hint_keyword)
 925 {
 926         ParallelHint *hint;
 927
 928         hint = palloc(sizeof(ScanMethodHint));
 929         hint->base.hint_str = hint_str;
 930         hint->base.keyword = keyword;
 931         hint->base.hint_keyword = hint_keyword;
 932         hint->base.type = HINT_TYPE_PARALLEL;
 933         hint->base.state = HINT_STATE_NOTUSED;
 934         hint->base.delete_func = (HintDeleteFunction) ParallelHintDelete;
 935         hint->base.desc_func = (HintDescFunction) ParallelHintDesc;
 936         hint->base.cmp_func = (HintCmpFunction) ParallelHintCmp;
 937         hint->base.parse_func = (HintParseFunction) ParallelHintParse;
 938         hint->relname = NULL;
 939         hint->nworkers = 0;
 940         hint->nworkers_str = "0";
 941
 942         return (Hint *) hint;
 943 }
 944
 945 static void
 946 ParallelHintDelete(ParallelHint *hint)
 947 {
 948         if (!hint)
 949                 return;
 950
 951         if (hint->relname)
 952                 pfree(hint->relname);
 953         pfree(hint);
 954 }
 955
 956
 957 static HintState *
 958 HintStateCreate(void)
 959 {
 960         HintState   *hstate;
 961
 962         hstate = palloc(sizeof(HintState));
 963         hstate->hint_str = NULL;
 964         hstate->nall_hints = 0;
 965         hstate->max_all_hints = 0;
 966         hstate->all_hints = NULL;
 967         memset(hstate->num_hints, 0, sizeof(hstate->num_hints));
 968         hstate->scan_hints = NULL;
 969         hstate->init_scan_mask = 0;
 970         hstate->init_nworkers = 0;
 971         hstate->init_min_para_tablescan_size = 0;
 972         hstate->init_min_para_indexscan_size = 0;
 973         hstate->init_paratup_cost = 0;
 974         hstate->init_parasetup_cost = 0;
 975         hstate->parent_relid = 0;
 976         hstate->parent_scan_hint = NULL;
 977         hstate->parent_parallel_hint = NULL;
 978         hstate->parent_index_infos = NIL;
 979         hstate->join_hints = NULL;
 980         hstate->init_join_mask = 0;
 981         hstate->join_hint_level = NULL;
 982         hstate->leading_hint = NULL;
 983         hstate->context = superuser() ? PGC_SUSET : PGC_USERSET;
 984         hstate->set_hints = NULL;
 985         hstate->rows_hints = NULL;
 986         hstate->parallel_hints = NULL;
 987
 988         return hstate;
 989 }
 990
 991 static void
 992 HintStateDelete(HintState *hstate)
 993 {
 994         int                     i;
 995
 996         if (!hstate)
 997                 return;
 998
 999         if (hstate->hint_str)
1000                 pfree(hstate->hint_str);
1001
1002         for (i = 0; i < hstate->num_hints[HINT_TYPE_SCAN_METHOD]; i++)
1003                 hstate->all_hints[i]->delete_func(hstate->all_hints[i]);
1004         if (hstate->all_hints)
1005                 pfree(hstate->all_hints);
1006         if (hstate->parent_index_infos)
1007                 list_free(hstate->parent_index_infos);
1008 }
1009
1010 /*
1011  * Copy given value into buf, with quoting with '"' if necessary.
1012  */
1013 static void
1014 quote_value(StringInfo buf, const char *value)
1015 {
1016         bool            need_quote = false;
1017         const char *str;
1018
1019         for (str = value; *str != '\0'; str++)
1020         {
1021                 if (isspace(*str) || *str == '(' || *str == ')' || *str == '"')
1022                 {
1023                         need_quote = true;
1024                         appendStringInfoCharMacro(buf, '"');
1025                         break;
1026                 }
1027         }
1028
1029         for (str = value; *str != '\0'; str++)
1030         {
1031                 if (*str == '"')
1032                         appendStringInfoCharMacro(buf, '"');
1033
1034                 appendStringInfoCharMacro(buf, *str);
1035         }
1036
1037         if (need_quote)
1038                 appendStringInfoCharMacro(buf, '"');
1039 }
1040
1041 static void
1042 ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf, bool nolf)
1043 {
1044         ListCell   *l;
1045
1046         appendStringInfo(buf, "%s(", hint->base.keyword);
1047         if (hint->relname != NULL)
1048         {
1049                 quote_value(buf, hint->relname);
1050                 foreach(l, hint->indexnames)
1051                 {
1052                         appendStringInfoCharMacro(buf, ' ');
1053                         quote_value(buf, (char *) lfirst(l));
1054                 }
1055         }
1056         appendStringInfoString(buf, ")");
1057         if (!nolf)
1058                 appendStringInfoChar(buf, '\n');
1059 }
1060
1061 static void
1062 JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf, bool nolf)
1063 {
1064         int     i;
1065
1066         appendStringInfo(buf, "%s(", hint->base.keyword);
1067         if (hint->relnames != NULL)
1068         {
1069                 quote_value(buf, hint->relnames[0]);
1070                 for (i = 1; i < hint->nrels; i++)
1071                 {
1072                         appendStringInfoCharMacro(buf, ' ');
1073                         quote_value(buf, hint->relnames[i]);
1074                 }
1075         }
1076         appendStringInfoString(buf, ")");
1077         if (!nolf)
1078                 appendStringInfoChar(buf, '\n');
1079 }
1080
1081 static void
1082 OuterInnerDesc(OuterInnerRels *outer_inner, StringInfo buf)
1083 {
1084         if (outer_inner->relation == NULL)
1085         {
1086                 bool            is_first;
1087                 ListCell   *l;
1088
1089                 is_first = true;
1090
1091                 appendStringInfoCharMacro(buf, '(');
1092                 foreach(l, outer_inner->outer_inner_pair)
1093                 {
1094                         if (is_first)
1095                                 is_first = false;
1096                         else
1097                                 appendStringInfoCharMacro(buf, ' ');
1098
1099                         OuterInnerDesc(lfirst(l), buf);
1100                 }
1101
1102                 appendStringInfoCharMacro(buf, ')');
1103         }
1104         else
1105                 quote_value(buf, outer_inner->relation);
1106 }
1107
1108 static void
1109 LeadingHintDesc(LeadingHint *hint, StringInfo buf, bool nolf)
1110 {
1111         appendStringInfo(buf, "%s(", HINT_LEADING);
1112         if (hint->outer_inner == NULL)
1113         {
1114                 ListCell   *l;
1115                 bool            is_first;
1116
1117                 is_first = true;
1118
1119                 foreach(l, hint->relations)
1120                 {
1121                         if (is_first)
1122                                 is_first = false;
1123                         else
1124                                 appendStringInfoCharMacro(buf, ' ');
1125
1126                         quote_value(buf, (char *) lfirst(l));
1127                 }
1128         }
1129         else
1130                 OuterInnerDesc(hint->outer_inner, buf);
1131
1132         appendStringInfoString(buf, ")");
1133         if (!nolf)
1134                 appendStringInfoChar(buf, '\n');
1135 }
1136
1137 static void
1138 SetHintDesc(SetHint *hint, StringInfo buf, bool nolf)
1139 {
1140         bool            is_first = true;
1141         ListCell   *l;
1142
1143         appendStringInfo(buf, "%s(", HINT_SET);
1144         foreach(l, hint->words)
1145         {
1146                 if (is_first)
1147                         is_first = false;
1148                 else
1149                         appendStringInfoCharMacro(buf, ' ');
1150
1151                 quote_value(buf, (char *) lfirst(l));
1152         }
1153         appendStringInfo(buf, ")");
1154         if (!nolf)
1155                 appendStringInfoChar(buf, '\n');
1156 }
1157
1158 static void
1159 RowsHintDesc(RowsHint *hint, StringInfo buf, bool nolf)
1160 {
1161         int     i;
1162
1163         appendStringInfo(buf, "%s(", hint->base.keyword);
1164         if (hint->relnames != NULL)
1165         {
1166                 quote_value(buf, hint->relnames[0]);
1167                 for (i = 1; i < hint->nrels; i++)
1168                 {
1169                         appendStringInfoCharMacro(buf, ' ');
1170                         quote_value(buf, hint->relnames[i]);
1171                 }
1172         }
1173         appendStringInfo(buf, " %s", hint->rows_str);
1174         appendStringInfoString(buf, ")");
1175         if (!nolf)
1176                 appendStringInfoChar(buf, '\n');
1177 }
1178
1179 static void
1180 ParallelHintDesc(ParallelHint *hint, StringInfo buf, bool nolf)
1181 {
1182         appendStringInfo(buf, "%s(", hint->base.keyword);
1183         if (hint->relname != NULL)
1184         {
1185                 quote_value(buf, hint->relname);
1186
1187                 /* number of workers  */
1188                 appendStringInfoCharMacro(buf, ' ');
1189                 quote_value(buf, hint->nworkers_str);
1190                 /* application mode of num of workers */
1191                 appendStringInfoCharMacro(buf, ' ');
1192                 appendStringInfoString(buf,
1193                                                            (hint->force_parallel ? "hard" : "soft"));
1194         }
1195         appendStringInfoString(buf, ")");
1196         if (!nolf)
1197                 appendStringInfoChar(buf, '\n');
1198 }
1199
1200 /*
1201  * Append string which represents all hints in a given state to buf, with
1202  * preceding title with them.
1203  */
1204 static void
1205 desc_hint_in_state(HintState *hstate, StringInfo buf, const char *title,
1206                                    HintStatus state, bool nolf)
1207 {
1208         int     i, nshown;
1209
1210         appendStringInfo(buf, "%s:", title);
1211         if (!nolf)
1212                 appendStringInfoChar(buf, '\n');
1213
1214         nshown = 0;
1215         for (i = 0; i < hstate->nall_hints; i++)
1216         {
1217                 if (hstate->all_hints[i]->state != state)
1218                         continue;
1219
1220                 hstate->all_hints[i]->desc_func(hstate->all_hints[i], buf, nolf);
1221                 nshown++;
1222         }
1223
1224         if (nolf && nshown == 0)
1225                 appendStringInfoString(buf, "(none)");
1226 }
1227
1228 /*
1229  * Dump contents of given hstate to server log with log level LOG.
1230  */
1231 static void
1232 HintStateDump(HintState *hstate)
1233 {
1234         StringInfoData  buf;
1235
1236         if (!hstate)
1237         {
1238                 elog(LOG, "pg_hint_plan:\nno hint");
1239                 return;
1240         }
1241
1242         initStringInfo(&buf);
1243
1244         appendStringInfoString(&buf, "pg_hint_plan:\n");
1245         desc_hint_in_state(hstate, &buf, "used hint", HINT_STATE_USED, false);
1246         desc_hint_in_state(hstate, &buf, "not used hint", HINT_STATE_NOTUSED, false);
1247         desc_hint_in_state(hstate, &buf, "duplication hint", HINT_STATE_DUPLICATION, false);
1248         desc_hint_in_state(hstate, &buf, "error hint", HINT_STATE_ERROR, false);
1249
1250         elog(LOG, "%s", buf.data);
1251
1252         pfree(buf.data);
1253 }
1254
1255 static void
1256 HintStateDump2(HintState *hstate)
1257 {
1258         StringInfoData  buf;
1259
1260         if (!hstate)
1261         {
1262                 elog(pg_hint_plan_message_level,
1263                          "pg_hint_plan%s: HintStateDump: no hint", qnostr);
1264                 return;
1265         }
1266
1267         initStringInfo(&buf);
1268         appendStringInfo(&buf, "pg_hint_plan%s: HintStateDump: ", qnostr);
1269         desc_hint_in_state(hstate, &buf, "{used hints", HINT_STATE_USED, true);
1270         desc_hint_in_state(hstate, &buf, "}, {not used hints", HINT_STATE_NOTUSED, true);
1271         desc_hint_in_state(hstate, &buf, "}, {duplicate hints", HINT_STATE_DUPLICATION, true);
1272         desc_hint_in_state(hstate, &buf, "}, {error hints", HINT_STATE_ERROR, true);
1273         appendStringInfoChar(&buf, '}');
1274
1275         ereport(pg_hint_plan_message_level,
1276                         (errmsg("%s", buf.data),
1277                          errhidestmt(true),
1278                          errhidecontext(true)));
1279
1280         pfree(buf.data);
1281 }
1282
1283 /*
1284  * compare functions
1285  */
1286
1287 static int
1288 RelnameCmp(const void *a, const void *b)
1289 {
1290         const char *relnamea = *((const char **) a);
1291         const char *relnameb = *((const char **) b);
1292
1293         return strcmp(relnamea, relnameb);
1294 }
1295
1296 static int
1297 ScanMethodHintCmp(const ScanMethodHint *a, const ScanMethodHint *b)
1298 {
1299         return RelnameCmp(&a->relname, &b->relname);
1300 }
1301
1302 static int
1303 JoinMethodHintCmp(const JoinMethodHint *a, const JoinMethodHint *b)
1304 {
1305         int     i;
1306
1307         if (a->nrels != b->nrels)
1308                 return a->nrels - b->nrels;
1309
1310         for (i = 0; i < a->nrels; i++)
1311         {
1312                 int     result;
1313                 if ((result = RelnameCmp(&a->relnames[i], &b->relnames[i])) != 0)
1314                         return result;
1315         }
1316
1317         return 0;
1318 }
1319
1320 static int
1321 LeadingHintCmp(const LeadingHint *a, const LeadingHint *b)
1322 {
1323         return 0;
1324 }
1325
1326 static int
1327 SetHintCmp(const SetHint *a, const SetHint *b)
1328 {
1329         return strcmp(a->name, b->name);
1330 }
1331
1332 static int
1333 RowsHintCmp(const RowsHint *a, const RowsHint *b)
1334 {
1335         int     i;
1336
1337         if (a->nrels != b->nrels)
1338                 return a->nrels - b->nrels;
1339
1340         for (i = 0; i < a->nrels; i++)
1341         {
1342                 int     result;
1343                 if ((result = RelnameCmp(&a->relnames[i], &b->relnames[i])) != 0)
1344                         return result;
1345         }
1346
1347         return 0;
1348 }
1349
1350 static int
1351 ParallelHintCmp(const ParallelHint *a, const ParallelHint *b)
1352 {
1353         return RelnameCmp(&a->relname, &b->relname);
1354 }
1355
1356 static int
1357 HintCmp(const void *a, const void *b)
1358 {
1359         const Hint *hinta = *((const Hint **) a);
1360         const Hint *hintb = *((const Hint **) b);
1361
1362         if (hinta->type != hintb->type)
1363                 return hinta->type - hintb->type;
1364         if (hinta->state == HINT_STATE_ERROR)
1365                 return -1;
1366         if (hintb->state == HINT_STATE_ERROR)
1367                 return 1;
1368         return hinta->cmp_func(hinta, hintb);
1369 }
1370
1371 /*
1372  * Returns byte offset of hint b from hint a.  If hint a was specified before
1373  * b, positive value is returned.
1374  */
1375 static int
1376 HintCmpWithPos(const void *a, const void *b)
1377 {
1378         const Hint *hinta = *((const Hint **) a);
1379         const Hint *hintb = *((const Hint **) b);
1380         int             result;
1381
1382         result = HintCmp(a, b);
1383         if (result == 0)
1384                 result = hinta->hint_str - hintb->hint_str;
1385
1386         return result;
1387 }
1388
1389 /*
1390  * parse functions
1391  */
1392 static const char *
1393 parse_keyword(const char *str, StringInfo buf)
1394 {
1395         skip_space(str);
1396
1397         while (!isspace(*str) && *str != '(' && *str != '\0')
1398                 appendStringInfoCharMacro(buf, *str++);
1399
1400         return str;
1401 }
1402
1403 static const char *
1404 skip_parenthesis(const char *str, char parenthesis)
1405 {
1406         skip_space(str);
1407
1408         if (*str != parenthesis)
1409         {
1410                 if (parenthesis == '(')
1411                         hint_ereport(str, ("Opening parenthesis is necessary."));
1412                 else if (parenthesis == ')')
1413                         hint_ereport(str, ("Closing parenthesis is necessary."));
1414
1415                 return NULL;
1416         }
1417
1418         str++;
1419
1420         return str;
1421 }
1422
1423 /*
1424  * Parse a token from str, and store malloc'd copy into word.  A token can be
1425  * quoted with '"'.  Return value is pointer to unparsed portion of original
1426  * string, or NULL if an error occurred.
1427  *
1428  * Parsed token is truncated within NAMEDATALEN-1 bytes, when truncate is true.
1429  */
1430 static const char *
1431 parse_quoted_value(const char *str, char **word, bool truncate)
1432 {
1433         StringInfoData  buf;
1434         bool                    in_quote;
1435
1436         /* Skip leading spaces. */
1437         skip_space(str);
1438
1439         initStringInfo(&buf);
1440         if (*str == '"')
1441         {
1442                 str++;
1443                 in_quote = true;
1444         }
1445         else
1446                 in_quote = false;
1447
1448         while (true)
1449         {
1450                 if (in_quote)
1451                 {
1452                         /* Double quotation must be closed. */
1453                         if (*str == '\0')
1454                         {
1455                                 pfree(buf.data);
1456                                 hint_ereport(str, ("Unterminated quoted string."));
1457                                 return NULL;
1458                         }
1459
1460                         /*
1461                          * Skip escaped double quotation.
1462                          *
1463                          * We don't allow slash-asterisk and asterisk-slash (delimiters of
1464                          * block comments) to be an object name, so users must specify
1465                          * alias for such object names.
1466                          *
1467                          * Those special names can be allowed if we care escaped slashes
1468                          * and asterisks, but we don't.
1469                          */
1470                         if (*str == '"')
1471                         {
1472                                 str++;
1473                                 if (*str != '"')
1474                                         break;
1475                         }
1476                 }
1477                 else if (isspace(*str) || *str == '(' || *str == ')' || *str == '"' ||
1478                                  *str == '\0')
1479                         break;
1480
1481                 appendStringInfoCharMacro(&buf, *str++);
1482         }
1483
1484         if (buf.len == 0)
1485         {
1486                 hint_ereport(str, ("Zero-length delimited string."));
1487
1488                 pfree(buf.data);
1489
1490                 return NULL;
1491         }
1492
1493         /* Truncate name if it's too long */
1494         if (truncate)
1495                 truncate_identifier(buf.data, strlen(buf.data), true);
1496
1497         *word = buf.data;
1498
1499         return str;
1500 }
1501
1502 static OuterInnerRels *
1503 OuterInnerRelsCreate(char *name, List *outer_inner_list)
1504 {
1505         OuterInnerRels *outer_inner;
1506
1507         outer_inner = palloc(sizeof(OuterInnerRels));
1508         outer_inner->relation = name;
1509         outer_inner->outer_inner_pair = outer_inner_list;
1510
1511         return outer_inner;
1512 }
1513
1514 static const char *
1515 parse_parentheses_Leading_in(const char *str, OuterInnerRels **outer_inner)
1516 {
1517         List   *outer_inner_pair = NIL;
1518
1519         if ((str = skip_parenthesis(str, '(')) == NULL)
1520                 return NULL;
1521
1522         skip_space(str);
1523
1524         /* Store words in parentheses into outer_inner_list. */
1525         while(*str != ')' && *str != '\0')
1526         {
1527                 OuterInnerRels *outer_inner_rels;
1528
1529                 if (*str == '(')
1530                 {
1531                         str = parse_parentheses_Leading_in(str, &outer_inner_rels);
1532                         if (str == NULL)
1533                                 break;
1534                 }
1535                 else
1536                 {
1537                         char   *name;
1538
1539                         if ((str = parse_quoted_value(str, &name, true)) == NULL)
1540                                 break;
1541                         else
1542                                 outer_inner_rels = OuterInnerRelsCreate(name, NIL);
1543                 }
1544
1545                 outer_inner_pair = lappend(outer_inner_pair, outer_inner_rels);
1546                 skip_space(str);
1547         }
1548
1549         if (str == NULL ||
1550                 (str = skip_parenthesis(str, ')')) == NULL)
1551         {
1552                 list_free(outer_inner_pair);
1553                 return NULL;
1554         }
1555
1556         *outer_inner = OuterInnerRelsCreate(NULL, outer_inner_pair);
1557
1558         return str;
1559 }
1560
1561 static const char *
1562 parse_parentheses_Leading(const char *str, List **name_list,
1563         OuterInnerRels **outer_inner)
1564 {
1565         char   *name;
1566         bool    truncate = true;
1567
1568         if ((str = skip_parenthesis(str, '(')) == NULL)
1569                 return NULL;
1570
1571         skip_space(str);
1572         if (*str =='(')
1573         {
1574                 if ((str = parse_parentheses_Leading_in(str, outer_inner)) == NULL)
1575                         return NULL;
1576         }
1577         else
1578         {
1579                 /* Store words in parentheses into name_list. */
1580                 while(*str != ')' && *str != '\0')
1581                 {
1582                         if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
1583                         {
1584                                 list_free(*name_list);
1585                                 return NULL;
1586                         }
1587
1588                         *name_list = lappend(*name_list, name);
1589                         skip_space(str);
1590                 }
1591         }
1592
1593         if ((str = skip_parenthesis(str, ')')) == NULL)
1594                 return NULL;
1595         return str;
1596 }
1597
1598 static const char *
1599 parse_parentheses(const char *str, List **name_list, HintKeyword keyword)
1600 {
1601         char   *name;
1602         bool    truncate = true;
1603
1604         if ((str = skip_parenthesis(str, '(')) == NULL)
1605                 return NULL;
1606
1607         skip_space(str);
1608
1609         /* Store words in parentheses into name_list. */
1610         while(*str != ')' && *str != '\0')
1611         {
1612                 if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
1613                 {
1614                         list_free(*name_list);
1615                         return NULL;
1616                 }
1617
1618                 *name_list = lappend(*name_list, name);
1619                 skip_space(str);
1620
1621                 if (keyword == HINT_KEYWORD_INDEXSCANREGEXP ||
1622                         keyword == HINT_KEYWORD_INDEXONLYSCANREGEXP ||
1623                         keyword == HINT_KEYWORD_BITMAPSCANREGEXP ||
1624                         keyword == HINT_KEYWORD_SET)
1625                 {
1626                         truncate = false;
1627                 }
1628         }
1629
1630         if ((str = skip_parenthesis(str, ')')) == NULL)
1631                 return NULL;
1632         return str;
1633 }
1634
1635 static void
1636 parse_hints(HintState *hstate, Query *parse, const char *str)
1637 {
1638         StringInfoData  buf;
1639         char               *head;
1640
1641         initStringInfo(&buf);
1642         while (*str != '\0')
1643         {
1644                 const HintParser *parser;
1645
1646                 /* in error message, we output the comment including the keyword. */
1647                 head = (char *) str;
1648
1649                 /* parse only the keyword of the hint. */
1650                 resetStringInfo(&buf);
1651                 str = parse_keyword(str, &buf);
1652
1653                 for (parser = parsers; parser->keyword != NULL; parser++)
1654                 {
1655                         char   *keyword = parser->keyword;
1656                         Hint   *hint;
1657
1658                         if (strcasecmp(buf.data, keyword) != 0)
1659                                 continue;
1660
1661                         hint = parser->create_func(head, keyword, parser->hint_keyword);
1662
1663                         /* parser of each hint does parse in a parenthesis. */
1664                         if ((str = hint->parse_func(hint, hstate, parse, str)) == NULL)
1665                         {
1666                                 hint->delete_func(hint);
1667                                 pfree(buf.data);
1668                                 return;
1669                         }
1670
1671                         /*
1672                          * Add hint information into all_hints array.  If we don't have
1673                          * enough space, double the array.
1674                          */
1675                         if (hstate->nall_hints == 0)
1676                         {
1677                                 hstate->max_all_hints = HINT_ARRAY_DEFAULT_INITSIZE;
1678                                 hstate->all_hints = (Hint **)
1679                                         palloc(sizeof(Hint *) * hstate->max_all_hints);
1680                         }
1681                         else if (hstate->nall_hints == hstate->max_all_hints)
1682                         {
1683                                 hstate->max_all_hints *= 2;
1684                                 hstate->all_hints = (Hint **)
1685                                         repalloc(hstate->all_hints,
1686                                                          sizeof(Hint *) * hstate->max_all_hints);
1687                         }
1688
1689                         hstate->all_hints[hstate->nall_hints] = hint;
1690                         hstate->nall_hints++;
1691
1692                         skip_space(str);
1693
1694                         break;
1695                 }
1696
1697                 if (parser->keyword == NULL)
1698                 {
1699                         hint_ereport(head,
1700                                                  ("Unrecognized hint keyword \"%s\".", buf.data));
1701                         pfree(buf.data);
1702                         return;
1703                 }
1704         }
1705
1706         pfree(buf.data);
1707 }
1708
1709
1710 /*
1711  * Get hints from table by client-supplied query string and application name.
1712  */
1713 static const char *
1714 get_hints_from_table(const char *client_query, const char *client_application)
1715 {
1716         const char *search_query =
1717                 "SELECT hints "
1718                 "  FROM hint_plan.hints "
1719                 " WHERE norm_query_string = $1 "
1720                 "   AND ( application_name = $2 "
1721                 "    OR application_name = '' ) "
1722                 " ORDER BY application_name DESC";
1723         static SPIPlanPtr plan = NULL;
1724         char   *hints = NULL;
1725         Oid             argtypes[2] = { TEXTOID, TEXTOID };
1726         Datum   values[2];
1727         bool    nulls[2] = { false, false };
1728         text   *qry;
1729         text   *app;
1730
1731         PG_TRY();
1732         {
1733                 bool snapshot_set = false;
1734
1735                 hint_inhibit_level++;
1736
1737                 if (!ActiveSnapshotSet())
1738                 {
1739                         PushActiveSnapshot(GetTransactionSnapshot());
1740                         snapshot_set = true;
1741                 }
1742
1743                 SPI_connect();
1744
1745                 if (plan == NULL)
1746                 {
1747                         SPIPlanPtr      p;
1748                         p = SPI_prepare(search_query, 2, argtypes);
1749                         plan = SPI_saveplan(p);
1750                         SPI_freeplan(p);
1751                 }
1752
1753                 qry = cstring_to_text(client_query);
1754                 app = cstring_to_text(client_application);
1755                 values[0] = PointerGetDatum(qry);
1756                 values[1] = PointerGetDatum(app);
1757
1758                 SPI_execute_plan(plan, values, nulls, true, 1);
1759
1760                 if (SPI_processed > 0)
1761                 {
1762                         char    *buf;
1763
1764                         hints = SPI_getvalue(SPI_tuptable->vals[0],
1765                                                                  SPI_tuptable->tupdesc, 1);
1766                         /*
1767                          * Here we use SPI_palloc to ensure that hints string is valid even
1768                          * after SPI_finish call.  We can't use simple palloc because it
1769                          * allocates memory in SPI's context and that context is deleted in
1770                          * SPI_finish.
1771                          */
1772                         buf = SPI_palloc(strlen(hints) + 1);
1773                         strcpy(buf, hints);
1774                         hints = buf;
1775                 }
1776
1777                 SPI_finish();
1778
1779                 if (snapshot_set)
1780                         PopActiveSnapshot();
1781
1782                 hint_inhibit_level--;
1783         }
1784         PG_CATCH();
1785         {
1786                 hint_inhibit_level--;
1787                 PG_RE_THROW();
1788         }
1789         PG_END_TRY();
1790
1791         return hints;
1792 }
1793
1794 /*
1795  * Get client-supplied query string. Addtion to that the jumbled query is
1796  * supplied if the caller requested. From the restriction of JumbleQuery, some
1797  * kind of query needs special amendments. Reutrns NULL if the current hint
1798  * string is still valid.
1799  */
1800 static const char *
1801 get_query_string(ParseState *pstate, Query *query, Query **jumblequery)
1802 {
1803         const char *p = debug_query_string;
1804
1805         if (jumblequery != NULL)
1806                 *jumblequery = query;
1807
1808         if (query->commandType == CMD_UTILITY)
1809         {
1810                 Query *target_query = query;
1811
1812                 /* Use the target query if EXPLAIN */
1813                 if (IsA(query->utilityStmt, ExplainStmt))
1814                 {
1815                         ExplainStmt *stmt = (ExplainStmt *)(query->utilityStmt);
1816
1817                         Assert(IsA(stmt->query, Query));
1818                         target_query = (Query *)stmt->query;
1819
1820                         /* strip out the top-level query for further processing */
1821                         if (target_query->commandType == CMD_UTILITY &&
1822                                 target_query->utilityStmt != NULL)
1823                                 target_query = (Query *)target_query->utilityStmt;
1824                 }
1825
1826                 if (IsA(target_query, CreateTableAsStmt))
1827                 {
1828                         /*
1829                          * Use the the body query for CREATE AS. The Query for jumble also
1830                          * replaced with the corresponding one.
1831                          */
1832                         CreateTableAsStmt  *stmt = (CreateTableAsStmt *) target_query;
1833                         PreparedStatement  *entry;
1834                         Query                      *tmp_query;
1835
1836                         Assert(IsA(stmt->query, Query));
1837                         tmp_query = (Query *) stmt->query;
1838
1839                         if (tmp_query->commandType == CMD_UTILITY &&
1840                                 IsA(tmp_query->utilityStmt, ExecuteStmt))
1841                         {
1842                                 ExecuteStmt *estmt = (ExecuteStmt *) tmp_query->utilityStmt;
1843                                 entry = FetchPreparedStatement(estmt->name, true);
1844                                 p = entry->plansource->query_string;
1845                                 target_query = (Query *) linitial (entry->plansource->query_list);
1846                         }
1847                 }
1848                 else
1849                 if (IsA(target_query, ExecuteStmt))
1850                 {
1851                         /*
1852                          * Use the prepared query for EXECUTE. The Query for jumble also
1853                          * replaced with the corresponding one.
1854                          */
1855                         ExecuteStmt *stmt = (ExecuteStmt *)target_query;
1856                         PreparedStatement  *entry;
1857
1858                         entry = FetchPreparedStatement(stmt->name, true);
1859                         p = entry->plansource->query_string;
1860                         target_query = (Query *) linitial (entry->plansource->query_list);
1861                 }
1862
1863                 /* We don't accept other than a Query other than a CMD_UTILITY */
1864                 if (!IsA(target_query, Query) ||
1865                         target_query->commandType == CMD_UTILITY)
1866                         target_query = NULL;
1867
1868                 if (jumblequery)
1869                         *jumblequery = target_query;
1870         }
1871         /* Return NULL if the pstate is not identical to the top-level query */
1872         else if (strcmp(pstate->p_sourcetext, p) != 0)
1873                 p = NULL;
1874
1875         return p;
1876 }
1877
1878 /*
1879  * Get hints from the head block comment in client-supplied query string.
1880  */
1881 static const char *
1882 get_hints_from_comment(const char *p)
1883 {
1884         const char *hint_head;
1885         char       *head;
1886         char       *tail;
1887         int                     len;
1888
1889         if (p == NULL)
1890                 return NULL;
1891
1892         /* extract query head comment. */
1893         hint_head = strstr(p, HINT_START);
1894         if (hint_head == NULL)
1895                 return NULL;
1896         for (;p < hint_head; p++)
1897         {
1898                 /*
1899                  * Allow these characters precedes hint comment:
1900                  *   - digits
1901                  *   - alphabets which are in ASCII range
1902                  *   - space, tabs and new-lines
1903                  *   - underscores, for identifier
1904                  *   - commas, for SELECT clause, EXPLAIN and PREPARE
1905                  *   - parentheses, for EXPLAIN and PREPARE
1906                  *
1907                  * Note that we don't use isalpha() nor isalnum() in ctype.h here to
1908                  * avoid behavior which depends on locale setting.
1909                  */
1910                 if (!(*p >= '0' && *p <= '9') &&
1911                         !(*p >= 'A' && *p <= 'Z') &&
1912                         !(*p >= 'a' && *p <= 'z') &&
1913                         !isspace(*p) &&
1914                         *p != '_' &&
1915                         *p != ',' &&
1916                         *p != '(' && *p != ')')
1917                         return NULL;
1918         }
1919
1920         len = strlen(HINT_START);
1921         head = (char *) p;
1922         p += len;
1923         skip_space(p);
1924
1925         /* find hint end keyword. */
1926         if ((tail = strstr(p, HINT_END)) == NULL)
1927         {
1928                 hint_ereport(head, ("Unterminated block comment."));
1929                 return NULL;
1930         }
1931
1932         /* We don't support nested block comments. */
1933         if ((head = strstr(p, BLOCK_COMMENT_START)) != NULL && head < tail)
1934         {
1935                 hint_ereport(head, ("Nested block comments are not supported."));
1936                 return NULL;
1937         }
1938
1939         /* Make a copy of hint. */
1940         len = tail - p;
1941         head = palloc(len + 1);
1942         memcpy(head, p, len);
1943         head[len] = '\0';
1944         p = head;
1945
1946         return p;
1947 }
1948
1949 /*
1950  * Parse hints that got, create hint struct from parse tree and parse hints.
1951  */
1952 static HintState *
1953 create_hintstate(Query *parse, const char *hints)
1954 {
1955         const char *p;
1956         int                     i;
1957         HintState   *hstate;
1958
1959         if (hints == NULL)
1960                 return NULL;
1961
1962         /* -1 means that no Parallel hint is specified. */
1963         max_hint_nworkers = -1;
1964
1965         p = hints;
1966         hstate = HintStateCreate();
1967         hstate->hint_str = (char *) hints;
1968
1969         /* parse each hint. */
1970         parse_hints(hstate, parse, p);
1971
1972         /* When nothing specified a hint, we free HintState and returns NULL. */
1973         if (hstate->nall_hints == 0)
1974         {
1975                 HintStateDelete(hstate);
1976                 return NULL;
1977         }
1978
1979         /* Sort hints in order of original position. */
1980         qsort(hstate->all_hints, hstate->nall_hints, sizeof(Hint *),
1981                   HintCmpWithPos);
1982
1983         /* Count number of hints per hint-type. */
1984         for (i = 0; i < hstate->nall_hints; i++)
1985         {
1986                 Hint   *cur_hint = hstate->all_hints[i];
1987                 hstate->num_hints[cur_hint->type]++;
1988         }
1989
1990         /*
1991          * If an object (or a set of objects) has multiple hints of same hint-type,
1992          * only the last hint is valid and others are ignored in planning.
1993          * Hints except the last are marked as 'duplicated' to remember the order.
1994          */
1995         for (i = 0; i < hstate->nall_hints - 1; i++)
1996         {
1997                 Hint   *cur_hint = hstate->all_hints[i];
1998                 Hint   *next_hint = hstate->all_hints[i + 1];
1999
2000                 /*
2001                  * Leading hint is marked as 'duplicated' in transform_join_hints.
2002                  */
2003                 if (cur_hint->type == HINT_TYPE_LEADING &&
2004                         next_hint->type == HINT_TYPE_LEADING)
2005                         continue;
2006
2007                 /*
2008                  * Note that we need to pass addresses of hint pointers, because
2009                  * HintCmp is designed to sort array of Hint* by qsort.
2010                  */
2011                 if (HintCmp(&cur_hint, &next_hint) == 0)
2012                 {
2013                         hint_ereport(cur_hint->hint_str,
2014                                                  ("Conflict %s hint.", HintTypeName[cur_hint->type]));
2015                         cur_hint->state = HINT_STATE_DUPLICATION;
2016                 }
2017         }
2018
2019         /*
2020          * Make sure that per-type array pointers point proper position in the
2021          * array which consists of all hints.
2022          */
2023         hstate->scan_hints = (ScanMethodHint **) hstate->all_hints;
2024         hstate->join_hints = (JoinMethodHint **) (hstate->scan_hints +
2025                 hstate->num_hints[HINT_TYPE_SCAN_METHOD]);
2026         hstate->leading_hint = (LeadingHint **) (hstate->join_hints +
2027                 hstate->num_hints[HINT_TYPE_JOIN_METHOD]);
2028         hstate->set_hints = (SetHint **) (hstate->leading_hint +
2029                 hstate->num_hints[HINT_TYPE_LEADING]);
2030         hstate->rows_hints = (RowsHint **) (hstate->set_hints +
2031                 hstate->num_hints[HINT_TYPE_SET]);
2032         hstate->parallel_hints = (ParallelHint **) (hstate->set_hints +
2033                 hstate->num_hints[HINT_TYPE_ROWS]);
2034
2035         return hstate;
2036 }
2037
2038 /*
2039  * Parse inside of parentheses of scan-method hints.
2040  */
2041 static const char *
2042 ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
2043                                         const char *str)
2044 {
2045         const char         *keyword = hint->base.keyword;
2046         HintKeyword             hint_keyword = hint->base.hint_keyword;
2047         List               *name_list = NIL;
2048         int                             length;
2049
2050         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
2051                 return NULL;
2052
2053         /* Parse relation name and index name(s) if given hint accepts. */
2054         length = list_length(name_list);
2055
2056         /* at least twp parameters required */
2057         if (length < 1)
2058         {
2059                 hint_ereport(str,
2060                                          ("%s hint requires a relation.",  hint->base.keyword));
2061                 hint->base.state = HINT_STATE_ERROR;
2062                 return str;
2063         }
2064
2065         hint->relname = linitial(name_list);
2066         hint->indexnames = list_delete_first(name_list);
2067
2068         /* check whether the hint accepts index name(s) */
2069         if (length > 1 && !SCAN_HINT_ACCEPTS_INDEX_NAMES(hint_keyword))
2070         {
2071                 hint_ereport(str,
2072                                          ("%s hint accepts only one relation.",
2073                                           hint->base.keyword));
2074                 hint->base.state = HINT_STATE_ERROR;
2075                 return str;
2076         }
2077
2078         /* Set a bit for specified hint. */
2079         switch (hint_keyword)
2080         {
2081                 case HINT_KEYWORD_SEQSCAN:
2082                         hint->enforce_mask = ENABLE_SEQSCAN;
2083                         break;
2084                 case HINT_KEYWORD_INDEXSCAN:
2085                         hint->enforce_mask = ENABLE_INDEXSCAN;
2086                         break;
2087                 case HINT_KEYWORD_INDEXSCANREGEXP:
2088                         hint->enforce_mask = ENABLE_INDEXSCAN;
2089                         hint->regexp = true;
2090                         break;
2091                 case HINT_KEYWORD_BITMAPSCAN:
2092                         hint->enforce_mask = ENABLE_BITMAPSCAN;
2093                         break;
2094                 case HINT_KEYWORD_BITMAPSCANREGEXP:
2095                         hint->enforce_mask = ENABLE_BITMAPSCAN;
2096                         hint->regexp = true;
2097                         break;
2098                 case HINT_KEYWORD_TIDSCAN:
2099                         hint->enforce_mask = ENABLE_TIDSCAN;
2100                         break;
2101                 case HINT_KEYWORD_NOSEQSCAN:
2102                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_SEQSCAN;
2103                         break;
2104                 case HINT_KEYWORD_NOINDEXSCAN:
2105                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXSCAN;
2106                         break;
2107                 case HINT_KEYWORD_NOBITMAPSCAN:
2108                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_BITMAPSCAN;
2109                         break;
2110                 case HINT_KEYWORD_NOTIDSCAN:
2111                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_TIDSCAN;
2112                         break;
2113                 case HINT_KEYWORD_INDEXONLYSCAN:
2114                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
2115                         break;
2116                 case HINT_KEYWORD_INDEXONLYSCANREGEXP:
2117                         hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
2118                         hint->regexp = true;
2119                         break;
2120                 case HINT_KEYWORD_NOINDEXONLYSCAN:
2121                         hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXONLYSCAN;
2122                         break;
2123                 default:
2124                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
2125                         return NULL;
2126                         break;
2127         }
2128
2129         return str;
2130 }
2131
2132 static const char *
2133 JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate, Query *parse,
2134                                         const char *str)
2135 {
2136         const char         *keyword = hint->base.keyword;
2137         HintKeyword             hint_keyword = hint->base.hint_keyword;
2138         List               *name_list = NIL;
2139
2140         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
2141                 return NULL;
2142
2143         hint->nrels = list_length(name_list);
2144
2145         if (hint->nrels > 0)
2146         {
2147                 ListCell   *l;
2148                 int                     i = 0;
2149
2150                 /*
2151                  * Transform relation names from list to array to sort them with qsort
2152                  * after.
2153                  */
2154                 hint->relnames = palloc(sizeof(char *) * hint->nrels);
2155                 foreach (l, name_list)
2156                 {
2157                         hint->relnames[i] = lfirst(l);
2158                         i++;
2159                 }
2160         }
2161
2162         list_free(name_list);
2163
2164         /* A join hint requires at least two relations */
2165         if (hint->nrels < 2)
2166         {
2167                 hint_ereport(str,
2168                                          ("%s hint requires at least two relations.",
2169                                           hint->base.keyword));
2170                 hint->base.state = HINT_STATE_ERROR;
2171                 return str;
2172         }
2173
2174         /* Sort hints in alphabetical order of relation names. */
2175         qsort(hint->relnames, hint->nrels, sizeof(char *), RelnameCmp);
2176
2177         switch (hint_keyword)
2178         {
2179                 case HINT_KEYWORD_NESTLOOP:
2180                         hint->enforce_mask = ENABLE_NESTLOOP;
2181                         break;
2182                 case HINT_KEYWORD_MERGEJOIN:
2183                         hint->enforce_mask = ENABLE_MERGEJOIN;
2184                         break;
2185                 case HINT_KEYWORD_HASHJOIN:
2186                         hint->enforce_mask = ENABLE_HASHJOIN;
2187                         break;
2188                 case HINT_KEYWORD_NONESTLOOP:
2189                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_NESTLOOP;
2190                         break;
2191                 case HINT_KEYWORD_NOMERGEJOIN:
2192                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_MERGEJOIN;
2193                         break;
2194                 case HINT_KEYWORD_NOHASHJOIN:
2195                         hint->enforce_mask = ENABLE_ALL_JOIN ^ ENABLE_HASHJOIN;
2196                         break;
2197                 default:
2198                         hint_ereport(str, ("Unrecognized hint keyword \"%s\".", keyword));
2199                         return NULL;
2200                         break;
2201         }
2202
2203         return str;
2204 }
2205
2206 static bool
2207 OuterInnerPairCheck(OuterInnerRels *outer_inner)
2208 {
2209         ListCell *l;
2210         if (outer_inner->outer_inner_pair == NIL)
2211         {
2212                 if (outer_inner->relation)
2213                         return true;
2214                 else
2215                         return false;
2216         }
2217
2218         if (list_length(outer_inner->outer_inner_pair) == 2)
2219         {
2220                 foreach(l, outer_inner->outer_inner_pair)
2221                 {
2222                         if (!OuterInnerPairCheck(lfirst(l)))
2223                                 return false;
2224                 }
2225         }
2226         else
2227                 return false;
2228
2229         return true;
2230 }
2231
2232 static List *
2233 OuterInnerList(OuterInnerRels *outer_inner)
2234 {
2235         List               *outer_inner_list = NIL;
2236         ListCell           *l;
2237         OuterInnerRels *outer_inner_rels;
2238
2239         foreach(l, outer_inner->outer_inner_pair)
2240         {
2241                 outer_inner_rels = (OuterInnerRels *)(lfirst(l));
2242
2243                 if (outer_inner_rels->relation != NULL)
2244                         outer_inner_list = lappend(outer_inner_list,
2245                                                                            outer_inner_rels->relation);
2246                 else
2247                         outer_inner_list = list_concat(outer_inner_list,
2248                                                                                    OuterInnerList(outer_inner_rels));
2249         }
2250         return outer_inner_list;
2251 }
2252
2253 static const char *
2254 LeadingHintParse(LeadingHint *hint, HintState *hstate, Query *parse,
2255                                  const char *str)
2256 {
2257         List               *name_list = NIL;
2258         OuterInnerRels *outer_inner = NULL;
2259
2260         if ((str = parse_parentheses_Leading(str, &name_list, &outer_inner)) ==
2261                 NULL)
2262                 return NULL;
2263
2264         if (outer_inner != NULL)
2265                 name_list = OuterInnerList(outer_inner);
2266
2267         hint->relations = name_list;
2268         hint->outer_inner = outer_inner;
2269
2270         /* A Leading hint requires at least two relations */
2271         if ( hint->outer_inner == NULL && list_length(hint->relations) < 2)
2272         {
2273                 hint_ereport(hint->base.hint_str,
2274                                          ("%s hint requires at least two relations.",
2275                                           HINT_LEADING));
2276                 hint->base.state = HINT_STATE_ERROR;
2277         }
2278         else if (hint->outer_inner != NULL &&
2279                          !OuterInnerPairCheck(hint->outer_inner))
2280         {
2281                 hint_ereport(hint->base.hint_str,
2282                                          ("%s hint requires two sets of relations when parentheses nests.",
2283                                           HINT_LEADING));
2284                 hint->base.state = HINT_STATE_ERROR;
2285         }
2286
2287         return str;
2288 }
2289
2290 static const char *
2291 SetHintParse(SetHint *hint, HintState *hstate, Query *parse, const char *str)
2292 {
2293         List   *name_list = NIL;
2294
2295         if ((str = parse_parentheses(str, &name_list, hint->base.hint_keyword))
2296                 == NULL)
2297                 return NULL;
2298
2299         hint->words = name_list;
2300
2301         /* We need both name and value to set GUC parameter. */
2302         if (list_length(name_list) == 2)
2303         {
2304                 hint->name = linitial(name_list);
2305                 hint->value = lsecond(name_list);
2306         }
2307         else
2308         {
2309                 hint_ereport(hint->base.hint_str,
2310                                          ("%s hint requires name and value of GUC parameter.",
2311                                           HINT_SET));
2312                 hint->base.state = HINT_STATE_ERROR;
2313         }
2314
2315         return str;
2316 }
2317
2318 static const char *
2319 RowsHintParse(RowsHint *hint, HintState *hstate, Query *parse,
2320                           const char *str)
2321 {
2322         HintKeyword             hint_keyword = hint->base.hint_keyword;
2323         List               *name_list = NIL;
2324         char               *rows_str;
2325         char               *end_ptr;
2326
2327         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
2328                 return NULL;
2329
2330         /* Last element must be rows specification */
2331         hint->nrels = list_length(name_list) - 1;
2332
2333         if (hint->nrels > 0)
2334         {
2335                 ListCell   *l;
2336                 int                     i = 0;
2337
2338                 /*
2339                  * Transform relation names from list to array to sort them with qsort
2340                  * after.
2341                  */
2342                 hint->relnames = palloc(sizeof(char *) * hint->nrels);
2343                 foreach (l, name_list)
2344                 {
2345                         if (hint->nrels <= i)
2346                                 break;
2347                         hint->relnames[i] = lfirst(l);
2348                         i++;
2349                 }
2350         }
2351
2352         /* Retieve rows estimation */
2353         rows_str = list_nth(name_list, hint->nrels);
2354         hint->rows_str = rows_str;              /* store as-is for error logging */
2355         if (rows_str[0] == '#')
2356         {
2357                 hint->value_type = RVT_ABSOLUTE;
2358                 rows_str++;
2359         }
2360         else if (rows_str[0] == '+')
2361         {
2362                 hint->value_type = RVT_ADD;
2363                 rows_str++;
2364         }
2365         else if (rows_str[0] == '-')
2366         {
2367                 hint->value_type = RVT_SUB;
2368                 rows_str++;
2369         }
2370         else if (rows_str[0] == '*')
2371         {
2372                 hint->value_type = RVT_MULTI;
2373                 rows_str++;
2374         }
2375         else
2376         {
2377                 hint_ereport(rows_str, ("Unrecognized rows value type notation."));
2378                 hint->base.state = HINT_STATE_ERROR;
2379                 return str;
2380         }
2381         hint->rows = strtod(rows_str, &end_ptr);
2382         if (*end_ptr)
2383         {
2384                 hint_ereport(rows_str,
2385                                          ("%s hint requires valid number as rows estimation.",
2386                                           hint->base.keyword));
2387                 hint->base.state = HINT_STATE_ERROR;
2388                 return str;
2389         }
2390
2391         /* A join hint requires at least two relations */
2392         if (hint->nrels < 2)
2393         {
2394                 hint_ereport(str,
2395                                          ("%s hint requires at least two relations.",
2396                                           hint->base.keyword));
2397                 hint->base.state = HINT_STATE_ERROR;
2398                 return str;
2399         }
2400
2401         list_free(name_list);
2402
2403         /* Sort relnames in alphabetical order. */
2404         qsort(hint->relnames, hint->nrels, sizeof(char *), RelnameCmp);
2405
2406         return str;
2407 }
2408
2409 static const char *
2410 ParallelHintParse(ParallelHint *hint, HintState *hstate, Query *parse,
2411                                   const char *str)
2412 {
2413         HintKeyword             hint_keyword = hint->base.hint_keyword;
2414         List               *name_list = NIL;
2415         int                             length;
2416         char   *end_ptr;
2417         int             nworkers;
2418         bool    force_parallel = false;
2419
2420         if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
2421                 return NULL;
2422
2423         /* Parse relation name and index name(s) if given hint accepts. */
2424         length = list_length(name_list);
2425
2426         if (length < 2 || length > 3)
2427         {
2428                 hint_ereport(")",
2429                                          ("wrong number of arguments (%d): %s",
2430                                           length,  hint->base.keyword));
2431                 hint->base.state = HINT_STATE_ERROR;
2432                 return str;
2433         }
2434
2435         hint->relname = linitial(name_list);
2436
2437         /* The second parameter is number of workers */
2438         hint->nworkers_str = list_nth(name_list, 1);
2439         nworkers = strtod(hint->nworkers_str, &end_ptr);
2440         if (*end_ptr || nworkers < 0 || nworkers > max_worker_processes)
2441         {
2442                 if (*end_ptr)
2443                         hint_ereport(hint->nworkers_str,
2444                                                  ("number of workers must be a number: %s",
2445                                                   hint->base.keyword));
2446                 else if (nworkers < 0)
2447                         hint_ereport(hint->nworkers_str,
2448                                                  ("number of workers must be positive: %s",
2449                                                   hint->base.keyword));
2450                 else if (nworkers > max_worker_processes)
2451                         hint_ereport(hint->nworkers_str,
2452                                                  ("number of workers = %d is larger than max_worker_processes(%d): %s",
2453                                                   nworkers, max_worker_processes, hint->base.keyword));
2454
2455                 hint->base.state = HINT_STATE_ERROR;
2456         }
2457
2458         hint->nworkers = nworkers;
2459
2460         /* optional third parameter is specified */
2461         if (length == 3)
2462         {
2463                 const char *modeparam = (const char *)list_nth(name_list, 2);
2464                 if (strcasecmp(modeparam, "hard") == 0)
2465                         force_parallel = true;
2466                 else if (strcasecmp(modeparam, "soft") != 0)
2467                 {
2468                         hint_ereport(modeparam,
2469                                                  ("enforcement must be soft or hard: %s",
2470                                                          hint->base.keyword));
2471                         hint->base.state = HINT_STATE_ERROR;
2472                 }
2473         }
2474
2475         hint->force_parallel = force_parallel;
2476
2477         if (hint->base.state != HINT_STATE_ERROR &&
2478                 nworkers > max_hint_nworkers)
2479                 max_hint_nworkers = nworkers;
2480
2481         return str;
2482 }
2483
2484 /*
2485  * set GUC parameter functions
2486  */
2487
2488 static int
2489 get_current_scan_mask()
2490 {
2491         int mask = 0;
2492
2493         if (enable_seqscan)
2494                 mask |= ENABLE_SEQSCAN;
2495         if (enable_indexscan)
2496                 mask |= ENABLE_INDEXSCAN;
2497         if (enable_bitmapscan)
2498                 mask |= ENABLE_BITMAPSCAN;
2499         if (enable_tidscan)
2500                 mask |= ENABLE_TIDSCAN;
2501         if (enable_indexonlyscan)
2502                 mask |= ENABLE_INDEXONLYSCAN;
2503
2504         return mask;
2505 }
2506
2507 static int
2508 get_current_join_mask()
2509 {
2510         int mask = 0;
2511
2512         if (enable_nestloop)
2513                 mask |= ENABLE_NESTLOOP;
2514         if (enable_mergejoin)
2515                 mask |= ENABLE_MERGEJOIN;
2516         if (enable_hashjoin)
2517                 mask |= ENABLE_HASHJOIN;
2518
2519         return mask;
2520 }
2521
2522 /*
2523  * Sets GUC prameters without throwing exception. Reutrns false if something
2524  * wrong.
2525  */
2526 static int
2527 set_config_option_noerror(const char *name, const char *value,
2528                                                   GucContext context, GucSource source,
2529                                                   GucAction action, bool changeVal, int elevel)
2530 {
2531         int                             result = 0;
2532         MemoryContext   ccxt = CurrentMemoryContext;
2533
2534         PG_TRY();
2535         {
2536                 result = set_config_option(name, value, context, source,
2537                                                                    action, changeVal, 0, false);
2538         }
2539         PG_CATCH();
2540         {
2541                 ErrorData          *errdata;
2542
2543                 /* Save error info */
2544                 MemoryContextSwitchTo(ccxt);
2545                 errdata = CopyErrorData();
2546                 FlushErrorState();
2547
2548                 ereport(elevel,
2549                                 (errcode(errdata->sqlerrcode),
2550                                  errmsg("%s", errdata->message),
2551                                  errdata->detail ? errdetail("%s", errdata->detail) : 0,
2552                                  errdata->hint ? errhint("%s", errdata->hint) : 0));
2553                 msgqno = qno;
2554                 FreeErrorData(errdata);
2555         }
2556         PG_END_TRY();
2557
2558         return result;
2559 }
2560
2561 /*
2562  * Sets GUC parameter of int32 type without throwing exceptions. Returns false
2563  * if something wrong.
2564  */
2565 static int
2566 set_config_int32_option(const char *name, int32 value, GucContext context)
2567 {
2568         char buf[16];   /* enough for int32 */
2569
2570         if (snprintf(buf, 16, "%d", value) < 0)
2571         {
2572                 ereport(pg_hint_plan_message_level,
2573                                 (errmsg ("Cannot set integer value: %d: %s",
2574                                                  max_hint_nworkers, strerror(errno))));
2575                 return false;
2576         }
2577
2578         return
2579                 set_config_option_noerror(name, buf, context,
2580                                                                   PGC_S_SESSION, GUC_ACTION_SAVE, true,
2581                                                                   pg_hint_plan_message_level);
2582 }
2583
2584 /* setup scan method enforcement according to given options */
2585 static void
2586 setup_guc_enforcement(SetHint **options, int noptions, GucContext context)
2587 {
2588         int     i;
2589
2590         for (i = 0; i < noptions; i++)
2591         {
2592                 SetHint    *hint = options[i];
2593                 int                     result;
2594
2595                 if (!hint_state_enabled(hint))
2596                         continue;
2597
2598                 result = set_config_option_noerror(hint->name, hint->value, context,
2599                                                                                    PGC_S_SESSION, GUC_ACTION_SAVE, true,
2600                                                                                    pg_hint_plan_message_level);
2601                 if (result != 0)
2602                         hint->base.state = HINT_STATE_USED;
2603                 else
2604                         hint->base.state = HINT_STATE_ERROR;
2605         }
2606
2607         return;
2608 }
2609
2610 /*
2611  * Setup parallel execution environment.
2612  *
2613  * If hint is not NULL, set up using it, elsewise reset to initial environment.
2614  */
2615 static void
2616 setup_parallel_plan_enforcement(ParallelHint *hint, HintState *state)
2617 {
2618         if (hint)
2619         {
2620                 hint->base.state = HINT_STATE_USED;
2621                 set_config_int32_option("max_parallel_workers_per_gather",
2622                                                                 hint->nworkers, state->context);
2623         }
2624         else
2625                 set_config_int32_option("max_parallel_workers_per_gather",
2626                                                                 state->init_nworkers, state->context);
2627
2628         /* force means that enforce parallel as far as possible */
2629         if (hint && hint->force_parallel)
2630         {
2631                 set_config_int32_option("parallel_tuple_cost", 0, state->context);
2632                 set_config_int32_option("parallel_setup_cost", 0, state->context);
2633                 set_config_int32_option("min_parallel_table_scan_size", 0,
2634                                                                 state->context);
2635                 set_config_int32_option("min_parallel_index_scan_size", 0,
2636                                                                 state->context);
2637         }
2638         else
2639         {
2640                 set_config_int32_option("parallel_tuple_cost",
2641                                                                 state->init_paratup_cost, state->context);
2642                 set_config_int32_option("parallel_setup_cost",
2643                                                                 state->init_parasetup_cost, state->context);
2644                 set_config_int32_option("min_parallel_table_scan_size",
2645                                                                 state->init_min_para_tablescan_size,
2646                                                                 state->context);
2647                 set_config_int32_option("min_parallel_index_scan_size",
2648                                                                 state->init_min_para_indexscan_size,
2649                                                                 state->context);
2650         }
2651 }
2652
2653 #define SET_CONFIG_OPTION(name, type_bits) \
2654         set_config_option_noerror((name), \
2655                 (mask & (type_bits)) ? "true" : "false", \
2656                 context, PGC_S_SESSION, GUC_ACTION_SAVE, true, ERROR)
2657
2658
2659 /*
2660  * Setup GUC environment to enforce scan methods. If scanhint is NULL, reset
2661  * GUCs to the saved state in state.
2662  */
2663 static void
2664 setup_scan_method_enforcement(ScanMethodHint *scanhint, HintState *state)
2665 {
2666         unsigned char   enforce_mask = state->init_scan_mask;
2667         GucContext              context = state->context;
2668         unsigned char   mask;
2669
2670         if (scanhint)
2671         {
2672                 enforce_mask = scanhint->enforce_mask;
2673                 scanhint->base.state = HINT_STATE_USED;
2674         }
2675
2676         if (enforce_mask == ENABLE_SEQSCAN || enforce_mask == ENABLE_INDEXSCAN ||
2677                 enforce_mask == ENABLE_BITMAPSCAN || enforce_mask == ENABLE_TIDSCAN
2678                 || enforce_mask == (ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN)
2679                 )
2680                 mask = enforce_mask;
2681         else
2682                 mask = enforce_mask & current_hint_state->init_scan_mask;
2683
2684         SET_CONFIG_OPTION("enable_seqscan", ENABLE_SEQSCAN);
2685         SET_CONFIG_OPTION("enable_indexscan", ENABLE_INDEXSCAN);
2686         SET_CONFIG_OPTION("enable_bitmapscan", ENABLE_BITMAPSCAN);
2687         SET_CONFIG_OPTION("enable_tidscan", ENABLE_TIDSCAN);
2688         SET_CONFIG_OPTION("enable_indexonlyscan", ENABLE_INDEXONLYSCAN);
2689 }
2690
2691 static void
2692 set_join_config_options(unsigned char enforce_mask, GucContext context)
2693 {
2694         unsigned char   mask;
2695
2696         if (enforce_mask == ENABLE_NESTLOOP || enforce_mask == ENABLE_MERGEJOIN ||
2697                 enforce_mask == ENABLE_HASHJOIN)
2698                 mask = enforce_mask;
2699         else
2700                 mask = enforce_mask & current_hint_state->init_join_mask;
2701
2702         SET_CONFIG_OPTION("enable_nestloop", ENABLE_NESTLOOP);
2703         SET_CONFIG_OPTION("enable_mergejoin", ENABLE_MERGEJOIN);
2704         SET_CONFIG_OPTION("enable_hashjoin", ENABLE_HASHJOIN);
2705 }
2706
2707 /*
2708  * Push a hint into hint stack which is implemented with List struct.  Head of
2709  * list is top of stack.
2710  */
2711 static void
2712 push_hint(HintState *hstate)
2713 {
2714         /* Prepend new hint to the list means pushing to stack. */
2715         HintStateStack = lcons(hstate, HintStateStack);
2716
2717         /* Pushed hint is the one which should be used hereafter. */
2718         current_hint_state = hstate;
2719 }
2720
2721 /* Pop a hint from hint stack.  Popped hint is automatically discarded. */
2722 static void
2723 pop_hint(void)
2724 {
2725         /* Hint stack must not be empty. */
2726         if(HintStateStack == NIL)
2727                 elog(ERROR, "hint stack is empty");
2728
2729         /*
2730          * Take a hint at the head from the list, and free it.  Switch
2731          * current_hint_state to point new head (NULL if the list is empty).
2732          */
2733         HintStateStack = list_delete_first(HintStateStack);
2734         HintStateDelete(current_hint_state);
2735         if(HintStateStack == NIL)
2736                 current_hint_state = NULL;
2737         else
2738                 current_hint_state = (HintState *) lfirst(list_head(HintStateStack));
2739 }
2740
2741 /*
2742  * Retrieve and store a hint string from given query or from the hint table.
2743  * If we are using the hint table, the query string is needed to be normalized.
2744  * However, ParseState, which is not available in planner_hook, is required to
2745  * check if the query tree (Query) is surely corresponding to the target query.
2746  */
2747 static void
2748 pg_hint_plan_post_parse_analyze(ParseState *pstate, Query *query)
2749 {
2750         const char *query_str;
2751         MemoryContext   oldcontext;
2752
2753         if (prev_post_parse_analyze_hook)
2754                 prev_post_parse_analyze_hook(pstate, query);
2755
2756         /* do nothing under hint table search */
2757         if (hint_inhibit_level > 0)
2758                 return;
2759
2760         if (!pg_hint_plan_enable_hint)
2761         {
2762                 if (current_hint_str)
2763                 {
2764                         pfree((void *)current_hint_str);
2765                         current_hint_str = NULL;
2766                 }
2767                 return;
2768         }
2769
2770         /* increment the query number */
2771         qnostr[0] = 0;
2772         if (debug_level > 1)
2773                 snprintf(qnostr, sizeof(qnostr), "[qno=0x%x]", qno++);
2774         qno++;
2775
2776         /* search the hint table for a hint if requested */
2777         if (pg_hint_plan_enable_hint_table)
2778         {
2779                 int                             query_len;
2780                 pgssJumbleState jstate;
2781                 Query              *jumblequery;
2782                 char               *normalized_query = NULL;
2783
2784                 query_str = get_query_string(pstate, query, &jumblequery);
2785
2786                 /* If this query is not for hint, just return */
2787                 if (!query_str)
2788                         return;
2789
2790                 /* clear the previous hint string */
2791                 if (current_hint_str)
2792                 {
2793                         pfree((void *)current_hint_str);
2794                         current_hint_str = NULL;
2795                 }
2796
2797                 if (jumblequery)
2798                 {
2799                         /*
2800                          * XXX: normalizing code is copied from pg_stat_statements.c, so be
2801                          * careful to PostgreSQL's version up.
2802                          */
2803                         jstate.jumble = (unsigned char *) palloc(JUMBLE_SIZE);
2804                         jstate.jumble_len = 0;
2805                         jstate.clocations_buf_size = 32;
2806                         jstate.clocations = (pgssLocationLen *)
2807                                 palloc(jstate.clocations_buf_size * sizeof(pgssLocationLen));
2808                         jstate.clocations_count = 0;
2809
2810                         JumbleQuery(&jstate, jumblequery);
2811
2812                         /*
2813                          * Normalize the query string by replacing constants with '?'
2814                          */
2815                         /*
2816                          * Search hint string which is stored keyed by query string
2817                          * and application name.  The query string is normalized to allow
2818                          * fuzzy matching.
2819                          *
2820                          * Adding 1 byte to query_len ensures that the returned string has
2821                          * a terminating NULL.
2822                          */
2823                         query_len = strlen(query_str) + 1;
2824                         normalized_query =
2825                                 generate_normalized_query(&jstate, query_str,
2826                                                                                   &query_len,
2827                                                                                   GetDatabaseEncoding());
2828
2829                         /*
2830                          * find a hint for the normalized query. the result should be in
2831                          * TopMemoryContext
2832                          */
2833                         oldcontext = MemoryContextSwitchTo(TopMemoryContext);
2834                         current_hint_str =
2835                                 get_hints_from_table(normalized_query, application_name);
2836                         MemoryContextSwitchTo(oldcontext);
2837
2838                         if (debug_level > 1)
2839                         {
2840                                 if (current_hint_str)
2841                                         ereport(pg_hint_plan_message_level,
2842                                                         (errmsg("pg_hint_plan[qno=0x%x]: "
2843                                                                         "post_parse_analyze_hook: "
2844                                                                         "hints from table: \"%s\": "
2845                                                                         "normalized_query=\"%s\", "
2846                                                                         "application name =\"%s\"",
2847                                                                         qno, current_hint_str,
2848                                                                         normalized_query, application_name),
2849                                                          errhidestmt(msgqno != qno),
2850                                                          errhidecontext(msgqno != qno)));
2851                                 else
2852                                         ereport(pg_hint_plan_message_level,
2853                                                         (errmsg("pg_hint_plan[qno=0x%x]: "
2854                                                                         "no match found in table:  "
2855                                                                         "application name = \"%s\", "
2856                                                                         "normalized_query=\"%s\"",
2857                                                                         qno, application_name,
2858                                                                         normalized_query),
2859                                                          errhidestmt(msgqno != qno),
2860                                                          errhidecontext(msgqno != qno)));
2861
2862                                 msgqno = qno;
2863                         }
2864                 }
2865
2866                 /* retrun if we have hint here*/
2867                 if (current_hint_str)
2868                         return;
2869         }
2870         else
2871                 query_str = get_query_string(pstate, query, NULL);
2872
2873         if (query_str)
2874         {
2875                 /*
2876                  * get hints from the comment. However we may have the same query
2877                  * string with the previous call, but just retrieving hints is expected
2878                  * to be faster than checking for identicalness before retrieval.
2879                  */
2880                 if (current_hint_str)
2881                         pfree((void *)current_hint_str);
2882
2883                 oldcontext = MemoryContextSwitchTo(TopMemoryContext);
2884                 current_hint_str = get_hints_from_comment(query_str);
2885                 MemoryContextSwitchTo(oldcontext);
2886         }
2887
2888         if (debug_level > 1)
2889         {
2890                 if (debug_level == 1 &&
2891                         (stmt_name || strcmp(query_str, debug_query_string)))
2892                         ereport(pg_hint_plan_message_level,
2893                                         (errmsg("hints in comment=\"%s\"",
2894                                                         current_hint_str ? current_hint_str : "(none)"),
2895                                          errhidestmt(msgqno != qno),
2896                                          errhidecontext(msgqno != qno)));
2897                 else
2898                         ereport(pg_hint_plan_message_level,
2899                                         (errmsg("hints in comment=\"%s\", stmt=\"%s\", query=\"%s\", debug_query_string=\"%s\"",
2900                                                         current_hint_str ? current_hint_str : "(none)",
2901                                                         stmt_name, query_str, debug_query_string),
2902                                          errhidestmt(msgqno != qno),
2903                                          errhidecontext(msgqno != qno)));
2904                 msgqno = qno;
2905         }
2906 }
2907
2908 /*
2909  * Read and set up hint information
2910  */
2911 static PlannedStmt *
2912 pg_hint_plan_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
2913 {
2914         int                             save_nestlevel;
2915         PlannedStmt        *result;
2916         HintState          *hstate;
2917
2918         /*
2919          * Use standard planner if pg_hint_plan is disabled or current nesting
2920          * depth is nesting depth of SPI calls. Other hook functions try to change
2921          * plan with current_hint_state if any, so set it to NULL.
2922          */
2923         if (!pg_hint_plan_enable_hint || hint_inhibit_level > 0)
2924         {
2925                 if (debug_level > 1)
2926                         ereport(pg_hint_plan_message_level,
2927                                         (errmsg ("pg_hint_plan%s: planner: enable_hint=%d,"
2928                                                          " hint_inhibit_level=%d",
2929                                                          qnostr, pg_hint_plan_enable_hint,
2930                                                          hint_inhibit_level),
2931                                          errhidestmt(msgqno != qno)));
2932                 msgqno = qno;
2933
2934                 goto standard_planner_proc;
2935         }
2936
2937         /*
2938          * Support for nested plpgsql functions. This is quite ugly but this is the
2939          * only point I could find where I can get the query string.
2940          */
2941         if (plpgsql_recurse_level > 0)
2942         {
2943                 MemoryContext oldcontext;
2944
2945                 if (current_hint_str)
2946                         pfree((void *)current_hint_str);
2947
2948                 oldcontext = MemoryContextSwitchTo(TopMemoryContext);
2949                 current_hint_str =
2950                         get_hints_from_comment((char *)error_context_stack->arg);
2951                 MemoryContextSwitchTo(oldcontext);
2952         }
2953
2954         if (!current_hint_str)
2955                 goto standard_planner_proc;
2956
2957         /* parse the hint into hint state struct */
2958         hstate = create_hintstate(parse, pstrdup(current_hint_str));
2959
2960         /* run standard planner if the statement has not valid hint */
2961         if (!hstate)
2962                 goto standard_planner_proc;
2963
2964         /*
2965          * Push new hint struct to the hint stack to disable previous hint context.
2966          */
2967         push_hint(hstate);
2968
2969         /*  Set scan enforcement here. */
2970         save_nestlevel = NewGUCNestLevel();
2971
2972         /* Apply Set hints, then save it as the initial state  */
2973         setup_guc_enforcement(current_hint_state->set_hints,
2974                                                    current_hint_state->num_hints[HINT_TYPE_SET],
2975                                                    current_hint_state->context);
2976
2977         current_hint_state->init_scan_mask = get_current_scan_mask();
2978         current_hint_state->init_join_mask = get_current_join_mask();
2979         current_hint_state->init_min_para_tablescan_size =
2980                 min_parallel_table_scan_size;
2981         current_hint_state->init_min_para_indexscan_size =
2982                 min_parallel_index_scan_size;
2983         current_hint_state->init_paratup_cost = parallel_tuple_cost;
2984         current_hint_state->init_parasetup_cost = parallel_setup_cost;
2985
2986         /*
2987          * max_parallel_workers_per_gather should be non-zero here if Workers hint
2988          * is specified.
2989          */
2990         if (max_hint_nworkers > 0 && max_parallel_workers_per_gather < 1)
2991                 set_config_int32_option("max_parallel_workers_per_gather",
2992                                                                 1, current_hint_state->context);
2993         current_hint_state->init_nworkers = max_parallel_workers_per_gather;
2994
2995         if (debug_level > 1)
2996         {
2997                 ereport(pg_hint_plan_message_level,
2998                                 (errhidestmt(msgqno != qno),
2999                                  errmsg("pg_hint_plan%s: planner", qnostr)));
3000                 msgqno = qno;
3001         }
3002
3003         /*
3004          * Use PG_TRY mechanism to recover GUC parameters and current_hint_state to
3005          * the state when this planner started when error occurred in planner.
3006          */
3007         PG_TRY();
3008         {
3009                 if (prev_planner)
3010                         result = (*prev_planner) (parse, cursorOptions, boundParams);
3011                 else
3012                         result = standard_planner(parse, cursorOptions, boundParams);
3013         }
3014         PG_CATCH();
3015         {
3016                 /*
3017                  * Rollback changes of GUC parameters, and pop current hint context
3018                  * from hint stack to rewind the state.
3019                  */
3020                 AtEOXact_GUC(true, save_nestlevel);
3021                 pop_hint();
3022                 PG_RE_THROW();
3023         }
3024         PG_END_TRY();
3025
3026         /* Print hint in debug mode. */
3027         if (debug_level == 1)
3028                 HintStateDump(current_hint_state);
3029         else if (debug_level > 1)
3030                 HintStateDump2(current_hint_state);
3031
3032         /*
3033          * Rollback changes of GUC parameters, and pop current hint context from
3034          * hint stack to rewind the state.
3035          */
3036         AtEOXact_GUC(true, save_nestlevel);
3037         pop_hint();
3038
3039         return result;
3040
3041 standard_planner_proc:
3042         if (debug_level > 1)
3043         {
3044                 ereport(pg_hint_plan_message_level,
3045                                 (errhidestmt(msgqno != qno),
3046                                  errmsg("pg_hint_plan%s: planner: no valid hint",
3047                                                 qnostr)));
3048                 msgqno = qno;
3049         }
3050         current_hint_state = NULL;
3051         if (prev_planner)
3052                 return (*prev_planner) (parse, cursorOptions, boundParams);
3053         else
3054                 return standard_planner(parse, cursorOptions, boundParams);
3055 }
3056
3057 /*
3058  * Find scan method hint to be applied to the given relation
3059  *
3060  */
3061 static ScanMethodHint *
3062 find_scan_hint(PlannerInfo *root, Index relid)
3063 {
3064         RelOptInfo         *rel;
3065         RangeTblEntry  *rte;
3066         ScanMethodHint  *real_name_hint = NULL;
3067         ScanMethodHint  *alias_hint = NULL;
3068         int                             i;
3069
3070         /* This should not be a join rel */
3071         Assert(relid > 0);
3072         rel = root->simple_rel_array[relid];
3073
3074         /*
3075          * This function is called for any RelOptInfo or its inheritance parent if
3076          * any. If we are called from inheritance planner, the RelOptInfo for the
3077          * parent of target child relation is not set in the planner info.
3078          *
3079          * Otherwise we should check that the reloptinfo is base relation or
3080          * inheritance children.
3081          */
3082         if (rel &&
3083                 rel->reloptkind != RELOPT_BASEREL &&
3084                 rel->reloptkind != RELOPT_OTHER_MEMBER_REL)
3085                 return NULL;
3086
3087         /*
3088          * This is baserel or appendrel children. We can refer to RangeTblEntry.
3089          */
3090         rte = root->simple_rte_array[relid];
3091         Assert(rte);
3092
3093         /* We don't hint on other than relation and foreign tables */
3094         if (rte->rtekind != RTE_RELATION ||
3095                 rte->relkind == RELKIND_FOREIGN_TABLE)
3096                 return NULL;
3097
3098         /* Find scan method hint, which matches given names, from the list. */
3099         for (i = 0; i < current_hint_state->num_hints[HINT_TYPE_SCAN_METHOD]; i++)
3100         {
3101                 ScanMethodHint *hint = current_hint_state->scan_hints[i];
3102
3103                 /* We ignore disabled hints. */
3104                 if (!hint_state_enabled(hint))
3105                         continue;
3106
3107                 if (!alias_hint &&
3108                         RelnameCmp(&rte->eref->aliasname, &hint->relname) == 0)
3109                         alias_hint = hint;
3110
3111                 /* check the real name for appendrel children */
3112                 if (!real_name_hint &&
3113                         rel && rel->reloptkind == RELOPT_OTHER_MEMBER_REL)
3114                 {
3115                         char *realname = get_rel_name(rte->relid);
3116
3117                         if (realname && RelnameCmp(&realname, &hint->relname) == 0)
3118                                 real_name_hint = hint;
3119                 }
3120
3121                 /* No more match expected, break  */
3122                 if(alias_hint && real_name_hint)
3123                         break;
3124         }
3125
3126         /* real name match precedes alias match */
3127         if (real_name_hint)
3128                 return real_name_hint;
3129
3130         return alias_hint;
3131 }
3132
3133 static ParallelHint *
3134 find_parallel_hint(PlannerInfo *root, Index relid)
3135 {
3136         RelOptInfo         *rel;
3137         RangeTblEntry  *rte;
3138         ParallelHint    *real_name_hint = NULL;
3139         ParallelHint    *alias_hint = NULL;
3140         int                             i;
3141
3142         /* This should not be a join rel */
3143         Assert(relid > 0);
3144         rel = root->simple_rel_array[relid];
3145
3146         /*
3147          * Parallel planning is appliable only on base relation, which has
3148          * RelOptInfo.
3149          */
3150         if (!rel)
3151                 return NULL;
3152
3153         /*
3154          * We have set root->glob->parallelModeOK if needed. What we should do here
3155          * is just following the decision of planner.
3156          */
3157         if (!rel->consider_parallel)
3158                 return NULL;
3159
3160         /*
3161          * This is baserel or appendrel children. We can refer to RangeTblEntry.
3162          */
3163         rte = root->simple_rte_array[relid];
3164         Assert(rte);
3165
3166         /* Find parallel method hint, which matches given names, from the list. */
3167         for (i = 0; i < current_hint_state->num_hints[HINT_TYPE_PARALLEL]; i++)
3168         {
3169                 ParallelHint *hint = current_hint_state->parallel_hints[i];
3170
3171                 /* We ignore disabled hints. */
3172                 if (!hint_state_enabled(hint))
3173                         continue;
3174
3175                 if (!alias_hint &&
3176                         RelnameCmp(&rte->eref->aliasname, &hint->relname) == 0)
3177                         alias_hint = hint;
3178
3179                 /* check the real name for appendrel children */
3180                 if (!real_name_hint &&
3181                         rel && rel->reloptkind == RELOPT_OTHER_MEMBER_REL)
3182                 {
3183                         char *realname = get_rel_name(rte->relid);
3184
3185                         if (realname && RelnameCmp(&realname, &hint->relname) == 0)
3186                                 real_name_hint = hint;
3187                 }
3188
3189                 /* No more match expected, break  */
3190                 if(alias_hint && real_name_hint)
3191                         break;
3192         }
3193
3194         /* real name match precedes alias match */
3195         if (real_name_hint)
3196                 return real_name_hint;
3197
3198         return alias_hint;
3199 }
3200
3201 /*
3202  * regexeq
3203  *
3204  * Returns TRUE on match, FALSE on no match.
3205  *
3206  *   s1 --- the data to match against
3207  *   s2 --- the pattern
3208  *
3209  * Because we copy s1 to NameData, make the size of s1 less than NAMEDATALEN.
3210  */
3211 static bool
3212 regexpeq(const char *s1, const char *s2)
3213 {
3214         NameData        name;
3215         text       *regexp;
3216         Datum           result;
3217
3218         strcpy(name.data, s1);
3219         regexp = cstring_to_text(s2);
3220
3221         result = DirectFunctionCall2Coll(nameregexeq,
3222                                                                          DEFAULT_COLLATION_OID,
3223                                                                          NameGetDatum(&name),
3224                                                                          PointerGetDatum(regexp));
3225         return DatumGetBool(result);
3226 }
3227
3228
3229 /* Remove indexes instructed not to use by hint. */
3230 static void
3231 restrict_indexes(PlannerInfo *root, ScanMethodHint *hint, RelOptInfo *rel,
3232                            bool using_parent_hint)
3233 {
3234         ListCell           *cell;
3235         ListCell           *prev;
3236         ListCell           *next;
3237         StringInfoData  buf;
3238         RangeTblEntry  *rte = root->simple_rte_array[rel->relid];
3239         Oid                             relationObjectId = rte->relid;
3240
3241         /*
3242          * We delete all the IndexOptInfo list and prevent you from being usable by
3243          * a scan.
3244          */
3245         if (hint->enforce_mask == ENABLE_SEQSCAN ||
3246                 hint->enforce_mask == ENABLE_TIDSCAN)
3247         {
3248                 list_free_deep(rel->indexlist);
3249                 rel->indexlist = NIL;
3250                 hint->base.state = HINT_STATE_USED;
3251
3252                 return;
3253         }
3254
3255         /*
3256          * When a list of indexes is not specified, we just use all indexes.
3257          */
3258         if (hint->indexnames == NIL)
3259                 return;
3260
3261         /*
3262          * Leaving only an specified index, we delete it from a IndexOptInfo list
3263          * other than it.
3264          */
3265         prev = NULL;
3266         if (debug_level > 0)
3267                 initStringInfo(&buf);
3268
3269         for (cell = list_head(rel->indexlist); cell; cell = next)
3270         {
3271                 IndexOptInfo   *info = (IndexOptInfo *) lfirst(cell);
3272                 char               *indexname = get_rel_name(info->indexoid);
3273                 ListCell           *l;
3274                 bool                    use_index = false;
3275
3276                 next = lnext(cell);
3277
3278                 foreach(l, hint->indexnames)
3279                 {
3280                         char   *hintname = (char *) lfirst(l);
3281                         bool    result;
3282
3283                         if (hint->regexp)
3284                                 result = regexpeq(indexname, hintname);
3285                         else
3286                                 result = RelnameCmp(&indexname, &hintname) == 0;
3287
3288                         if (result)
3289                         {
3290                                 use_index = true;
3291                                 if (debug_level > 0)
3292                                 {
3293                                         appendStringInfoCharMacro(&buf, ' ');
3294                                         quote_value(&buf, indexname);
3295                                 }
3296
3297                                 break;
3298                         }
3299                 }
3300
3301                 /*
3302                  * Apply index restriction of parent hint to children. Since index
3303                  * inheritance is not explicitly described we should search for an
3304                  * children's index with the same definition to that of the parent.
3305                  */
3306                 if (using_parent_hint && !use_index)
3307                 {
3308                         foreach(l, current_hint_state->parent_index_infos)
3309                         {
3310                                 int                                     i;
3311                                 HeapTuple                       ht_idx;
3312                                 ParentIndexInfo    *p_info = (ParentIndexInfo *)lfirst(l);
3313
3314                                 /*
3315                                  * we check the 'same' index by comparing uniqueness, access
3316                                  * method and index key columns.
3317                                  */
3318                                 if (p_info->indisunique != info->unique ||
3319                                         p_info->method != info->relam ||
3320                                         list_length(p_info->column_names) != info->ncolumns)
3321                                         continue;
3322
3323                                 /* Check if index key columns match */
3324                                 for (i = 0; i < info->ncolumns; i++)
3325                                 {
3326                                         char       *c_attname = NULL;
3327                                         char       *p_attname = NULL;
3328
3329                                         p_attname = list_nth(p_info->column_names, i);
3330
3331                                         /*
3332                                          * if both of the key of the same position are expressions,
3333                                          * ignore them for now and check later.
3334                                          */
3335                                         if (info->indexkeys[i] == 0 && !p_attname)
3336                                                 continue;
3337
3338                                         /* deny if one is expression while another is not */
3339                                         if (info->indexkeys[i] == 0 || !p_attname)
3340                                                 break;
3341
3342                                         c_attname = get_attname(relationObjectId,
3343                                                                                                 info->indexkeys[i]);
3344
3345                                         /* deny if any of column attributes don't match */
3346                                         if (strcmp(p_attname, c_attname) != 0 ||
3347                                                 p_info->indcollation[i] != info->indexcollations[i] ||
3348                                                 p_info->opclass[i] != info->opcintype[i]||
3349                                                 ((p_info->indoption[i] & INDOPTION_DESC) != 0)
3350                                                 != info->reverse_sort[i] ||
3351                                                 ((p_info->indoption[i] & INDOPTION_NULLS_FIRST) != 0)
3352                                                 != info->nulls_first[i])
3353                                                 break;
3354                                 }
3355
3356                                 /* deny this if any difference found */
3357                                 if (i != info->ncolumns)
3358                                         continue;
3359
3360                                 /* check on key expressions  */
3361                                 if ((p_info->expression_str && (info->indexprs != NIL)) ||
3362                                         (p_info->indpred_str && (info->indpred != NIL)))
3363                                 {
3364                                         /* fetch the index of this child */
3365                                         ht_idx = SearchSysCache1(INDEXRELID,
3366                                                                                          ObjectIdGetDatum(info->indexoid));
3367
3368                                         /* check expressions if both expressions are available */
3369                                         if (p_info->expression_str &&
3370                                                 !heap_attisnull(ht_idx, Anum_pg_index_indexprs))
3371                                         {
3372                                                 Datum       exprsDatum;
3373                                                 bool        isnull;
3374                                                 Datum       result;
3375
3376                                                 /*
3377                                                  * to change the expression's parameter of child's
3378                                                  * index to strings
3379                                                  */
3380                                                 exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
3381                                                                                                          Anum_pg_index_indexprs,
3382                                                                                                          &isnull);
3383
3384                                                 result = DirectFunctionCall2(pg_get_expr,
3385                                                                                                          exprsDatum,
3386                                                                                                          ObjectIdGetDatum(
3387                                                                                                                  relationObjectId));
3388
3389                                                 /* deny if expressions don't match */
3390                                                 if (strcmp(p_info->expression_str,
3391                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
3392                                                 {
3393                                                         /* Clean up */
3394                                                         ReleaseSysCache(ht_idx);
3395                                                         continue;
3396                                                 }
3397                                         }
3398
3399                                         /* compare index predicates  */
3400                                         if (p_info->indpred_str &&
3401                                                 !heap_attisnull(ht_idx, Anum_pg_index_indpred))
3402                                         {
3403                                                 Datum       predDatum;
3404                                                 bool        isnull;
3405                                                 Datum       result;
3406
3407                                                 predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
3408                                                                                                          Anum_pg_index_indpred,
3409                                                                                                          &isnull);
3410
3411                                                 result = DirectFunctionCall2(pg_get_expr,
3412                                                                                                          predDatum,
3413                                                                                                          ObjectIdGetDatum(
3414                                                                                                                  relationObjectId));
3415
3416                                                 if (strcmp(p_info->indpred_str,
3417                                                                    text_to_cstring(DatumGetTextP(result))) != 0)
3418                                                 {
3419                                                         /* Clean up */
3420                                                         ReleaseSysCache(ht_idx);
3421                                                         continue;
3422                                                 }
3423                                         }
3424
3425                                         /* Clean up */
3426                                         ReleaseSysCache(ht_idx);
3427                                 }
3428                                 else if (p_info->expression_str || (info->indexprs != NIL))
3429                                         continue;
3430                                 else if (p_info->indpred_str || (info->indpred != NIL))
3431                                         continue;
3432
3433                                 use_index = true;
3434
3435                                 /* to log the candidate of index */
3436                                 if (debug_level > 0)
3437                                 {
3438                                         appendStringInfoCharMacro(&buf, ' ');
3439                                         quote_value(&buf, indexname);
3440                                 }
3441
3442                                 break;
3443                         }
3444                 }
3445
3446                 if (!use_index)
3447                         rel->indexlist = list_delete_cell(rel->indexlist, cell, prev);
3448                 else
3449                         prev = cell;
3450
3451                 pfree(indexname);
3452         }
3453
3454         if (debug_level == 1)
3455         {
3456                 StringInfoData  rel_buf;
3457                 char *disprelname = "";
3458
3459                 /*
3460                  * If this hint targetted the parent, use the real name of this
3461                  * child. Otherwise use hint specification.
3462                  */
3463                 if (using_parent_hint)
3464                         disprelname = get_rel_name(rte->relid);
3465                 else
3466                         disprelname = hint->relname;
3467
3468
3469                 initStringInfo(&rel_buf);
3470                 quote_value(&rel_buf, disprelname);
3471
3472                 ereport(LOG,
3473                                 (errmsg("available indexes for %s(%s):%s",
3474                                          hint->base.keyword,
3475                                          rel_buf.data,
3476                                          buf.data)));
3477                 pfree(buf.data);
3478                 pfree(rel_buf.data);
3479         }
3480 }
3481
3482 /*
3483  * Return information of index definition.
3484  */
3485 static ParentIndexInfo *
3486 get_parent_index_info(Oid indexoid, Oid relid)
3487 {
3488         ParentIndexInfo *p_info = palloc(sizeof(ParentIndexInfo));
3489         Relation            indexRelation;
3490         Form_pg_index   index;
3491         char               *attname;
3492         int                             i;
3493
3494         indexRelation = index_open(indexoid, RowExclusiveLock);
3495
3496         index = indexRelation->rd_index;
3497
3498         p_info->indisunique = index->indisunique;
3499         p_info->method = indexRelation->rd_rel->relam;
3500
3501         p_info->column_names = NIL;
3502         p_info->indcollation = (Oid *) palloc(sizeof(Oid) * index->indnatts);
3503         p_info->opclass = (Oid *) palloc(sizeof(Oid) * index->indnatts);
3504         p_info->indoption = (int16 *) palloc(sizeof(Oid) * index->indnatts);
3505
3506         for (i = 0; i < index->indnatts; i++)
3507         {
3508                 attname = get_attname(relid, index->indkey.values[i]);
3509                 p_info->column_names = lappend(p_info->column_names, attname);
3510
3511                 p_info->indcollation[i] = indexRelation->rd_indcollation[i];
3512                 p_info->opclass[i] = indexRelation->rd_opcintype[i];
3513                 p_info->indoption[i] = indexRelation->rd_indoption[i];
3514         }
3515
3516         /*
3517          * to check to match the expression's parameter of index with child indexes
3518          */
3519         p_info->expression_str = NULL;
3520         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indexprs))
3521         {
3522                 Datum       exprsDatum;
3523                 bool            isnull;
3524                 Datum           result;
3525
3526                 exprsDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
3527                                                                          Anum_pg_index_indexprs, &isnull);
3528
3529                 result = DirectFunctionCall2(pg_get_expr,
3530                                                                          exprsDatum,
3531                                                                          ObjectIdGetDatum(relid));
3532
3533                 p_info->expression_str = text_to_cstring(DatumGetTextP(result));
3534         }
3535
3536         /*
3537          * to check to match the predicate's parameter of index with child indexes
3538          */
3539         p_info->indpred_str = NULL;
3540         if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indpred))
3541         {
3542                 Datum       predDatum;
3543                 bool            isnull;
3544                 Datum           result;
3545
3546                 predDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
3547                                                                          Anum_pg_index_indpred, &isnull);
3548
3549                 result = DirectFunctionCall2(pg_get_expr,
3550                                                                          predDatum,
3551                                                                          ObjectIdGetDatum(relid));
3552
3553                 p_info->indpred_str = text_to_cstring(DatumGetTextP(result));
3554         }
3555
3556         index_close(indexRelation, NoLock);
3557
3558         return p_info;
3559 }
3560
3561 /*
3562  * cancel hint enforcement
3563  */
3564 static void
3565 reset_hint_enforcement()
3566 {
3567         setup_scan_method_enforcement(NULL, current_hint_state);
3568         setup_parallel_plan_enforcement(NULL, current_hint_state);
3569 }
3570
3571 /*
3572  * Set planner guc parameters according to corresponding scan hints.  Returns
3573  * bitmap of HintTypeBitmap. If shint or phint is not NULL, set used hint
3574  * there respectively.
3575  */
3576 static bool
3577 setup_hint_enforcement(PlannerInfo *root, RelOptInfo *rel,
3578                                            ScanMethodHint **rshint, ParallelHint **rphint)
3579 {
3580         Index   new_parent_relid = 0;
3581         ListCell *l;
3582         ScanMethodHint *shint = NULL;
3583         ParallelHint   *phint = NULL;
3584         bool                    inhparent = root->simple_rte_array[rel->relid]->inh;
3585         Oid             relationObjectId = root->simple_rte_array[rel->relid]->relid;
3586         int                             ret = 0;
3587
3588         /* reset returns if requested  */
3589         if (rshint != NULL) *rshint = NULL;
3590         if (rphint != NULL) *rphint = NULL;
3591
3592         /*
3593          * We could register the parent relation of the following children here
3594          * when inhparent == true but inheritnce planner doesn't call this function
3595          * for parents. Since we cannot distinguish who called this function we
3596          * cannot do other than always seeking the parent regardless of who called
3597          * this function.
3598          */
3599         if (inhparent)
3600         {
3601                 if (debug_level > 1)
3602                         ereport(pg_hint_plan_message_level,
3603                                         (errhidestmt(true),
3604                                          errmsg ("pg_hint_plan%s: setup_hint_enforcement"
3605                                                          " skipping inh parent: relation=%u(%s), inhparent=%d,"
3606                                                          " current_hint_state=%p, hint_inhibit_level=%d",
3607                                                          qnostr, relationObjectId,
3608                                                          get_rel_name(relationObjectId),
3609                                                          inhparent, current_hint_state, hint_inhibit_level)));
3610                 return 0;
3611         }
3612
3613         /* Find the parent for this relation other than the registered parent */
3614         foreach (l, root->append_rel_list)
3615         {
3616                 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
3617
3618                 if (appinfo->child_relid == rel->relid)
3619                 {
3620                         if (current_hint_state->parent_relid != appinfo->parent_relid)
3621                                 new_parent_relid = appinfo->parent_relid;
3622                         break;
3623                 }
3624         }
3625
3626         if (!l)
3627         {
3628                 /* This relation doesn't have a parent. Cancel current_hint_state. */
3629                 current_hint_state->parent_relid = 0;
3630                 current_hint_state->parent_scan_hint = NULL;
3631                 current_hint_state->parent_parallel_hint = NULL;
3632         }
3633
3634         if (new_parent_relid > 0)
3635         {
3636                 /*
3637                  * Here we found a new parent for the current relation. Scan continues
3638                  * hint to other childrens of this parent so remember it * to avoid
3639                  * hinthintredundant setup cost.
3640                  */
3641                 current_hint_state->parent_relid = new_parent_relid;
3642
3643                 /* Find hints for the parent */
3644                 current_hint_state->parent_scan_hint =
3645                         find_scan_hint(root, current_hint_state->parent_relid);
3646
3647                 current_hint_state->parent_parallel_hint =
3648                         find_parallel_hint(root, current_hint_state->parent_relid);
3649
3650                 /*
3651                  * If hint is found for the parent, apply it for this child instead
3652                  * of its own.
3653                  */
3654                 if (current_hint_state->parent_scan_hint)
3655                 {
3656                         ScanMethodHint * pshint = current_hint_state->parent_scan_hint;
3657
3658                         pshint->base.state = HINT_STATE_USED;
3659
3660                         /* Apply index mask in the same manner to the parent. */
3661                         if (pshint->indexnames)
3662                         {
3663                                 Oid                     parentrel_oid;
3664                                 Relation        parent_rel;
3665
3666                                 parentrel_oid =
3667                                         root->simple_rte_array[current_hint_state->parent_relid]->relid;
3668                                 parent_rel = heap_open(parentrel_oid, NoLock);
3669
3670                                 /* Search the parent relation for indexes match the hint spec */
3671                                 foreach(l, RelationGetIndexList(parent_rel))
3672                                 {
3673                                         Oid         indexoid = lfirst_oid(l);
3674                                         char       *indexname = get_rel_name(indexoid);
3675                                         ListCell   *lc;
3676                                         ParentIndexInfo *parent_index_info;
3677
3678                                         foreach(lc, pshint->indexnames)
3679                                         {
3680                                                 if (RelnameCmp(&indexname, &lfirst(lc)) == 0)
3681                                                         break;
3682                                         }
3683                                         if (!lc)
3684                                                 continue;
3685
3686                                         parent_index_info =
3687                                                 get_parent_index_info(indexoid, parentrel_oid);
3688                                         current_hint_state->parent_index_infos =
3689                                                 lappend(current_hint_state->parent_index_infos,
3690                                                                 parent_index_info);
3691                                 }
3692                                 heap_close(parent_rel, NoLock);
3693                         }
3694                 }
3695         }
3696
3697         shint = find_scan_hint(root, rel->relid);
3698         if (!shint)
3699                 shint = current_hint_state->parent_scan_hint;
3700
3701         if (shint)
3702         {
3703                 bool using_parent_hint =
3704                         (shint == current_hint_state->parent_scan_hint);
3705
3706                 ret |= HINT_BM_SCAN_METHOD;
3707
3708                 /* Setup scan enforcement environment */
3709                 setup_scan_method_enforcement(shint, current_hint_state);
3710
3711                 /* restrict unwanted inexes */
3712                 restrict_indexes(root, shint, rel, using_parent_hint);
3713
3714                 if (debug_level > 1)
3715                 {
3716                         char *additional_message = "";
3717
3718                         if (shint == current_hint_state->parent_scan_hint)
3719                                 additional_message = " by parent hint";
3720
3721                         ereport(pg_hint_plan_message_level,
3722                                         (errhidestmt(true),
3723                                          errmsg ("pg_hint_plan%s: setup_hint_enforcement"
3724                                                          " index deletion%s:"
3725                                                          " relation=%u(%s), inhparent=%d, "
3726                                                          "current_hint_state=%p,"
3727                                                          " hint_inhibit_level=%d, scanmask=0x%x",
3728                                                          qnostr, additional_message,
3729                                                          relationObjectId,
3730                                                          get_rel_name(relationObjectId),
3731                                                          inhparent, current_hint_state,
3732                                                          hint_inhibit_level,
3733                                                          shint->enforce_mask)));
3734                 }
3735         }
3736
3737         /* Do the same for parallel plan enforcement */
3738         phint = find_parallel_hint(root, rel->relid);
3739         if (!phint)
3740                 phint = current_hint_state->parent_parallel_hint;
3741
3742         setup_parallel_plan_enforcement(phint, current_hint_state);
3743
3744         if (phint)
3745                 ret |= HINT_BM_PARALLEL;
3746
3747         /* Nothing to apply. Reset the scan mask to intial state */
3748         if (!shint && ! phint)
3749         {
3750                 if (debug_level > 1)
3751                         ereport(pg_hint_plan_message_level,
3752                                         (errhidestmt (true),
3753                                          errmsg ("pg_hint_plan%s: setup_hint_enforcement"
3754                                                          " no hint applied:"
3755                                                          " relation=%u(%s), inhparent=%d, current_hint=%p,"
3756                                                          " hint_inhibit_level=%d, scanmask=0x%x",
3757                                                          qnostr, relationObjectId,
3758                                                          get_rel_name(relationObjectId),
3759                                                          inhparent, current_hint_state, hint_inhibit_level,
3760                                                          current_hint_state->init_scan_mask)));
3761
3762                 setup_scan_method_enforcement(NULL,     current_hint_state);
3763
3764                 return ret;
3765         }
3766
3767         if (rshint != NULL) *rshint = shint;
3768         if (rphint != NULL) *rphint = phint;
3769
3770         return ret;
3771 }
3772
3773 /*
3774  * Return index of relation which matches given aliasname, or 0 if not found.
3775  * If same aliasname was used multiple times in a query, return -1.
3776  */
3777 static int
3778 find_relid_aliasname(PlannerInfo *root, char *aliasname, List *initial_rels,
3779                                          const char *str)
3780 {
3781         int             i;
3782         Index   found = 0;
3783
3784         for (i = 1; i < root->simple_rel_array_size; i++)
3785         {
3786                 ListCell   *l;
3787
3788                 if (root->simple_rel_array[i] == NULL)
3789                         continue;
3790
3791                 Assert(i == root->simple_rel_array[i]->relid);
3792
3793                 if (RelnameCmp(&aliasname,
3794                                            &root->simple_rte_array[i]->eref->aliasname) != 0)
3795                         continue;
3796
3797                 foreach(l, initial_rels)
3798                 {
3799                         RelOptInfo *rel = (RelOptInfo *) lfirst(l);
3800
3801                         if (rel->reloptkind == RELOPT_BASEREL)
3802                         {
3803                                 if (rel->relid != i)
3804                                         continue;
3805                         }
3806                         else
3807                         {
3808                                 Assert(rel->reloptkind == RELOPT_JOINREL);
3809
3810                                 if (!bms_is_member(i, rel->relids))
3811                                         continue;
3812                         }
3813
3814                         if (found != 0)
3815                         {
3816                                 hint_ereport(str,
3817                                                          ("Relation name \"%s\" is ambiguous.",
3818                                                           aliasname));
3819                                 return -1;
3820                         }
3821
3822                         found = i;
3823                         break;
3824                 }
3825
3826         }
3827
3828         return found;
3829 }
3830
3831 /*
3832  * Return join hint which matches given joinrelids.
3833  */
3834 static JoinMethodHint *
3835 find_join_hint(Relids joinrelids)
3836 {
3837         List       *join_hint;
3838         ListCell   *l;
3839
3840         join_hint = current_hint_state->join_hint_level[bms_num_members(joinrelids)];
3841
3842         foreach(l, join_hint)
3843         {
3844                 JoinMethodHint *hint = (JoinMethodHint *) lfirst(l);
3845
3846                 if (bms_equal(joinrelids, hint->joinrelids))
3847                         return hint;
3848         }
3849
3850         return NULL;
3851 }
3852
3853 static Relids
3854 OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
3855         PlannerInfo *root, List *initial_rels, HintState *hstate, int nbaserel)
3856 {
3857         OuterInnerRels *outer_rels;
3858         OuterInnerRels *inner_rels;
3859         Relids                  outer_relids;
3860         Relids                  inner_relids;
3861         Relids                  join_relids;
3862         JoinMethodHint *hint;
3863
3864         if (outer_inner->relation != NULL)
3865         {
3866                 return bms_make_singleton(
3867                                         find_relid_aliasname(root, outer_inner->relation,
3868                                                                                  initial_rels,
3869                                                                                  leading_hint->base.hint_str));
3870         }
3871
3872         outer_rels = lfirst(outer_inner->outer_inner_pair->head);
3873         inner_rels = lfirst(outer_inner->outer_inner_pair->tail);
3874
3875         outer_relids = OuterInnerJoinCreate(outer_rels,
3876                                                                                 leading_hint,
3877                                                                                 root,
3878                                                                                 initial_rels,
3879                                                                                 hstate,
3880                                                                                 nbaserel);
3881         inner_relids = OuterInnerJoinCreate(inner_rels,
3882                                                                                 leading_hint,
3883                                                                                 root,
3884                                                                                 initial_rels,
3885                                                                                 hstate,
3886                                                                                 nbaserel);
3887
3888         join_relids = bms_add_members(outer_relids, inner_relids);
3889
3890         if (bms_num_members(join_relids) > nbaserel)
3891                 return join_relids;
3892
3893         /*
3894          * If we don't have join method hint, create new one for the
3895          * join combination with all join methods are enabled.
3896          */
3897         hint = find_join_hint(join_relids);
3898         if (hint == NULL)
3899         {
3900                 /*
3901                  * Here relnames is not set, since Relids bitmap is sufficient to
3902                  * control paths of this query afterward.
3903                  */
3904                 hint = (JoinMethodHint *) JoinMethodHintCreate(
3905                                         leading_hint->base.hint_str,
3906                                         HINT_LEADING,
3907                                         HINT_KEYWORD_LEADING);
3908                 hint->base.state = HINT_STATE_USED;
3909                 hint->nrels = bms_num_members(join_relids);
3910                 hint->enforce_mask = ENABLE_ALL_JOIN;
3911                 hint->joinrelids = bms_copy(join_relids);
3912                 hint->inner_nrels = bms_num_members(inner_relids);
3913                 hint->inner_joinrelids = bms_copy(inner_relids);
3914
3915                 hstate->join_hint_level[hint->nrels] =
3916                         lappend(hstate->join_hint_level[hint->nrels], hint);
3917         }
3918         else
3919         {
3920                 hint->inner_nrels = bms_num_members(inner_relids);
3921                 hint->inner_joinrelids = bms_copy(inner_relids);
3922         }
3923
3924         return join_relids;
3925 }
3926
3927 static Relids
3928 create_bms_of_relids(Hint *base, PlannerInfo *root, List *initial_rels,
3929                 int nrels, char **relnames)
3930 {
3931         int             relid;
3932         Relids  relids = NULL;
3933         int             j;
3934         char   *relname;
3935
3936         for (j = 0; j < nrels; j++)
3937         {
3938                 relname = relnames[j];
3939
3940                 relid = find_relid_aliasname(root, relname, initial_rels,
3941                                                                          base->hint_str);
3942
3943                 if (relid == -1)
3944                         base->state = HINT_STATE_ERROR;
3945
3946                 /*
3947                  * the aliasname is not found(relid == 0) or same aliasname was used
3948                  * multiple times in a query(relid == -1)
3949                  */
3950                 if (relid <= 0)
3951                 {
3952                         relids = NULL;
3953                         break;
3954                 }
3955                 if (bms_is_member(relid, relids))
3956                 {
3957                         hint_ereport(base->hint_str,
3958                                                  ("Relation name \"%s\" is duplicated.", relname));
3959                         base->state = HINT_STATE_ERROR;
3960                         break;
3961                 }
3962
3963                 relids = bms_add_member(relids, relid);
3964         }
3965         return relids;
3966 }
3967 /*
3968  * Transform join method hint into handy form.
3969  *
3970  *   - create bitmap of relids from alias names, to make it easier to check
3971  *     whether a join path matches a join method hint.
3972  *   - add join method hints which are necessary to enforce join order
3973  *     specified by Leading hint
3974  */
3975 static bool
3976 transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
3977                 List *initial_rels, JoinMethodHint **join_method_hints)
3978 {
3979         int                             i;
3980         int                             relid;
3981         Relids                  joinrelids;
3982         int                             njoinrels;
3983         ListCell           *l;
3984         char               *relname;
3985         LeadingHint        *lhint = NULL;
3986
3987         /*
3988          * Create bitmap of relids from alias names for each join method hint.
3989          * Bitmaps are more handy than strings in join searching.
3990          */
3991         for (i = 0; i < hstate->num_hints[HINT_TYPE_JOIN_METHOD]; i++)
3992         {
3993                 JoinMethodHint *hint = hstate->join_hints[i];
3994
3995                 if (!hint_state_enabled(hint) || hint->nrels > nbaserel)
3996                         continue;
3997
3998                 hint->joinrelids = create_bms_of_relids(&(hint->base), root,
3999                                                                          initial_rels, hint->nrels, hint->relnames);
4000
4001                 if (hint->joinrelids == NULL || hint->base.state == HINT_STATE_ERROR)
4002                         continue;
4003
4004                 hstate->join_hint_level[hint->nrels] =
4005                         lappend(hstate->join_hint_level[hint->nrels], hint);
4006         }
4007
4008         /*
4009          * Create bitmap of relids from alias names for each rows hint.
4010          * Bitmaps are more handy than strings in join searching.
4011          */
4012         for (i = 0; i < hstate->num_hints[HINT_TYPE_ROWS]; i++)
4013         {
4014                 RowsHint *hint = hstate->rows_hints[i];
4015
4016                 if (!hint_state_enabled(hint) || hint->nrels > nbaserel)
4017                         continue;
4018
4019                 hint->joinrelids = create_bms_of_relids(&(hint->base), root,
4020                                                                          initial_rels, hint->nrels, hint->relnames);
4021         }
4022
4023         /* Do nothing if no Leading hint was supplied. */
4024         if (hstate->num_hints[HINT_TYPE_LEADING] == 0)
4025                 return false;
4026
4027         /*
4028          * Decide whether to use Leading hint
4029          */
4030         for (i = 0; i < hstate->num_hints[HINT_TYPE_LEADING]; i++)
4031         {
4032                 LeadingHint        *leading_hint = (LeadingHint *)hstate->leading_hint[i];
4033                 Relids                  relids;
4034
4035                 if (leading_hint->base.state == HINT_STATE_ERROR)
4036                         continue;
4037
4038                 relid = 0;
4039                 relids = NULL;
4040
4041                 foreach(l, leading_hint->relations)
4042                 {
4043                         relname = (char *)lfirst(l);;
4044
4045                         relid = find_relid_aliasname(root, relname, initial_rels,
4046                                                                                  leading_hint->base.hint_str);
4047                         if (relid == -1)
4048                                 leading_hint->base.state = HINT_STATE_ERROR;
4049
4050                         if (relid <= 0)
4051                                 break;
4052
4053                         if (bms_is_member(relid, relids))
4054                         {
4055                                 hint_ereport(leading_hint->base.hint_str,
4056                                                          ("Relation name \"%s\" is duplicated.", relname));
4057                                 leading_hint->base.state = HINT_STATE_ERROR;
4058                                 break;
4059                         }
4060
4061                         relids = bms_add_member(relids, relid);
4062                 }
4063
4064                 if (relid <= 0 || leading_hint->base.state == HINT_STATE_ERROR)
4065                         continue;
4066
4067                 if (lhint != NULL)
4068                 {
4069                         hint_ereport(lhint->base.hint_str,
4070                                  ("Conflict %s hint.", HintTypeName[lhint->base.type]));
4071                         lhint->base.state = HINT_STATE_DUPLICATION;
4072                 }
4073                 leading_hint->base.state = HINT_STATE_USED;
4074                 lhint = leading_hint;
4075         }
4076
4077         /* check to exist Leading hint marked with 'used'. */
4078         if (lhint == NULL)
4079                 return false;
4080
4081         /*
4082          * We need join method hints which fit specified join order in every join
4083          * level.  For example, Leading(A B C) virtually requires following join
4084          * method hints, if no join method hint supplied:
4085          *   - level 1: none
4086          *   - level 2: NestLoop(A B), MergeJoin(A B), HashJoin(A B)
4087          *   - level 3: NestLoop(A B C), MergeJoin(A B C), HashJoin(A B C)
4088          *
4089          * If we already have join method hint which fits specified join order in
4090          * that join level, we leave it as-is and don't add new hints.
4091          */
4092         joinrelids = NULL;
4093         njoinrels = 0;
4094         if (lhint->outer_inner == NULL)
4095         {
4096                 foreach(l, lhint->relations)
4097                 {
4098                         JoinMethodHint *hint;
4099
4100                         relname = (char *)lfirst(l);
4101
4102                         /*
4103                          * Find relid of the relation which has given name.  If we have the
4104                          * name given in Leading hint multiple times in the join, nothing to
4105                          * do.
4106                          */
4107                         relid = find_relid_aliasname(root, relname, initial_rels,
4108                                                                                  hstate->hint_str);
4109
4110                         /* Create bitmap of relids for current join level. */
4111                         joinrelids = bms_add_member(joinrelids, relid);
4112                         njoinrels++;
4113
4114                         /* We never have join method hint for single relation. */
4115                         if (njoinrels < 2)
4116                                 continue;
4117
4118                         /*
4119                          * If we don't have join method hint, create new one for the
4120                          * join combination with all join methods are enabled.
4121                          */
4122                         hint = find_join_hint(joinrelids);
4123                         if (hint == NULL)
4124                         {
4125                                 /*
4126                                  * Here relnames is not set, since Relids bitmap is sufficient
4127                                  * to control paths of this query afterward.
4128                                  */
4129                                 hint = (JoinMethodHint *) JoinMethodHintCreate(
4130                                                                                         lhint->base.hint_str,
4131                                                                                         HINT_LEADING,
4132                                                                                         HINT_KEYWORD_LEADING);
4133                                 hint->base.state = HINT_STATE_USED;
4134                                 hint->nrels = njoinrels;
4135                                 hint->enforce_mask = ENABLE_ALL_JOIN;
4136                                 hint->joinrelids = bms_copy(joinrelids);
4137                         }
4138
4139                         join_method_hints[njoinrels] = hint;
4140
4141                         if (njoinrels >= nbaserel)
4142                                 break;
4143                 }
4144                 bms_free(joinrelids);
4145
4146                 if (njoinrels < 2)
4147                         return false;
4148
4149                 /*
4150                  * Delete all join hints which have different combination from Leading
4151                  * hint.
4152                  */
4153                 for (i = 2; i <= njoinrels; i++)
4154                 {
4155                         list_free(hstate->join_hint_level[i]);
4156
4157                         hstate->join_hint_level[i] = lappend(NIL, join_method_hints[i]);
4158                 }
4159         }
4160         else
4161         {
4162                 joinrelids = OuterInnerJoinCreate(lhint->outer_inner,
4163                                                                                   lhint,
4164                                           root,
4165                                           initial_rels,
4166                                                                                   hstate,
4167                                                                                   nbaserel);
4168
4169                 njoinrels = bms_num_members(joinrelids);
4170                 Assert(njoinrels >= 2);
4171
4172                 /*
4173                  * Delete all join hints which have different combination from Leading
4174                  * hint.
4175                  */
4176                 for (i = 2;i <= njoinrels; i++)
4177                 {
4178                         if (hstate->join_hint_level[i] != NIL)
4179                         {
4180                                 ListCell *prev = NULL;
4181                                 ListCell *next = NULL;
4182                                 for(l = list_head(hstate->join_hint_level[i]); l; l = next)
4183                                 {
4184
4185                                         JoinMethodHint *hint = (JoinMethodHint *)lfirst(l);
4186
4187                                         next = lnext(l);
4188
4189                                         if (hint->inner_nrels == 0 &&
4190                                                 !(bms_intersect(hint->joinrelids, joinrelids) == NULL ||
4191                                                   bms_equal(bms_union(hint->joinrelids, joinrelids),
4192                                                   hint->joinrelids)))
4193                                         {
4194                                                 hstate->join_hint_level[i] =
4195                                                         list_delete_cell(hstate->join_hint_level[i], l,
4196                                                                                          prev);
4197                                         }
4198                                         else
4199                                                 prev = l;
4200                                 }
4201                         }
4202                 }
4203
4204                 bms_free(joinrelids);
4205         }
4206
4207         if (hint_state_enabled(lhint))
4208         {
4209                 set_join_config_options(DISABLE_ALL_JOIN, current_hint_state->context);
4210                 return true;
4211         }
4212         return false;
4213 }
4214
4215 /*
4216  * wrapper of make_join_rel()
4217  *
4218  * call make_join_rel() after changing enable_* parameters according to given
4219  * hints.
4220  */
4221 static RelOptInfo *
4222 make_join_rel_wrapper(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
4223 {
4224         Relids                  joinrelids;
4225         JoinMethodHint *hint;
4226         RelOptInfo         *rel;
4227         int                             save_nestlevel;
4228
4229         joinrelids = bms_union(rel1->relids, rel2->relids);
4230         hint = find_join_hint(joinrelids);
4231         bms_free(joinrelids);
4232
4233         if (!hint)
4234                 return pg_hint_plan_make_join_rel(root, rel1, rel2);
4235
4236         if (hint->inner_nrels == 0)
4237         {
4238                 save_nestlevel = NewGUCNestLevel();
4239
4240                 set_join_config_options(hint->enforce_mask,
4241                                                                 current_hint_state->context);
4242
4243                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
4244                 hint->base.state = HINT_STATE_USED;
4245
4246                 /*
4247                  * Restore the GUC variables we set above.
4248                  */
4249                 AtEOXact_GUC(true, save_nestlevel);
4250         }
4251         else
4252                 rel = pg_hint_plan_make_join_rel(root, rel1, rel2);
4253
4254         return rel;
4255 }
4256
4257 /*
4258  * TODO : comment
4259  */
4260 static void
4261 add_paths_to_joinrel_wrapper(PlannerInfo *root,
4262                                                          RelOptInfo *joinrel,
4263                                                          RelOptInfo *outerrel,
4264                                                          RelOptInfo *innerrel,
4265                                                          JoinType jointype,
4266                                                          SpecialJoinInfo *sjinfo,
4267                                                          List *restrictlist)
4268 {
4269         Relids                  joinrelids;
4270         JoinMethodHint *join_hint;
4271         int                             save_nestlevel;
4272
4273         joinrelids = bms_union(outerrel->relids, innerrel->relids);
4274         join_hint = find_join_hint(joinrelids);
4275         bms_free(joinrelids);
4276
4277         if (join_hint && join_hint->inner_nrels != 0)
4278         {
4279                 save_nestlevel = NewGUCNestLevel();
4280
4281                 if (bms_equal(join_hint->inner_joinrelids, innerrel->relids))
4282                 {
4283
4284                         set_join_config_options(join_hint->enforce_mask,
4285                                                                         current_hint_state->context);
4286
4287                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
4288                                                                  sjinfo, restrictlist);
4289                         join_hint->base.state = HINT_STATE_USED;
4290                 }
4291                 else
4292                 {
4293                         set_join_config_options(DISABLE_ALL_JOIN,
4294                                                                         current_hint_state->context);
4295                         add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
4296                                                                  sjinfo, restrictlist);
4297                 }
4298
4299                 /*
4300                  * Restore the GUC variables we set above.
4301                  */
4302                 AtEOXact_GUC(true, save_nestlevel);
4303         }
4304         else
4305                 add_paths_to_joinrel(root, joinrel, outerrel, innerrel, jointype,
4306                                                          sjinfo, restrictlist);
4307 }
4308
4309 static int
4310 get_num_baserels(List *initial_rels)
4311 {
4312         int                     nbaserel = 0;
4313         ListCell   *l;
4314
4315         foreach(l, initial_rels)
4316         {
4317                 RelOptInfo *rel = (RelOptInfo *) lfirst(l);
4318
4319                 if (rel->reloptkind == RELOPT_BASEREL)
4320                         nbaserel++;
4321                 else if (rel->reloptkind ==RELOPT_JOINREL)
4322                         nbaserel+= bms_num_members(rel->relids);
4323                 else
4324                 {
4325                         /* other values not expected here */
4326                         elog(ERROR, "unrecognized reloptkind type: %d", rel->reloptkind);
4327                 }
4328         }
4329
4330         return nbaserel;
4331 }
4332
4333 static RelOptInfo *
4334 pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
4335                                                  List *initial_rels)
4336 {
4337         JoinMethodHint    **join_method_hints;
4338         int                                     nbaserel;
4339         RelOptInfo                 *rel;
4340         int                                     i;
4341         bool                            leading_hint_enable;
4342
4343         /*
4344          * Use standard planner (or geqo planner) if pg_hint_plan is disabled or no
4345          * valid hint is supplied or current nesting depth is nesting depth of SPI
4346          * calls.
4347          */
4348         if (!current_hint_state || hint_inhibit_level > 0)
4349         {
4350                 if (prev_join_search)
4351                         return (*prev_join_search) (root, levels_needed, initial_rels);
4352                 else if (enable_geqo && levels_needed >= geqo_threshold)
4353                         return geqo(root, levels_needed, initial_rels);
4354                 else
4355                         return standard_join_search(root, levels_needed, initial_rels);
4356         }
4357
4358         /*
4359          * In the case using GEQO, only scan method hints and Set hints have
4360          * effect.  Join method and join order is not controllable by hints.
4361          */
4362         if (enable_geqo && levels_needed >= geqo_threshold)
4363                 return geqo(root, levels_needed, initial_rels);
4364
4365         nbaserel = get_num_baserels(initial_rels);
4366         current_hint_state->join_hint_level =
4367                 palloc0(sizeof(List *) * (nbaserel + 1));
4368         join_method_hints = palloc0(sizeof(JoinMethodHint *) * (nbaserel + 1));
4369
4370         leading_hint_enable = transform_join_hints(current_hint_state,
4371                                                                                            root, nbaserel,
4372                                                                                            initial_rels, join_method_hints);
4373
4374         rel = pg_hint_plan_standard_join_search(root, levels_needed, initial_rels);
4375
4376         for (i = 2; i <= nbaserel; i++)
4377         {
4378                 list_free(current_hint_state->join_hint_level[i]);
4379
4380                 /* free Leading hint only */
4381                 if (join_method_hints[i] != NULL &&
4382                         join_method_hints[i]->enforce_mask == ENABLE_ALL_JOIN)
4383                         JoinMethodHintDelete(join_method_hints[i]);
4384         }
4385         pfree(current_hint_state->join_hint_level);
4386         pfree(join_method_hints);
4387
4388         if (leading_hint_enable)
4389                 set_join_config_options(current_hint_state->init_join_mask,
4390                                                                 current_hint_state->context);
4391
4392         return rel;
4393 }
4394
4395 /*
4396  * Force number of wokers if instructed by hint
4397  */
4398 void
4399 pg_hint_plan_set_rel_pathlist(PlannerInfo * root, RelOptInfo *rel,
4400                                                           Index rti, RangeTblEntry *rte)
4401 {
4402         ParallelHint   *phint;
4403         ListCell           *l;
4404         int                             found_hints;
4405
4406         /* call the previous hook */
4407         if (prev_set_rel_pathlist)
4408                 prev_set_rel_pathlist(root, rel, rti, rte);
4409
4410         /* Nothing to do if no hint available */
4411         if (current_hint_state == NULL)
4412                 return;
4413
4414         /* Don't touch dummy rels. */
4415         if (IS_DUMMY_REL(rel))
4416                 return;
4417
4418         /*
4419          * We can accept only plain relations, foreign tables and table saples are
4420          * also unacceptable. See set_rel_pathlist.
4421          */
4422         if (rel->rtekind != RTE_RELATION ||
4423                 rte->relkind == RELKIND_FOREIGN_TABLE ||
4424                 rte->tablesample != NULL)
4425                 return;
4426
4427         /* We cannot handle if this requires an outer */
4428         if (rel->lateral_relids)
4429                 return;
4430
4431         /* Return if this relation gets no enfocement */
4432         if ((found_hints = setup_hint_enforcement(root, rel, NULL, &phint)) == 0)
4433                 return;
4434
4435         /* Here, we regenerate paths with the current hint restriction */
4436         if (found_hints & HINT_BM_SCAN_METHOD || found_hints & HINT_BM_PARALLEL)
4437         {
4438                 /* Just discard all the paths considered so far */
4439                 list_free_deep(rel->pathlist);
4440                 rel->pathlist = NIL;
4441
4442                 /* Remove all the partial paths if Parallel hint is specfied */
4443                 if ((found_hints & HINT_BM_PARALLEL) && rel->partial_pathlist)
4444                 {
4445                         list_free_deep(rel->partial_pathlist);
4446                         rel->partial_pathlist = NIL;
4447                 }
4448
4449                 /* Regenerate paths with the current enforcement */
4450                 set_plain_rel_pathlist(root, rel, rte);
4451
4452                 /* Additional work to enforce parallel query execution */
4453                 if (phint && phint->nworkers > 0)
4454                 {
4455                         /* Lower the priorities of non-parallel paths */
4456                         foreach (l, rel->pathlist)
4457                         {
4458                                 Path *path = (Path *) lfirst(l);
4459
4460                                 if (path->startup_cost < disable_cost)
4461                                 {
4462                                         path->startup_cost += disable_cost;
4463                                         path->total_cost += disable_cost;
4464                                 }
4465                         }
4466
4467                         /* enforce number of workers if requested */
4468                         if (phint->force_parallel)
4469                         {
4470                                 foreach (l, rel->partial_pathlist)
4471                                 {
4472                                         Path *ppath = (Path *) lfirst(l);
4473
4474                                         ppath->parallel_workers = phint->nworkers;
4475                                 }
4476                         }
4477
4478                         /* Generate gather paths for base rels */
4479                         if (rel->reloptkind == RELOPT_BASEREL)
4480                                 generate_gather_paths(root, rel);
4481                 }
4482         }
4483
4484         reset_hint_enforcement();
4485 }
4486
4487 /*
4488  * set_rel_pathlist
4489  *        Build access paths for a base relation
4490  *
4491  * This function was copied and edited from set_rel_pathlist() in
4492  * src/backend/optimizer/path/allpaths.c in order not to copy other static
4493  * functions not required here.
4494  */
4495 static void
4496 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
4497                                  Index rti, RangeTblEntry *rte)
4498 {
4499         if (IS_DUMMY_REL(rel))
4500         {
4501                 /* We already proved the relation empty, so nothing more to do */
4502         }
4503         else if (rte->inh)
4504         {
4505                 /* It's an "append relation", process accordingly */
4506                 set_append_rel_pathlist(root, rel, rti, rte);
4507         }
4508         else
4509         {
4510                 if (rel->rtekind == RTE_RELATION)
4511                 {
4512                         if (rte->relkind == RELKIND_RELATION)
4513                         {
4514                                 if(rte->tablesample != NULL)
4515                                         elog(ERROR, "sampled relation is not supported");
4516
4517                                 /* Plain relation */
4518                                 set_plain_rel_pathlist(root, rel, rte);
4519                         }
4520                         else
4521                                 elog(ERROR, "unexpected relkind: %c", rte->relkind);
4522                 }
4523                 else
4524                         elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
4525         }
4526
4527         /*
4528          * Allow a plugin to editorialize on the set of Paths for this base
4529          * relation.  It could add new paths (such as CustomPaths) by calling
4530          * add_path(), or delete or modify paths added by the core code.
4531          */
4532         if (set_rel_pathlist_hook)
4533                 (*set_rel_pathlist_hook) (root, rel, rti, rte);
4534
4535         /* Now find the cheapest of the paths for this rel */
4536         set_cheapest(rel);
4537 }
4538
4539 /*
4540  * stmt_beg callback is called when each query in PL/pgSQL function is about
4541  * to be executed.  At that timing, we save query string in the global variable
4542  * plpgsql_query_string to use it in planner hook.  It's safe to use one global
4543  * variable for the purpose, because its content is only necessary until
4544  * planner hook is called for the query, so recursive PL/pgSQL function calls
4545  * don't harm this mechanism.
4546  */
4547 static void
4548 pg_hint_plan_plpgsql_stmt_beg(PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt)
4549 {
4550         plpgsql_recurse_level++;
4551 }
4552
4553 /*
4554  * stmt_end callback is called then each query in PL/pgSQL function has
4555  * finished.  At that timing, we clear plpgsql_query_string to tell planner
4556  * hook that next call is not for a query written in PL/pgSQL block.
4557  */
4558 static void
4559 pg_hint_plan_plpgsql_stmt_end(PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt)
4560 {
4561         plpgsql_recurse_level--;
4562 }
4563
4564 void plpgsql_query_erase_callback(ResourceReleasePhase phase,
4565                                                                   bool isCommit,
4566                                                                   bool isTopLevel,
4567                                                                   void *arg)
4568 {
4569         if (phase != RESOURCE_RELEASE_AFTER_LOCKS)
4570                 return;
4571         /* Cancel plpgsql nest level*/
4572         plpgsql_recurse_level = 0;
4573 }
4574
4575 #define standard_join_search pg_hint_plan_standard_join_search
4576 #define join_search_one_level pg_hint_plan_join_search_one_level
4577 #define make_join_rel make_join_rel_wrapper
4578 #include "core.c"
4579
4580 #undef make_join_rel
4581 #define make_join_rel pg_hint_plan_make_join_rel
4582 #define add_paths_to_joinrel add_paths_to_joinrel_wrapper
4583 #include "make_join_rel.c"
4584
4585 #include "pg_stat_statements.c"