pg_hint_plan.c

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