X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=pg_hint_plan.c;h=db1082aaed0c6955b543df05b52c12377ec39e02;hb=7d7cdde7181d4017d3887ac2baf9465ffe9a60d8;hp=26586a288708d7e798e2df7757652bb29734061b;hpb=aa499a1f127c33c27218f5ddfa9d8392a5adb29f;p=pghintplan%2Fpg_hint_plan.git

diff --git a/pg_hint_plan.c b/pg_hint_plan.c
index 26586a2..db1082a 100644
--- a/pg_hint_plan.c
+++ b/pg_hint_plan.c
@@ -4,11 +4,13 @@
  *		  do instructions or hints to the planner using C-style block comments
  *		  of the SQL.
  *
- * Copyright (c) 2012, NIPPON TELEGRAPH AND TELEPHONE CORPORATION
+ * Copyright (c) 2012-2013, NIPPON TELEGRAPH AND TELEPHONE CORPORATION
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
+#include "catalog/pg_collation.h"
+#include "catalog/pg_index.h"
 #include "commands/prepare.h"
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
@@ -25,12 +27,17 @@
 #include "optimizer/restrictinfo.h"
 #include "parser/scansup.h"
 #include "tcop/utility.h"
+#include "utils/builtins.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/rel.h"
+#include "utils/syscache.h"
 #if PG_VERSION_NUM >= 90200
 #include "catalog/pg_class.h"
 #endif
 
+#include "plpgsql.h"
+
 #ifdef PG_MODULE_MAGIC
 PG_MODULE_MAGIC;
 #endif
@@ -48,7 +55,9 @@ PG_MODULE_MAGIC;
 /* hint keywords */
 #define HINT_SEQSCAN			"SeqScan"
 #define HINT_INDEXSCAN			"IndexScan"
+#define HINT_INDEXSCANREGEXP	"IndexScanRegexp"
 #define HINT_BITMAPSCAN			"BitmapScan"
+#define HINT_BITMAPSCANREGEXP	"BitmapScanRegexp"
 #define HINT_TIDSCAN			"TidScan"
 #define HINT_NOSEQSCAN			"NoSeqScan"
 #define HINT_NOINDEXSCAN		"NoIndexScan"
@@ -56,6 +65,7 @@ PG_MODULE_MAGIC;
 #define HINT_NOTIDSCAN			"NoTidScan"
 #if PG_VERSION_NUM >= 90200
 #define HINT_INDEXONLYSCAN		"IndexOnlyScan"
+#define HINT_INDEXONLYSCANREGEXP	"IndexOnlyScanRegexp"
 #define HINT_NOINDEXONLYSCAN	"NoIndexOnlyScan"
 #endif
 #define HINT_NESTLOOP			"NestLoop"
@@ -113,7 +123,9 @@ typedef enum HintKeyword
 {
 	HINT_KEYWORD_SEQSCAN,
 	HINT_KEYWORD_INDEXSCAN,
+	HINT_KEYWORD_INDEXSCANREGEXP,
 	HINT_KEYWORD_BITMAPSCAN,
+	HINT_KEYWORD_BITMAPSCANREGEXP,
 	HINT_KEYWORD_TIDSCAN,
 	HINT_KEYWORD_NOSEQSCAN,
 	HINT_KEYWORD_NOINDEXSCAN,
@@ -121,6 +133,7 @@ typedef enum HintKeyword
 	HINT_KEYWORD_NOTIDSCAN,
 #if PG_VERSION_NUM >= 90200
 	HINT_KEYWORD_INDEXONLYSCAN,
+	HINT_KEYWORD_INDEXONLYSCANREGEXP,
 	HINT_KEYWORD_NOINDEXONLYSCAN,
 #endif
 	HINT_KEYWORD_NESTLOOP,
@@ -141,7 +154,7 @@ typedef Hint *(*HintCreateFunction) (const char *hint_str,
 									 const char *keyword,
 									 HintKeyword hint_keyword);
 typedef void (*HintDeleteFunction) (Hint *hint);
-typedef void (*HintDumpFunction) (Hint *hint, StringInfo buf);
+typedef void (*HintDescFunction) (Hint *hint, StringInfo buf);
 typedef int (*HintCmpFunction) (const Hint *a, const Hint *b);
 typedef const char *(*HintParseFunction) (Hint *hint, HintState *hstate,
 										  Query *parse, const char *str);
@@ -185,7 +198,7 @@ struct Hint
 	HintType			type;
 	HintStatus			state;
 	HintDeleteFunction	delete_func;
-	HintDumpFunction	dump_func;
+	HintDescFunction	desc_func;
 	HintCmpFunction		cmp_func;
 	HintParseFunction	parse_func;
 };
@@ -196,9 +209,22 @@ typedef struct ScanMethodHint
 	Hint			base;
 	char		   *relname;
 	List		   *indexnames;
+	bool			regexp;
 	unsigned char	enforce_mask;
 } ScanMethodHint;
 
+typedef struct ParentIndexInfo
+{
+	bool		indisunique;
+	Oid			method;
+	List	   *column_names;
+	char	   *expression_str;
+	Oid		   *indcollation;
+	Oid		   *opclass;
+	int16	   *indoption;
+	char	   *indpred_str;
+} ParentIndexInfo;
+
 /* join method hints */
 typedef struct JoinMethodHint
 {
@@ -253,7 +279,10 @@ struct HintState
 	ScanMethodHint **scan_hints;		/* parsed scan hints */
 	int				init_scan_mask;		/* initial value scan parameter */
 	Index			parent_relid;		/* inherit parent table relid */
+	Oid				parent_rel_oid;     /* inherit parent table relid */
 	ScanMethodHint *parent_hint;		/* inherit parent table scan hint */
+	List		   *parent_index_infos; /* infomation of inherit parent table's
+										 * index */
 
 	/* for join method hints */
 	JoinMethodHint **join_hints;		/* parsed join hints */
@@ -261,7 +290,7 @@ struct HintState
 	List		  **join_hint_level;
 
 	/* for Leading hint */
-	LeadingHint	  **leading_hint;		/* parsed last specified Leading hint */
+	LeadingHint	  **leading_hint;		/* parsed Leading hints */
 
 	/* for Set hints */
 	SetHint		  **set_hints;			/* parsed Set hints */
@@ -302,36 +331,36 @@ static RelOptInfo *pg_hint_plan_join_search(PlannerInfo *root,
 static Hint *ScanMethodHintCreate(const char *hint_str, const char *keyword,
 								  HintKeyword hint_keyword);
 static void ScanMethodHintDelete(ScanMethodHint *hint);
-static void ScanMethodHintDump(ScanMethodHint *hint, StringInfo buf);
+static void ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf);
 static int ScanMethodHintCmp(const ScanMethodHint *a, const ScanMethodHint *b);
 static const char *ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate,
 									   Query *parse, const char *str);
 static Hint *JoinMethodHintCreate(const char *hint_str, const char *keyword,
 								  HintKeyword hint_keyword);
 static void JoinMethodHintDelete(JoinMethodHint *hint);
-static void JoinMethodHintDump(JoinMethodHint *hint, StringInfo buf);
+static void JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf);
 static int JoinMethodHintCmp(const JoinMethodHint *a, const JoinMethodHint *b);
 static const char *JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate,
 									   Query *parse, const char *str);
 static Hint *LeadingHintCreate(const char *hint_str, const char *keyword,
 							   HintKeyword hint_keyword);
 static void LeadingHintDelete(LeadingHint *hint);
