+ if (!ActiveSnapshotSet())
+ {
+ PushActiveSnapshot(GetTransactionSnapshot());
+ snapshot_set = true;
+ }
+
+ SPI_connect();
+
+ if (plan == NULL)
+ {
+ SPIPlanPtr p;
+ p = SPI_prepare(search_query, 2, argtypes);
+ plan = SPI_saveplan(p);
+ SPI_freeplan(p);
+ }
+
+ qry = cstring_to_text(client_query);
+ app = cstring_to_text(client_application);
+ values[0] = PointerGetDatum(qry);
+ values[1] = PointerGetDatum(app);
+
+ SPI_execute_plan(plan, values, nulls, true, 1);
+
+ if (SPI_processed > 0)
+ {
+ char *buf;
+
+ hints = SPI_getvalue(SPI_tuptable->vals[0],
+ SPI_tuptable->tupdesc, 1);
+ /*
+ * Here we use SPI_palloc to ensure that hints string is valid even
+ * after SPI_finish call. We can't use simple palloc because it
+ * allocates memory in SPI's context and that context is deleted in
+ * SPI_finish.
+ */
+ buf = SPI_palloc(strlen(hints) + 1);
+ strcpy(buf, hints);
+ hints = buf;
+ }
+
+ SPI_finish();
+
+ if (snapshot_set)
+ PopActiveSnapshot();
+
+ hint_inhibit_level--;
+ }
+ PG_CATCH();
+ {
+ hint_inhibit_level--;
+ PG_RE_THROW();
+ }
+ PG_END_TRY();
+
+ return hints;
+}
+
+/*
+ * Get client-supplied query string. Addtion to that the jumbled query is
+ * supplied if the caller requested. From the restriction of JumbleQuery, some
+ * kind of query needs special amendments. Reutrns NULL if this query doesn't
+ * change the current hint. This function returns NULL also when something
+ * wrong has happend and let the caller continue using the current hints.
+ */
+static const char *
+get_query_string(ParseState *pstate, Query *query, Query **jumblequery)
+{
+ const char *p = debug_query_string;
+
+ if (jumblequery != NULL)
+ *jumblequery = query;
+
+ if (query->commandType == CMD_UTILITY)
+ {
+ Query *target_query = (Query *)query->utilityStmt;
+
+ /*
+ * Some CMD_UTILITY statements have a subquery that we can hint on.
+ * Since EXPLAIN can be placed before other kind of utility statements
+ * and EXECUTE can be contained other kind of utility statements, these
+ * conditions are not mutually exclusive and should be considered in
+ * this order.
+ */
+ if (IsA(target_query, ExplainStmt))
+ {
+ ExplainStmt *stmt = (ExplainStmt *)target_query;
+
+ Assert(IsA(stmt->query, Query));
+ target_query = (Query *)stmt->query;
+
+ /* strip out the top-level query for further processing */
+ if (target_query->commandType == CMD_UTILITY &&
+ target_query->utilityStmt != NULL)
+ target_query = (Query *)target_query->utilityStmt;
+ }
+
+ if (IsA(target_query, DeclareCursorStmt))
+ {
+ DeclareCursorStmt *stmt = (DeclareCursorStmt *)target_query;
+ Query *query = (Query *)stmt->query;
+
+ /* the target must be CMD_SELECT in this case */
+ Assert(IsA(query, Query) && query->commandType == CMD_SELECT);
+ target_query = query;
+ }
+
+ if (IsA(target_query, CreateTableAsStmt))
+ {
+ CreateTableAsStmt *stmt = (CreateTableAsStmt *) target_query;
+
+ Assert(IsA(stmt->query, Query));
+ target_query = (Query *) stmt->query;
+
+ /* strip out the top-level query for further processing */
+ if (target_query->commandType == CMD_UTILITY &&
+ target_query->utilityStmt != NULL)
+ target_query = (Query *)target_query->utilityStmt;
+ }
+
+ if (IsA(target_query, ExecuteStmt))
+ {
+ /*
+ * Use the prepared query for EXECUTE. The Query for jumble
+ * also replaced with the corresponding one.
+ */
+ ExecuteStmt *stmt = (ExecuteStmt *)target_query;
+ PreparedStatement *entry;
+
+ entry = FetchPreparedStatement(stmt->name, true);
+ p = entry->plansource->query_string;
+ target_query = (Query *) linitial (entry->plansource->query_list);
+ }
+
+ /* JumbleQuery accespts only a non-utility Query */
+ if (!IsA(target_query, Query) ||
+ target_query->utilityStmt != NULL)
+ target_query = NULL;
+
+ if (jumblequery)
+ *jumblequery = target_query;
+ }
+ /* Return NULL if the pstate is not identical to the top-level query */
+ else if (strcmp(pstate->p_sourcetext, p) != 0)
+ p = NULL;
+
+ return p;
+}
+
+/*
+ * Get hints from the head block comment in client-supplied query string.
+ */
+static const char *
+get_hints_from_comment(const char *p)
+{
+ const char *hint_head;
+ char *head;
+ char *tail;
+ int len;
+
+ if (p == NULL)
+ return NULL;
+
+ /* extract query head comment. */
+ 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;
+ }