-static void LeadingHintDump(LeadingHint *hint, StringInfo buf);
+static void LeadingHintDesc(LeadingHint *hint, StringInfo buf);
 static int LeadingHintCmp(const LeadingHint *a, const LeadingHint *b);
 static const char *LeadingHintParse(LeadingHint *hint, HintState *hstate,
 									Query *parse, const char *str);
 static Hint *SetHintCreate(const char *hint_str, const char *keyword,
 						   HintKeyword hint_keyword);
 static void SetHintDelete(SetHint *hint);
-static void SetHintDump(SetHint *hint, StringInfo buf);
+static void SetHintDesc(SetHint *hint, StringInfo buf);
 static int SetHintCmp(const SetHint *a, const SetHint *b);
 static const char *SetHintParse(SetHint *hint, HintState *hstate, Query *parse,
 								const char *str);
 
-static void dump_quote_value_quote_char(StringInfo buf, const char *value,
-										char quote_char);
-static const char *parse_quote_value_term_char(const char *str, char **word,
-											   bool truncate, char term_char);
+static void quote_value(StringInfo buf, const char *value);
+
+static const char *parse_quoted_value(const char *str, char **word,
+									  bool truncate);
 
 RelOptInfo *pg_hint_plan_standard_join_search(PlannerInfo *root,
 											  int levels_needed,
@@ -357,6 +386,13 @@ static void set_dummy_rel_pathlist(RelOptInfo *rel);
 RelOptInfo *pg_hint_plan_make_join_rel(PlannerInfo *root, RelOptInfo *rel1,
 									   RelOptInfo *rel2);
 
+static void pg_hint_plan_plpgsql_func_setup(PLpgSQL_execstate *estate,
+										  PLpgSQL_stmt *stmt);
+static void pg_hint_plan_plpgsql_stmt_beg(PLpgSQL_execstate *estate,
+										  PLpgSQL_stmt *stmt);
+static void pg_hint_plan_plpgsql_stmt_end(PLpgSQL_execstate *estate,
+										  PLpgSQL_stmt *stmt);
+
 /* GUC variables */
 static bool	pg_hint_plan_enable_hint = true;
 static bool	pg_hint_plan_debug_print = false;
@@ -405,7 +441,10 @@ static char	   *stmt_name = NULL;
 static const HintParser parsers[] = {
 	{HINT_SEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_SEQSCAN},
 	{HINT_INDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCAN},
+	{HINT_INDEXSCANREGEXP, ScanMethodHintCreate, HINT_KEYWORD_INDEXSCANREGEXP},
 	{HINT_BITMAPSCAN, ScanMethodHintCreate, HINT_KEYWORD_BITMAPSCAN},
+	{HINT_BITMAPSCANREGEXP, ScanMethodHintCreate,
+	 HINT_KEYWORD_BITMAPSCANREGEXP},
 	{HINT_TIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_TIDSCAN},
 	{HINT_NOSEQSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOSEQSCAN},
 	{HINT_NOINDEXSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXSCAN},
@@ -413,6 +452,8 @@ static const HintParser parsers[] = {
 	{HINT_NOTIDSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOTIDSCAN},
 #if PG_VERSION_NUM >= 90200
 	{HINT_INDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_INDEXONLYSCAN},
+	{HINT_INDEXONLYSCANREGEXP, ScanMethodHintCreate,
+	 HINT_KEYWORD_INDEXONLYSCANREGEXP},
 	{HINT_NOINDEXONLYSCAN, ScanMethodHintCreate, HINT_KEYWORD_NOINDEXONLYSCAN},
 #endif
 	{HINT_NESTLOOP, JoinMethodHintCreate, HINT_KEYWORD_NESTLOOP},
@@ -426,6 +467,8 @@ static const HintParser parsers[] = {
 	{NULL, NULL, HINT_KEYWORD_UNRECOGNIZED}
 };
 
+const char *hint_query_string = NULL;
+PLpgSQL_plugin  plugin_funcs = { };
 /*
  * Module load callbacks
  */
@@ -476,6 +519,11 @@ _PG_init(void)
 	get_relation_info_hook = pg_hint_plan_get_relation_info;
 	prev_join_search = join_search_hook;
 	join_search_hook = pg_hint_plan_join_search;
+
+	/* PL/pgSQL plugin hook */
+	PLpgSQL_plugin	**var_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin");
+	*var_ptr = &plugin_funcs;
+	(&plugin_funcs)->func_setup = (void *)pg_hint_plan_plpgsql_func_setup;
 }
 
 /*
@@ -509,11 +557,12 @@ ScanMethodHintCreate(const char *hint_str, const char *keyword,
 	hint->base.type = HINT_TYPE_SCAN_METHOD;
 	hint->base.state = HINT_STATE_NOTUSED;
 	hint->base.delete_func = (HintDeleteFunction) ScanMethodHintDelete;
-	hint->base.dump_func = (HintDumpFunction) ScanMethodHintDump;
+	hint->base.desc_func = (HintDescFunction) ScanMethodHintDesc;
 	hint->base.cmp_func = (HintCmpFunction) ScanMethodHintCmp;
 	hint->base.parse_func = (HintParseFunction) ScanMethodHintParse;
 	hint->relname = NULL;
 	hint->indexnames = NIL;
+	hint->regexp = false;
 	hint->enforce_mask = 0;
 
 	return (Hint *) hint;
@@ -544,7 +593,7 @@ JoinMethodHintCreate(const char *hint_str, const char *keyword,
 	hint->base.type = HINT_TYPE_JOIN_METHOD;
 	hint->base.state = HINT_STATE_NOTUSED;
 	hint->base.delete_func = (HintDeleteFunction) JoinMethodHintDelete;
-	hint->base.dump_func = (HintDumpFunction) JoinMethodHintDump;
+	hint->base.desc_func = (HintDescFunction) JoinMethodHintDesc;
 	hint->base.cmp_func = (HintCmpFunction) JoinMethodHintCmp;
 	hint->base.parse_func = (HintParseFunction) JoinMethodHintParse;
 	hint->nrels = 0;
@@ -590,7 +639,7 @@ LeadingHintCreate(const char *hint_str, const char *keyword,
 	hint->base.type = HINT_TYPE_LEADING;
 	hint->base.state = HINT_STATE_NOTUSED;
 	hint->base.delete_func = (HintDeleteFunction)LeadingHintDelete;
-	hint->base.dump_func = (HintDumpFunction) LeadingHintDump;
+	hint->base.desc_func = (HintDescFunction) LeadingHintDesc;
 	hint->base.cmp_func = (HintCmpFunction) LeadingHintCmp;
 	hint->base.parse_func = (HintParseFunction) LeadingHintParse;
 	hint->relations = NIL;
@@ -606,7 +655,8 @@ LeadingHintDelete(LeadingHint *hint)
 		return;
 
 	list_free_deep(hint->relations);
-	free(hint->outer_inner);
+	if (hint->outer_inner)
+		pfree(hint->outer_inner);
 	pfree(hint);
 }
 
@@ -623,7 +673,7 @@ SetHintCreate(const char *hint_str, const char *keyword,
 	hint->base.type = HINT_TYPE_SET;
 	hint->base.state = HINT_STATE_NOTUSED;
 	hint->base.delete_func = (HintDeleteFunction) SetHintDelete;
-	hint->base.dump_func = (HintDumpFunction) SetHintDump;
+	hint->base.desc_func = (HintDescFunction) SetHintDesc;
 	hint->base.cmp_func = (HintCmpFunction) SetHintCmp;
 	hint->base.parse_func = (HintParseFunction) SetHintParse;
 	hint->name = NULL;
@@ -662,7 +712,9 @@ HintStateCreate(void)
 	hstate->scan_hints = NULL;
 	hstate->init_scan_mask = 0;
 	hstate->parent_relid = 0;
+	hstate->parent_rel_oid = InvalidOid;
 	hstate->parent_hint = NULL;
+	hstate->parent_index_infos = NIL;
 	hstate->join_hints = NULL;
 	hstate->init_join_mask = 0;
 	hstate->join_hint_level = NULL;
@@ -688,34 +740,22 @@ HintStateDelete(HintState *hstate)
 		hstate->all_hints[i]->delete_func(hstate->all_hints[i]);
 	if (hstate->all_hints)
 		pfree(hstate->all_hints);
+	if (hstate->parent_index_infos)
+		list_free(hstate->parent_index_infos);
 }
 
 /*
- * dump functions
- */
-
-/*
- * Quote value as needed and dump it to buf.
+ * Copy given value into buf, with quoting with '"' if necessary.
  */
 static void
-dump_quote_value(StringInfo buf, const char *value)
-{
-	dump_quote_value_quote_char(buf, value, '"');
-}
-
-/*
- * We specified a character to quote for by addition in quote_char.
- * If there is not a character to quote, we specified '"'.
- */
-static void
-dump_quote_value_quote_char(StringInfo buf, const char *value, char quote_char)
+quote_value(StringInfo buf, const char *value)
 {
 	bool		need_quote = false;
 	const char *str;
 
 	for (str = value; *str != '\0'; str++)
 	{
-		if (isspace(*str) || *str == ')' || *str == '"' || *str == quote_char)
+		if (isspace(*str) || *str == '(' || *str == ')' || *str == '"')
 		{
 			need_quote = true;
 			appendStringInfoCharMacro(buf, '"');
@@ -736,36 +776,36 @@ dump_quote_value_quote_char(StringInfo buf, const char *value, char quote_char)
 }
 
 static void
-ScanMethodHintDump(ScanMethodHint *hint, StringInfo buf)
+ScanMethodHintDesc(ScanMethodHint *hint, StringInfo buf)
 {
 	ListCell   *l;
 
 	appendStringInfo(buf, "%s(", hint->base.keyword);
 	if (hint->relname != NULL)
 	{
-		dump_quote_value(buf, hint->relname);
+		quote_value(buf, hint->relname);
 		foreach(l, hint->indexnames)
 		{
 			appendStringInfoCharMacro(buf, ' ');
-			dump_quote_value(buf, (char *) lfirst(l));
+			quote_value(buf, (char *) lfirst(l));
 		}
 	}
 	appendStringInfoString(buf, ")\n");
 }
 
 static void
-JoinMethodHintDump(JoinMethodHint *hint, StringInfo buf)
+JoinMethodHintDesc(JoinMethodHint *hint, StringInfo buf)
 {
 	int	i;
 
 	appendStringInfo(buf, "%s(", hint->base.keyword);
 	if (hint->relnames != NULL)
 	{
-		dump_quote_value(buf, hint->relnames[0]);
+		quote_value(buf, hint->relnames[0]);
 		for (i = 1; i < hint->nrels; i++)
 		{
 			appendStringInfoCharMacro(buf, ' ');
-			dump_quote_value(buf, hint->relnames[i]);
+			quote_value(buf, hint->relnames[i]);
 		}
 	}
 	appendStringInfoString(buf, ")\n");
@@ -773,7 +813,7 @@ JoinMethodHintDump(JoinMethodHint *hint, StringInfo buf)
 }
 
 static void
-OuterInnerDump(OuterInnerRels *outer_inner, StringInfo buf)
+OuterInnerDesc(OuterInnerRels *outer_inner, StringInfo buf)
 {
 	if (outer_inner->relation == NULL)
 	{
@@ -790,25 +830,26 @@ OuterInnerDump(OuterInnerRels *outer_inner, StringInfo buf)
 			else
 				appendStringInfoCharMacro(buf, ' ');
 
-			OuterInnerDump(lfirst(l), buf);
+			OuterInnerDesc(lfirst(l), buf);
 		}
 
 		appendStringInfoCharMacro(buf, ')');
 	}
 	else
-		dump_quote_value_quote_char(buf, outer_inner->relation, '(');
+		quote_value(buf, outer_inner->relation);
 }
 
 static void
-LeadingHintDump(LeadingHint *hint, StringInfo buf)
+LeadingHintDesc(LeadingHint *hint, StringInfo buf)
 {
-	bool		is_first;
-	ListCell   *l;
-
 	appendStringInfo(buf, "%s(", HINT_LEADING);
-	is_first = true;
 	if (hint->outer_inner == NULL)
 	{
+		ListCell   *l;
+		bool		is_first;
+
+		is_first = true;
+
 		foreach(l, hint->relations)
 		{
 			if (is_first)
@@ -816,17 +857,17 @@ LeadingHintDump(LeadingHint *hint, StringInfo buf)
 			else
 				appendStringInfoCharMacro(buf, ' ');
 
-			dump_quote_value(buf, (char *) lfirst(l));
+			quote_value(buf, (char *) lfirst(l));
 		}
 	}
 	else
-		OuterInnerDump(hint->outer_inner, buf);
+		OuterInnerDesc(hint->outer_inner, buf);
 
 	appendStringInfoString(buf, ")\n");
 }
 
 static void
-SetHintDump(SetHint *hint, StringInfo buf)
+SetHintDesc(SetHint *hint, StringInfo buf)
 {
 	bool		is_first = true;
 	ListCell   *l;
@@ -839,14 +880,18 @@ SetHintDump(SetHint *hint, StringInfo buf)
 		else
 			appendStringInfoCharMacro(buf, ' ');
 
-		dump_quote_value(buf, (char *) lfirst(l));
+		quote_value(buf, (char *) lfirst(l));
 	}
 	appendStringInfo(buf, ")\n");
 }
 
+/*
+ * Append string which repserents all hints in a given state to buf, with
+ * preceding title with them.
+ */
 static void
-all_hint_dump(HintState *hstate, StringInfo buf, const char *title,
-			  HintStatus state)
+desc_hint_in_state(HintState *hstate, StringInfo buf, const char *title,
+					HintStatus state)
 {
 	int	i;
 
@@ -856,10 +901,13 @@ all_hint_dump(HintState *hstate, StringInfo buf, const char *title,
 		if (hstate->all_hints[i]->state != state)
 			continue;
 
-		hstate->all_hints[i]->dump_func(hstate->all_hints[i], buf);
+		hstate->all_hints[i]->desc_func(hstate->all_hints[i], buf);
 	}
 }
 
+/*
+ * Dump contents of given hstate to server log with log level LOG.
+ */
 static void
 HintStateDump(HintState *hstate)
 {
@@ -874,10 +922,10 @@ HintStateDump(HintState *hstate)
 	initStringInfo(&buf);
 
 	appendStringInfoString(&buf, "pg_hint_plan:\n");
-	all_hint_dump(hstate, &buf, "used hint", HINT_STATE_USED);
-	all_hint_dump(hstate, &buf, "not used hint", HINT_STATE_NOTUSED);
-	all_hint_dump(hstate, &buf, "duplication hint", HINT_STATE_DUPLICATION);
-	all_hint_dump(hstate, &buf, "error hint", HINT_STATE_ERROR);
+	desc_hint_in_state(hstate, &buf, "used hint", HINT_STATE_USED);
+	desc_hint_in_state(hstate, &buf, "not used hint", HINT_STATE_NOTUSED);
+	desc_hint_in_state(hstate, &buf, "duplication hint", HINT_STATE_DUPLICATION);
+	desc_hint_in_state(hstate, &buf, "error hint", HINT_STATE_ERROR);
 
 	elog(LOG, "%s", buf.data);
 
@@ -1008,18 +1056,7 @@ skip_parenthesis(const char *str, char parenthesis)
  * Parsed token is truncated within NAMEDATALEN-1 bytes, when truncate is true.
  */
 static const char *
-parse_quote_value(const char *str, char **word, bool truncate)
-{
-	return parse_quote_value_term_char(str, word, truncate, '\0');
-}
-
-/*
- * In term_char, We specified the special character which a terminal of a word.
- * When we do not have a special character, We specified '\0'.
- */
-static const char *
-parse_quote_value_term_char(const char *str, char **word, bool truncate,
-							char term_char)
+parse_quoted_value(const char *str, char **word, bool truncate)
 {
 	StringInfoData	buf;
 	bool			in_quote;
@@ -1065,8 +1102,8 @@ parse_quote_value_term_char(const char *str, char **word, bool truncate,
 					break;
 			}
 		}
-		else if (isspace(*str) || *str == ')' || *str == '"' || *str == '\0' ||
-				 *str == term_char)
+		else if (isspace(*str) || *str == '(' || *str == ')' || *str == '"' ||
+				 *str == '\0')
 			break;
 
 		appendStringInfoCharMacro(&buf, *str++);
@@ -1091,8 +1128,10 @@ parse_quote_value_term_char(const char *str, char **word, bool truncate,
 }
 
 static OuterInnerRels *
-OuterInnerRelsCreate(OuterInnerRels *outer_inner, char *name, List *outer_inner_list)
+OuterInnerRelsCreate(char *name, List *outer_inner_list)
 {
+	OuterInnerRels *outer_inner;
+
 	outer_inner = palloc(sizeof(OuterInnerRels));
 	outer_inner->relation = name;
 	outer_inner->outer_inner_pair = outer_inner_list;
@@ -1103,40 +1142,46 @@ OuterInnerRelsCreate(OuterInnerRels *outer_inner, char *name, List *outer_inner_
 static const char *
 parse_parentheses_Leading_in(const char *str, OuterInnerRels **outer_inner)
 {
-	char   *name;
-	bool	truncate = true;
+	List   *outer_inner_pair = NIL;
 
-	OuterInnerRels *outer_inner_rels;
-	outer_inner_rels = NULL;
+	if ((str = skip_parenthesis(str, '(')) == NULL)
+		return NULL;
 
 	skip_space(str);
 
 	/* Store words in parentheses into outer_inner_list. */
 	while(*str != ')' && *str != '\0')
 	{
+		OuterInnerRels *outer_inner_rels;
+
 		if (*str == '(')
 		{
-			str++;
-			outer_inner_rels = OuterInnerRelsCreate(outer_inner_rels,
-													NULL,
-													NIL);
 			str = parse_parentheses_Leading_in(str, &outer_inner_rels);
+			if (str == NULL)
+				break;
 		}
-		else if ((str = parse_quote_value_term_char(str, &name, truncate, '(')) == NULL)
+		else
 		{
-			list_free((*outer_inner)->outer_inner_pair);
-			return NULL;
+			char   *name;
+
+			if ((str = parse_quoted_value(str, &name, true)) == NULL)
+				break;
+			else
+				outer_inner_rels = OuterInnerRelsCreate(name, NIL);
 		}
-		else
-			outer_inner_rels = OuterInnerRelsCreate(outer_inner_rels, name, NIL);
 
-		(*outer_inner)->outer_inner_pair = lappend(
-											(*outer_inner)->outer_inner_pair,
-											 outer_inner_rels);
+		outer_inner_pair = lappend(outer_inner_pair, outer_inner_rels);
 		skip_space(str);
 	}
 
-	str++;
+	if (str == NULL ||
+		(str = skip_parenthesis(str, ')')) == NULL)
+	{
+		list_free(outer_inner_pair);
+		return NULL;
+	}
+
+	*outer_inner = OuterInnerRelsCreate(NULL, outer_inner_pair);
 
 	return str;
 }
@@ -1154,17 +1199,15 @@ parse_parentheses_Leading(const char *str, List **name_list,
 	skip_space(str);
 	if (*str =='(')
 	{
-		str++;
-
-		*outer_inner = OuterInnerRelsCreate(*outer_inner, NULL, NIL);
-		str = parse_parentheses_Leading_in(str, outer_inner);
+		if ((str = parse_parentheses_Leading_in(str, outer_inner)) == NULL)
+			return NULL;
 	}
 	else
 	{
 		/* Store words in parentheses into name_list. */
 		while(*str != ')' && *str != '\0')
 		{
-			if ((str = parse_quote_value(str, &name, truncate)) == NULL)
+			if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
 			{
 				list_free(*name_list);
 				return NULL;
@@ -1181,7 +1224,7 @@ parse_parentheses_Leading(const char *str, List **name_list,
 }
 
 static const char *
-parse_parentheses(const char *str, List **name_list, HintType type)
+parse_parentheses(const char *str, List **name_list, HintKeyword keyword)
 {
 	char   *name;
 	bool	truncate = true;
@@ -1194,7 +1237,7 @@ parse_parentheses(const char *str, List **name_list, HintType type)
 	/* Store words in parentheses into name_list. */
 	while(*str != ')' && *str != '\0')
 	{
-		if ((str = parse_quote_value(str, &name, truncate)) == NULL)
+		if ((str = parse_quoted_value(str, &name, truncate)) == NULL)
 		{
 			list_free(*name_list);
 			return NULL;
@@ -1203,7 +1246,12 @@ parse_parentheses(const char *str, List **name_list, HintType type)
 		*name_list = lappend(*name_list, name);
 		skip_space(str);
 
-		if (type == HINT_TYPE_SET)
+		if (keyword == HINT_KEYWORD_INDEXSCANREGEXP ||
+#if PG_VERSION_NUM >= 90200
+			keyword == HINT_KEYWORD_INDEXONLYSCANREGEXP ||
+#endif
+			keyword == HINT_KEYWORD_BITMAPSCANREGEXP ||
+			keyword == HINT_KEYWORD_SET)
 		{
 			truncate = false;
 		}
@@ -1295,6 +1343,7 @@ static HintState *
 parse_head_comment(Query *parse)
 {
 	const char *p;
+	const char *hint_head;
 	char	   *head;
 	char	   *tail;
 	int			len;
@@ -1309,6 +1358,8 @@ parse_head_comment(Query *parse)
 		entry = FetchPreparedStatement(stmt_name, true);
 		p = entry->plansource->query_string;
 	}
+	else if (hint_query_string)
+		p = hint_query_string;
 	else
 		p = debug_query_string;
 
@@ -1316,11 +1367,34 @@ parse_head_comment(Query *parse)
 		return NULL;
 
 	/* extract query head comment. */
-	len = strlen(HINT_START);
-	skip_space(p);
-	if (strncmp(p, HINT_START, len))
+	hint_head = strstr(p, HINT_START);
+	if (hint_head == NULL)
 		return NULL;
+	for (;p < hint_head; p++)
+	{
+		/*
+		 * Allow these characters precedes hint comment:
+		 *   - digits
+		 *   - alphabets which are in ASCII range
+		 *   - space, tabs and new-lines
+		 *   - underscores, for identifier
+		 *   - commas, for SELECT clause, EXPLAIN and PREPARE
+		 *   - parentheses, for EXPLAIN and PREPARE
+		 *
+		 * Note that we don't use isalpha() nor isalnum() in ctype.h here to
+		 * avoid behavior which depends on locale setting.
+		 */
+		if (!(*p >= '0' && *p <= '9') &&
+			!(*p >= 'A' && *p <= 'Z') &&
+			!(*p >= 'a' && *p <= 'z') &&
+			!isspace(*p) &&
+			*p != '_' &&
+			*p != ',' &&
+			*p != '(' && *p != ')')
+			return NULL;
+	}
 
+	len = strlen(HINT_START);
 	head = (char *) p;
 	p += len;
 	skip_space(p);
@@ -1381,14 +1455,10 @@ parse_head_comment(Query *parse)
 		Hint   *next_hint = hstate->all_hints[i + 1];
 
 		/*
-		 *  TODO : Leadingヒントの重複チェックは、transform_join_hints関数の実行
-		 *  　　   中に実施する。
-		*/
-		if (i >= hstate->num_hints[HINT_TYPE_SCAN_METHOD] +
-			    hstate->num_hints[HINT_TYPE_JOIN_METHOD] &&
-			i < hstate->num_hints[HINT_TYPE_SCAN_METHOD] +
-				hstate->num_hints[HINT_TYPE_JOIN_METHOD] +
-				hstate->num_hints[HINT_TYPE_LEADING])
+		 * Leading hint is marked as 'duplicated' in transform_join_hints.
+		 */
+		if (cur_hint->type == HINT_TYPE_LEADING &&
+			next_hint->type == HINT_TYPE_LEADING)
 			continue;
 
 		/*
@@ -1408,15 +1478,12 @@ parse_head_comment(Query *parse)
 	 * array which consists of all hints.
 	 */
 	hstate->scan_hints = (ScanMethodHint **) hstate->all_hints;
-	hstate->join_hints = (JoinMethodHint **) hstate->all_hints +
-		hstate->num_hints[HINT_TYPE_SCAN_METHOD];
-	hstate->leading_hint = (LeadingHint **) hstate->all_hints +
-		hstate->num_hints[HINT_TYPE_SCAN_METHOD] +
-		hstate->num_hints[HINT_TYPE_JOIN_METHOD];
-	hstate->set_hints = (SetHint **) hstate->all_hints +
-		hstate->num_hints[HINT_TYPE_SCAN_METHOD] +
-		hstate->num_hints[HINT_TYPE_JOIN_METHOD] +
-		hstate->num_hints[HINT_TYPE_LEADING];
+	hstate->join_hints = (JoinMethodHint **) (hstate->scan_hints +
+		hstate->num_hints[HINT_TYPE_SCAN_METHOD]);
+	hstate->leading_hint = (LeadingHint **) (hstate->join_hints +
+		hstate->num_hints[HINT_TYPE_JOIN_METHOD]);
+	hstate->set_hints = (SetHint **) (hstate->leading_hint +
+		hstate->num_hints[HINT_TYPE_LEADING]);
 
 	return hstate;
 }
@@ -1433,7 +1500,7 @@ ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
 	List		   *name_list = NIL;
 	int				length;
 
-	if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+	if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
 		return NULL;
 
 	/* Parse relation name and index name(s) if given hint accepts. */
@@ -1444,12 +1511,15 @@ ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
 		hint->indexnames = list_delete_first(name_list);
 
 		/* check whether the hint accepts index name(s). */
-		if (hint_keyword != HINT_KEYWORD_INDEXSCAN &&
+		if (length != 1 &&
+			hint_keyword != HINT_KEYWORD_INDEXSCAN &&
+			hint_keyword != HINT_KEYWORD_INDEXSCANREGEXP &&
 #if PG_VERSION_NUM >= 90200
 			hint_keyword != HINT_KEYWORD_INDEXONLYSCAN &&
+			hint_keyword != HINT_KEYWORD_INDEXONLYSCANREGEXP &&
 #endif
 			hint_keyword != HINT_KEYWORD_BITMAPSCAN &&
-			length != 1)
+			hint_keyword != HINT_KEYWORD_BITMAPSCANREGEXP)
 		{
 			hint_ereport(str,
 						 ("%s hint accepts only one relation.",
@@ -1476,9 +1546,17 @@ ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
 		case HINT_KEYWORD_INDEXSCAN:
 			hint->enforce_mask = ENABLE_INDEXSCAN;
 			break;
+		case HINT_KEYWORD_INDEXSCANREGEXP:
+			hint->enforce_mask = ENABLE_INDEXSCAN;
+			hint->regexp = true;
+			break;
 		case HINT_KEYWORD_BITMAPSCAN:
 			hint->enforce_mask = ENABLE_BITMAPSCAN;
 			break;
+		case HINT_KEYWORD_BITMAPSCANREGEXP:
+			hint->enforce_mask = ENABLE_BITMAPSCAN;
+			hint->regexp = true;
+			break;
 		case HINT_KEYWORD_TIDSCAN:
 			hint->enforce_mask = ENABLE_TIDSCAN;
 			break;
@@ -1498,6 +1576,10 @@ ScanMethodHintParse(ScanMethodHint *hint, HintState *hstate, Query *parse,
 		case HINT_KEYWORD_INDEXONLYSCAN:
 			hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
 			break;
+		case HINT_KEYWORD_INDEXONLYSCANREGEXP:
+			hint->enforce_mask = ENABLE_INDEXSCAN | ENABLE_INDEXONLYSCAN;
+			hint->regexp = true;
+			break;
 		case HINT_KEYWORD_NOINDEXONLYSCAN:
 			hint->enforce_mask = ENABLE_ALL_SCAN ^ ENABLE_INDEXONLYSCAN;
 			break;
@@ -1519,7 +1601,7 @@ JoinMethodHintParse(JoinMethodHint *hint, HintState *hstate, Query *parse,
 	HintKeyword		hint_keyword = hint->base.hint_keyword;
 	List		   *name_list = NIL;
 
-	if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+	if ((str = parse_parentheses(str, &name_list, hint_keyword)) == NULL)
 		return NULL;
 
 	hint->nrels = list_length(name_list);
@@ -1611,6 +1693,27 @@ OuterInnerPairCheck(OuterInnerRels *outer_inner)
 	return true;
 }
 
+static List *
+OuterInnerList(OuterInnerRels *outer_inner)
+{
+	List		   *outer_inner_list = NIL;
+	ListCell	   *l;
+	OuterInnerRels *outer_inner_rels;
+
+	foreach(l, outer_inner->outer_inner_pair)
+	{
+		outer_inner_rels = (OuterInnerRels *)(lfirst(l));
+
+		if (outer_inner_rels->relation != NULL)
+			outer_inner_list = lappend(outer_inner_list,
+									   outer_inner_rels->relation);
+		else
+			outer_inner_list = list_concat(outer_inner_list,
+										   OuterInnerList(outer_inner_rels));
+	}
+	return outer_inner_list;
+}
+
 static const char *
 LeadingHintParse(LeadingHint *hint, HintState *hstate, Query *parse,
 				 const char *str)
@@ -1618,15 +1721,18 @@ LeadingHintParse(LeadingHint *hint, HintState *hstate, Query *parse,
 	List		   *name_list = NIL;
 	OuterInnerRels *outer_inner = NULL;
 
-	if ((str =
-		 parse_parentheses_Leading(str, &name_list, &outer_inner)) == NULL)
+	if ((str = parse_parentheses_Leading(str, &name_list, &outer_inner)) ==
+		NULL)
 		return NULL;
 
+	if (outer_inner != NULL)
+		name_list = OuterInnerList(outer_inner);
+
 	hint->relations = name_list;
 	hint->outer_inner = outer_inner;
 
 	/* A Leading hint requires at least two relations */
-	if (list_length(hint->relations) < 2 && hint->outer_inner == NULL)
+	if ( hint->outer_inner == NULL && list_length(hint->relations) < 2)
 	{
 		hint_ereport(hint->base.hint_str,
 					 ("%s hint requires at least two relations.",
@@ -1650,7 +1756,8 @@ SetHintParse(SetHint *hint, HintState *hstate, Query *parse, const char *str)
 {
 	List   *name_list = NIL;
 
-	if ((str = parse_parentheses(str, &name_list, hint->base.type)) == NULL)
+	if ((str = parse_parentheses(str, &name_list, hint->base.hint_keyword))
+		== NULL)
 		return NULL;
 
 	hint->words = name_list;
@@ -2071,6 +2178,33 @@ find_scan_hint(PlannerInfo *root, RelOptInfo *rel)
 	return NULL;
 }
 
+/*
+ * regexeq
+ *
+ * Returns TRUE on match, FALSE on no match.
+ *
+ *   s1 --- the data to match against
+ *   s2 --- the pattern
+ *
+ * Because we copy s1 to NameData, make the size of s1 less than NAMEDATALEN.
+ */
+static bool
+regexpeq(const char *s1, const char *s2)
+{
+	NameData	name;
+	text	   *regexp;
+	Datum		result;
+
+	strcpy(name.data, s1);
+	regexp = cstring_to_text(s2);
+
+	result = DirectFunctionCall2Coll(nameregexeq,
+									 DEFAULT_COLLATION_OID,
+									 NameGetDatum(&name),
+									 PointerGetDatum(regexp));
+	return DatumGetBool(result);
+}
+
 static void
 delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
 {
@@ -2118,13 +2252,180 @@ delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
 
 		foreach(l, hint->indexnames)
 		{
-			if (RelnameCmp(&indexname, &lfirst(l)) == 0)
+			char   *hintname = (char *) lfirst(l);
+			bool	result;
+
+			if (hint->regexp)
+				result = regexpeq(indexname, hintname);
+			else
+				result = RelnameCmp(&indexname, &hintname) == 0;
+
+			if (result)
 			{
 				use_index = true;
 				if (pg_hint_plan_debug_print)
 				{
 					appendStringInfoCharMacro(&buf, ' ');
-					dump_quote_value(&buf, indexname);
+					quote_value(&buf, indexname);
+				}
+
+				break;
+			}
+		}
+
+		/*
+		 * to make the index a candidate when definition of this index is
+		 * matched with the index's definition of current_hint.
+		 */
+		if (OidIsValid(relationObjectId) && !use_index)
+		{
+			foreach(l, current_hint->parent_index_infos)
+			{
+				int					i;
+				HeapTuple			ht_idx;
+				ParentIndexInfo	   *p_info = (ParentIndexInfo *)lfirst(l);
+
+				/* check to match the parameter of unique */
+				if (p_info->indisunique != info->unique)
+					continue;
+
+				/* check to match the parameter of index's method */
+				if (p_info->method != info->relam)
+					continue;
+
+				/* to check to match the indexkey's configuration */
+				if ((list_length(p_info->column_names)) !=
+					 info->ncolumns)
+					continue;
+
+				/* check to match the indexkey's configuration */
+				for (i = 0; i < info->ncolumns; i++)
+				{
+					char       *c_attname = NULL;
+					char       *p_attname = NULL;
+
+					p_attname =
+						list_nth(p_info->column_names, i);
+
+					/* both are expressions */
+					if (info->indexkeys[i] == 0 && !p_attname)
+						continue;
+
+					/* one's column is expression, the other is not */
+					if (info->indexkeys[i] == 0 || !p_attname)
+						break;
+
+					c_attname = get_attname(relationObjectId,
+												info->indexkeys[i]);
+
+					if (strcmp(p_attname, c_attname) != 0)
+						break;
+
+					if (p_info->indcollation[i] != info->indexcollations[i])
+						break;
+
+					if (p_info->opclass[i] != info->opcintype[i])
+						break;
+
+					if (((p_info->indoption[i] & INDOPTION_DESC) != 0) !=
+						info->reverse_sort[i])
+						break;
+
+					if (((p_info->indoption[i] & INDOPTION_NULLS_FIRST) != 0) !=
+						info->nulls_first[i])
+						break;
+
+				}
+
+				if (i != info->ncolumns)
+					continue;
+
+				if ((p_info->expression_str && (info->indexprs != NIL)) ||
+					(p_info->indpred_str && (info->indpred != NIL)))
+				{
+					/*
+					 * Fetch the pg_index tuple by the Oid of the index
+					 */
+					ht_idx = SearchSysCache1(INDEXRELID,
+											 ObjectIdGetDatum(info->indexoid));
+
+					/* check to match the expression's parameter of index */
+					if (p_info->expression_str &&
+						!heap_attisnull(ht_idx, Anum_pg_index_indexprs))
+					{
+						Datum       exprsDatum;
+						bool        isnull;
+						Datum       result;
+
+						/*
+						 * to change the expression's parameter of child's
+						 * index to strings
+						 */
+						exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+													 Anum_pg_index_indexprs,
+													 &isnull);
+
+						result = DirectFunctionCall2(pg_get_expr,
+													 exprsDatum,
+													 ObjectIdGetDatum(
+														 relationObjectId));
+
+						if (strcmp(p_info->expression_str,
+								   text_to_cstring(DatumGetTextP(result))) != 0)
+						{
+							/* Clean up */
+							ReleaseSysCache(ht_idx);
+
+							continue;
+						}
+					}
+
+					/* Check to match the predicate's paraameter of index */
+					if (p_info->indpred_str &&
+						!heap_attisnull(ht_idx, Anum_pg_index_indpred))
+					{
+						Datum       predDatum;
+						bool        isnull;
+						Datum       result;
+
+						/*
+						 * to change the predicate's parabeter of child's
+						 * index to strings
+						 */
+						predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+													 Anum_pg_index_indpred,
+													 &isnull);
+
+						result = DirectFunctionCall2(pg_get_expr,
+													 predDatum,
+													 ObjectIdGetDatum(
+														 relationObjectId));
+
+						if (strcmp(p_info->indpred_str,
+								   text_to_cstring(DatumGetTextP(result))) != 0)
+						{
+							/* Clean up */
+							ReleaseSysCache(ht_idx);
+
+							continue;
+						}
+					}
+
+					/* Clean up */
+					ReleaseSysCache(ht_idx);
+				}
+				else if (p_info->expression_str || (info->indexprs != NIL))
+					continue;
+				else if	(p_info->indpred_str || (info->indpred != NIL))
+					continue;
+
+				use_index = true;
+
+				/* to log the candidate of index */
+				if (pg_hint_plan_debug_print)
+				{
+					appendStringInfoCharMacro(&buf, ' ');
+					quote_value(&buf, indexname);
 				}
 
 				break;
@@ -2150,7 +2451,7 @@ delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
 			relname = hint->relname;
 
 		initStringInfo(&rel_buf);
-		dump_quote_value(&rel_buf, relname);
+		quote_value(&rel_buf, relname);
 
 		ereport(LOG,
 				(errmsg("available indexes for %s(%s):%s",
@@ -2162,6 +2463,85 @@ delete_indexes(ScanMethodHint *hint, RelOptInfo *rel, Oid relationObjectId)
 	}
 }
 
+/* 
+ * Return information of index definition.
+ */
+static ParentIndexInfo *
+get_parent_index_info(Oid indexoid, Oid relid)
+{
+	ParentIndexInfo	*p_info = palloc(sizeof(ParentIndexInfo));
+	Relation	    indexRelation;
+	Form_pg_index	index;
+	char		   *attname;
+	int				i;
+
+	indexRelation = index_open(indexoid, RowExclusiveLock);
+
+	index = indexRelation->rd_index;
+
+	p_info->indisunique = index->indisunique;
+	p_info->method = indexRelation->rd_rel->relam;
+
+	p_info->column_names = NIL;
+	p_info->indcollation = (Oid *) palloc(sizeof(Oid) * index->indnatts);
+	p_info->opclass = (Oid *) palloc(sizeof(Oid) * index->indnatts);
+	p_info->indoption = (int16 *) palloc(sizeof(Oid) * index->indnatts);
+
+	for (i = 0; i < index->indnatts; i++)
+	{
+		attname = get_attname(relid, index->indkey.values[i]);
+		p_info->column_names = lappend(p_info->column_names, attname);
+
+		p_info->indcollation[i] = indexRelation->rd_indcollation[i];
+		p_info->opclass[i] = indexRelation->rd_opcintype[i];
+		p_info->indoption[i] = indexRelation->rd_indoption[i];
+	}
+
+	/*
+	 * to check to match the expression's paraameter of index with child indexes
+ 	 */
+	p_info->expression_str = NULL;
+	if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indexprs))
+	{
+		Datum       exprsDatum;
+		bool		isnull;
+		Datum		result;
+
+		exprsDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
+									 Anum_pg_index_indexprs, &isnull);
+
+		result = DirectFunctionCall2(pg_get_expr,
+									 exprsDatum,
+									 ObjectIdGetDatum(relid));
+
+		p_info->expression_str = text_to_cstring(DatumGetTextP(result));
+	}
+
+	/*
+	 * to check to match the predicate's paraameter of index with child indexes
+ 	 */
+	p_info->indpred_str = NULL;
+	if(!heap_attisnull(indexRelation->rd_indextuple, Anum_pg_index_indpred))
+	{
+		Datum       predDatum;
+		bool		isnull;
+		Datum		result;
+
+		predDatum = SysCacheGetAttr(INDEXRELID, indexRelation->rd_indextuple,
+									 Anum_pg_index_indpred, &isnull);
+
+		result = DirectFunctionCall2(pg_get_expr,
+									 predDatum,
+									 ObjectIdGetDatum(relid));
+
+		p_info->indpred_str = text_to_cstring(DatumGetTextP(result));
+	}
+
+	index_close(indexRelation, NoLock);
+
+	return p_info;
+}
+
 static void
 pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
 							   bool inhparent, RelOptInfo *rel)
@@ -2179,6 +2559,7 @@ pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
 	{
 		/* store does relids of parent table. */
 		current_hint->parent_relid = rel->relid;
+		current_hint->parent_rel_oid = relationObjectId;
 	}
 	else if (current_hint->parent_relid != 0)
 	{
@@ -2207,6 +2588,7 @@ pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
 
 		/* This rel is not inherit table. */
 		current_hint->parent_relid = 0;
+		current_hint->parent_rel_oid = InvalidOid;
 		current_hint->parent_hint = NULL;
 	}
 
@@ -2222,8 +2604,44 @@ pg_hint_plan_get_relation_info(PlannerInfo *root, Oid relationObjectId,
 	}
 	set_scan_config_options(hint->enforce_mask, current_hint->context);
 	hint->base.state = HINT_STATE_USED;
+
 	if (inhparent)
+	{
+		Relation    relation;
+		List       *indexoidlist;
+		ListCell   *l;
+
 		current_hint->parent_hint = hint;
+
+		relation = heap_open(relationObjectId, NoLock);
+		indexoidlist = RelationGetIndexList(relation);
+
+		foreach(l, indexoidlist)
+		{
+			Oid         indexoid = lfirst_oid(l);
+			char       *indexname = get_rel_name(indexoid);
+			bool        use_index = false;
+			ListCell   *lc;
+			ParentIndexInfo *parent_index_info;
+
+			foreach(lc, hint->indexnames)
+			{
+				if (RelnameCmp(&indexname, &lfirst(lc)) == 0)
+				{
+					use_index = true;
+					break;
+				}
+			}
+			if (!use_index)
+				continue;
+
+			parent_index_info = get_parent_index_info(indexoid,
+													  relationObjectId);
+			current_hint->parent_index_infos =
+				lappend(current_hint->parent_index_infos, parent_index_info);
+		}
+		heap_close(relation, NoLock);
+	}
 	else
 		delete_indexes(hint, rel, InvalidOid);
 }
@@ -2308,31 +2726,9 @@ find_join_hint(Relids joinrelids)
 	return NULL;
 }
 
-static List *
-OuterInnerList(OuterInnerRels *outer_inner)
-{
-	List		   *outer_inner_list = NIL;
-	ListCell	   *l;
-	OuterInnerRels *outer_inner_rels;
-
-	foreach(l, outer_inner->outer_inner_pair)
-	{
-		outer_inner_rels = (OuterInnerRels *)(lfirst(l));
-
-		if (outer_inner_rels->relation != NULL)
-			outer_inner_list = lappend(outer_inner_list,
-									   outer_inner_rels->relation);
-		else
-			outer_inner_list = list_concat(outer_inner_list,
-										   OuterInnerList(outer_inner_rels));
-	}
-	return outer_inner_list;
-}
-
 static Relids
 OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
-	PlannerInfo *root, List *initial_rels, HintState *hstate, int *njoinrels,
-	int nbaserel)
+	PlannerInfo *root, List *initial_rels, HintState *hstate, int nbaserel)
 {
 	OuterInnerRels *outer_rels;
 	OuterInnerRels *inner_rels;
@@ -2343,7 +2739,6 @@ OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
 
 	if (outer_inner->relation != NULL)
 	{
-		(*njoinrels)++;
 		return bms_make_singleton(
 					find_relid_aliasname(root, outer_inner->relation,
 										 initial_rels,
@@ -2358,19 +2753,17 @@ OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
 										root,
 										initial_rels,
 										hstate,
-										njoinrels,
 										nbaserel);
 	inner_relids = OuterInnerJoinCreate(inner_rels,
 										leading_hint,
 										root,
 										initial_rels,
 										hstate,
-										njoinrels,
 										nbaserel);
 
 	join_relids = bms_add_members(outer_relids, inner_relids);
 
-	if (bms_num_members(join_relids) > nbaserel || *njoinrels > nbaserel)
+	if (bms_num_members(join_relids) > nbaserel)
 		return join_relids;
 
 	/*
@@ -2395,8 +2788,8 @@ OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
 		hint->inner_nrels = bms_num_members(inner_relids);
 		hint->inner_joinrelids = bms_copy(inner_relids);
 
-		hstate->join_hint_level[*njoinrels] =
-			lappend(hstate->join_hint_level[*njoinrels], hint);
+		hstate->join_hint_level[hint->nrels] =
+			lappend(hstate->join_hint_level[hint->nrels], hint);
 	}
 	else
 	{
@@ -2415,10 +2808,9 @@ OuterInnerJoinCreate(OuterInnerRels *outer_inner, LeadingHint *leading_hint,
  *   - add join method hints which are necessary to enforce join order
  *     specified by Leading hint
  */
-static void
+static bool
 transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
-		List *initial_rels, JoinMethodHint **join_method_hints,
-		LeadingHint *lhint)
+		List *initial_rels, JoinMethodHint **join_method_hints)
 {
 	int				i;
 	int				relid;
@@ -2426,7 +2818,7 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
 	int				njoinrels;
 	ListCell	   *l;
 	char		   *relname;
-	bool			exist_effective_leading;
+	LeadingHint	   *lhint = NULL;
 
 	/*
 	 * Create bitmap of relids from alias names for each join method hint.
@@ -2476,30 +2868,23 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
 
 	/* Do nothing if no Leading hint was supplied. */
 	if (hstate->num_hints[HINT_TYPE_LEADING] == 0)
-		return;
+		return false;
 
 	/*
 	 * Decide to use Leading hint。
  	 */
-	exist_effective_leading = false;
-	for (i = hstate->num_hints[HINT_TYPE_LEADING] - 1; i >= 0; i--) {
-		LeadingHint *leading_hint = (LeadingHint *)hstate->leading_hint[i];
-
-		List *relname_list;
-		Relids	relids;
+	for (i = 0; i < hstate->num_hints[HINT_TYPE_LEADING]; i++)
+	{
+		LeadingHint	   *leading_hint = (LeadingHint *)hstate->leading_hint[i];
+		Relids			relids;
 
 		if (leading_hint->base.state == HINT_STATE_ERROR)
 			continue;
 
-		if (leading_hint->outer_inner != NULL)
-			relname_list = OuterInnerList(leading_hint->outer_inner);
-		else
-			relname_list = leading_hint->relations;
-
 		relid = 0;
-		relids = 0;
+		relids = NULL;
 
-		foreach(l, relname_list)
+		foreach(l, leading_hint->relations)
 		{
 			relname = (char *)lfirst(l);;
 
@@ -2525,21 +2910,19 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
 		if (relid <= 0 || leading_hint->base.state == HINT_STATE_ERROR)
 			continue;
 
-		if (exist_effective_leading)
+		if (lhint != NULL)
 		{
-			hint_ereport(leading_hint->base.hint_str,
-				 ("Conflict %s hint.", HintTypeName[leading_hint->base.type]));
-			leading_hint->base.state = HINT_STATE_DUPLICATION;
-		}
-		else
-		{
-			leading_hint->base.state = HINT_STATE_USED;
-			exist_effective_leading = true;
-			lhint = leading_hint;
+			hint_ereport(lhint->base.hint_str,
+				 ("Conflict %s hint.", HintTypeName[lhint->base.type]));
+			lhint->base.state = HINT_STATE_DUPLICATION;
 		}
+		leading_hint->base.state = HINT_STATE_USED;
+		lhint = leading_hint;
 	}
-	if (exist_effective_leading == false)
-		return;
+
+	/* check to exist Leading hint marked with 'used'. */
+	if (lhint == NULL)
+		return false;
 
 	/*
 	 * We need join method hints which fit specified join order in every join
@@ -2607,7 +2990,7 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
 		bms_free(joinrelids);
 
 		if (njoinrels < 2)
-			return;
+			return false;
 
 		/*
 		 * Delete all join hints which have different combination from Leading
@@ -2627,14 +3010,16 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
                                           root,
                                           initial_rels,
 										  hstate,
-                                         &njoinrels,
 										  nbaserel);
 
+		njoinrels = bms_num_members(joinrelids);
+		Assert(njoinrels >= 2);
+
 		/*
 		 * Delete all join hints which have different combination from Leading
 		 * hint.
 		 */
-		for (i = 2;i <= nbaserel; i++)
+		for (i = 2;i <= njoinrels; i++)
 		{
 			if (hstate->join_hint_level[i] != NIL)
 			{
@@ -2662,14 +3047,15 @@ transform_join_hints(HintState *hstate, PlannerInfo *root, int nbaserel,
 			}
 		}
 
-	bms_free(joinrelids);
-
-	if (njoinrels < 2)
-		return;
+		bms_free(joinrelids);
 	}
 
 	if (hint_state_enabled(lhint))
+	{
 		set_join_config_options(DISABLE_ALL_JOIN, current_hint->context);
+		return true;
+	}
+	return false;
 }
 
 /*
@@ -2886,10 +3272,10 @@ pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
 						 List *initial_rels)
 {
 	JoinMethodHint	  **join_method_hints;
-	LeadingHint		   *leading_hint = NULL;
 	int					nbaserel;
 	RelOptInfo		   *rel;
 	int					i;
+	bool				leading_hint_enable;
 
 	/*
 	 * Use standard planner (or geqo planner) if pg_hint_plan is disabled or no
@@ -2919,8 +3305,8 @@ pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
 	current_hint->join_hint_level = palloc0(sizeof(List *) * (nbaserel + 1));
 	join_method_hints = palloc0(sizeof(JoinMethodHint *) * (nbaserel + 1));
 
-	transform_join_hints(current_hint, root, nbaserel, initial_rels,
-						 join_method_hints, leading_hint);
+	leading_hint_enable = transform_join_hints(current_hint, root, nbaserel,
+											   initial_rels, join_method_hints);
 
 	rel = pg_hint_plan_standard_join_search(root, levels_needed, initial_rels);
 
@@ -2936,9 +3322,7 @@ pg_hint_plan_join_search(PlannerInfo *root, int levels_needed,
 	pfree(current_hint->join_hint_level);
 	pfree(join_method_hints);
 
-	if (current_hint->num_hints[HINT_TYPE_LEADING] > 0 &&
-		leading_hint != NULL &&
-		hint_state_enabled(leading_hint))
+	if (leading_hint_enable)
 		set_join_config_options(current_hint->init_join_mask,
 								current_hint->context);
 
@@ -2986,6 +3370,30 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 	}
 }
 
+static void
+pg_hint_plan_plpgsql_func_setup(PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt)
+{
+	(&plugin_funcs)->stmt_beg = pg_hint_plan_plpgsql_stmt_beg;
+	(&plugin_funcs)->stmt_end = pg_hint_plan_plpgsql_stmt_end;
+}
+
+static void
+pg_hint_plan_plpgsql_stmt_beg(PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt)
+{
+	if ((enum PLpgSQL_stmt_types) stmt->cmd_type == PLPGSQL_STMT_EXECSQL)
+	{
+		PLpgSQL_expr *expr = ((PLpgSQL_stmt_execsql *) stmt)->sqlstmt;
+		hint_query_string = expr->query;
+	}
+}
+
+static void
+pg_hint_plan_plpgsql_stmt_end(PLpgSQL_execstate *estate, PLpgSQL_stmt *stmt)
+{
+	if ((enum PLpgSQL_stmt_types) stmt->cmd_type == PLPGSQL_STMT_EXECSQL)
+		hint_query_string = NULL;
+}
+
 #define standard_join_search pg_hint_plan_standard_join_search
 #define join_search_one_level pg_hint_plan_join_search_one_level
 #define make_join_rel make_join_rel_wrapper