pgtt.c

/*-------------------------------------------------------------------------
 *
 * pgtt.c
 *	Add support to Oracle-style Global Temporary Table in PostgreSQL.
 *
 * Author: Gilles Darold <gilles@darold.net>
 * Licence: PostgreSQL
 * Copyright (c) 2018-2026, Gilles Darold,
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
#include <unistd.h>
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"

#include "access/htup_details.h"
#include "access/parallel.h"
#include "access/reloptions.h"
#include "access/sysattr.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_extension.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "catalog/toasting.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/extension.h"
#include "commands/tablecmds.h"
#include "commands/comment.h"
#include "executor/spi.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/nodes.h"
#include "nodes/pg_list.h"
#include "nodes/print.h"
#include "nodes/value.h"
#include "optimizer/paths.h"
#include "optimizer/plancat.h"
#include "parser/analyze.h"
#include "parser/parse_utilcmd.h"
#include "parser/parser.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/proc.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/varlena.h"

#if PG_VERSION_NUM < 110000
#include "utils/memutils.h"
#endif

/* for regexp search */
#include "regex/regexport.h"

#if (PG_VERSION_NUM >= 120000)
#include "access/genam.h"
#include "access/heapam.h"
#include "catalog/pg_class.h"
#endif

#if PG_VERSION_NUM < 120000
#error Minimum version of PostgreSQL required is 12
#endif

#define CATALOG_GLOBAL_TEMP_REL	"pg_global_temp_tables"
#define Anum_pgtt_relid   1
#define Anum_pgtt_nspname 2
#define Anum_pgtt_relname 3

PG_MODULE_MAGIC;

#define NOT_IN_PARALLEL_WORKER (ParallelWorkerNumber < 0)

#if PG_VERSION_NUM >= 140000
#define STMT_OBJTYPE(stmt) stmt->objtype
#else
#define STMT_OBJTYPE(stmt) stmt->relkind
#endif

/* Define ProcessUtility hook proto/parameters following the PostgreSQL version */
#if PG_VERSION_NUM >= 140000
#define GTT_PROCESSUTILITY_PROTO PlannedStmt *pstmt, const char *queryString, \
				       bool readOnlyTree, \
					ProcessUtilityContext context, ParamListInfo params, \
					QueryEnvironment *queryEnv, DestReceiver *dest, \
					QueryCompletion *qc
#define GTT_PROCESSUTILITY_ARGS pstmt, queryString, readOnlyTree, context, params, queryEnv, dest, qc
#else
#if PG_VERSION_NUM >= 130000
#define GTT_PROCESSUTILITY_PROTO PlannedStmt *pstmt, const char *queryString, \
					ProcessUtilityContext context, ParamListInfo params, \
					QueryEnvironment *queryEnv, DestReceiver *dest, \
					QueryCompletion *qc
#define GTT_PROCESSUTILITY_ARGS pstmt, queryString, context, params, queryEnv, dest, qc
#else
#if PG_VERSION_NUM >= 100000
#define GTT_PROCESSUTILITY_PROTO PlannedStmt *pstmt, const char *queryString, \
					ProcessUtilityContext context, ParamListInfo params, \
					QueryEnvironment *queryEnv, DestReceiver *dest, \
					char *completionTag
#define GTT_PROCESSUTILITY_ARGS pstmt, queryString, context, params, queryEnv, dest, completionTag
#elif PG_VERSION_NUM >= 90300
#define GTT_PROCESSUTILITY_PROTO Node *parsetree, const char *queryString, \
                                        ProcessUtilityContext context, ParamListInfo params, \
					DestReceiver *dest, char *completionTag
#define GTT_PROCESSUTILITY_ARGS parsetree, queryString, context, params, dest, completionTag
#else
#define GTT_PROCESSUTILITY_PROTO Node *parsetree, const char *queryString, \
                                        ParamListInfo params, bool isTopLevel, \
					DestReceiver *dest, char *completionTag
#define GTT_PROCESSUTILITY_ARGS parsetree, queryString, params, isTopLevel, dest, completionTag
#endif
#endif
#endif

/* Saved hook values in case of unload */
static ProcessUtility_hook_type prev_ProcessUtility = NULL;
static ExecutorStart_hook_type prev_ExecutorStart = NULL;
static post_parse_analyze_hook_type prev_post_parse_analyze_hook = NULL;
/* Hook to intercept CREATE GLOBAL TEMPORARY TABLE query */
static void gtt_ProcessUtility(GTT_PROCESSUTILITY_PROTO);
static void gtt_ExecutorStart(QueryDesc *queryDesc, int eflags);
#if PG_VERSION_NUM >= 190000
static void gtt_post_parse_analyze(ParseState *pstate, Query *query, const JumbleState *jstate);
#else
#if PG_VERSION_NUM >= 140000
static void gtt_post_parse_analyze(ParseState *pstate, Query *query, JumbleState *jstate);
#else
static void gtt_post_parse_analyze(ParseState *pstate, Query *query);
#endif
#endif
static void gtt_try_load(void);
#if PG_VERSION_NUM < 160000
Oid get_extension_schema(Oid ext_oid);
#endif
static bool is_declared_gtt(Oid relid);

/* Enable use of Global Temporary Table at session level */
static bool pgtt_is_enabled = true;

/* Regular expression search */
#define CREATE_GLOBAL_REGEXP "^\\s*CREATE\\s+(?:\\/\\*\\s*)?GLOBAL(?:\\s*\\*\\/)?"

/* Oid and name of pgtt extrension schema in the database */
static Oid pgtt_namespace_oid = InvalidOid;
static char pgtt_namespace_name[NAMEDATALEN];

/* In memory storage of GTT and state */
typedef struct Gtt
{
	Oid           relid;
	Oid           temp_relid;
	char          relname[NAMEDATALEN];
	bool          preserved;
	bool          created;
	char          *code;
} Gtt;

typedef struct relhashent
{
	char          name[NAMEDATALEN];
	Gtt           gtt;
} GttHashEnt;

static HTAB *GttHashTable = NULL;

/* Default size of the storage area for GTT but will be dynamically extended */
#define GTT_PER_DATABASE	16

#define GttHashTableDelete(NAME) \
do { \
        GttHashEnt *hentry; \
        \
        hentry = (GttHashEnt *) hash_search(GttHashTable, NAME, HASH_REMOVE, NULL); \
        if (hentry == NULL) \
                elog(DEBUG1, "trying to delete GTT entry in HTAB that does not exist"); \
} while(0)

#define GttHashTableLookup(NAME, GTT) \
do { \
	GttHashEnt *hentry; \
	\
	hentry = (GttHashEnt *) hash_search(GttHashTable, \
							   (NAME), HASH_FIND, NULL); \
	if (hentry) \
		GTT = hentry->gtt; \
} while(0)

#define GttHashTableInsert(GTT, NAME) \
do { \
        GttHashEnt *hentry; bool found; \
        \
        hentry = (GttHashEnt *) hash_search(GttHashTable, \
								   (NAME), HASH_ENTER, &found); \
        if (found) \
                elog(ERROR, "duplicate GTT name"); \
        hentry->gtt = GTT; \
        strlcpy(hentry->name, NAME, sizeof(hentry->name)); \
	elog(DEBUG1, "Insert GTT entry in HTAB, key: %s, relid: %d, temp_relid: %d, created: %d", hentry->gtt.relname, hentry->gtt.relid, hentry->gtt.temp_relid, hentry->gtt.created); \
} while(0)

/* Function declarations */

PGDLLEXPORT void	_PG_init(void);
PGDLLEXPORT void	_PG_fini(void);

static Oid gtt_create_table_statement(Gtt gtt);
static void gtt_create_table_as(Gtt gtt, bool skipdata);
static void gtt_unregister_global_temporary_table(const char *relname);
void GttHashTableDeleteAll(void);
bool EnableGttManager(void);
Gtt GetGttByName(const char *name);
static void gtt_load_global_temporary_tables(void);
static Oid create_temporary_table_internal(ParseState *pstate, Oid parent_relid, bool preserved);
static bool gtt_check_command(GTT_PROCESSUTILITY_PROTO);
static bool gtt_table_exists(QueryDesc *queryDesc);
void exitHook(int code, Datum arg);
static bool is_catalog_relid(Oid relid);
static void gtt_rewrite_rte(ParseState *pstate, Query *query, RangeTblEntry *rte);
static void gtt_rewrite_query(ParseState *pstate, Query *query);
static bool gtt_query_walker(Node *node, void *context);
static void gtt_exec_utility_subcommand(Node *stmt, const char *querystring);
static void gtt_copy_triggers(Oid parent_relid, const char *relname);
static void gtt_set_trigger_enabled(const char *relname, const char *tgname, char tgenabled);
static void force_pgtt_namespace (void);
#if PG_VERSION_NUM < 140000
static bool gtt_stmt_is_rewritten(Node *parsetree);
#endif
static void gtt_update_registered_table(Gtt gtt);
int strremovestr(char *src, char *toremove);
static void gtt_unregister_gtt_not_cached(const char *relname);
static bool gtt_tableelts_has_foreign_key(List *tableElts);
static bool gtt_current_user_can_drop(Oid relid);

/*
 * Module load callback
 */
void
_PG_init(void)
{
	elog(DEBUG1, "_PG_init()");

	if (ParallelWorkerNumber >= 0)
		return;

	/*
	 * If we are loaded via shared_preload_libraries exit.
	 */
	if (process_shared_preload_libraries_in_progress)
	{
		ereport(FATAL,
				(errmsg("The pgtt extension can not be loaded using shared_preload_libraries."),
				 errhint("Add 'pgtt' to session_preload_libraries globally, or"
						 " for the wanted roles or databases instead.")));
	}

	/*
 	 * Define (or redefine) custom GUC variables.
	 * No custom GUC variable at this time
	 */
	DefineCustomBoolVariable("pgtt.enabled",
							"Enable use of Global Temporary Table",
							"By default the extension is automatically enabled after load, "
							"it can be temporary disable by setting the GUC value to false "
							"then enable again later wnen necessary.",
							&pgtt_is_enabled,
							true,
							PGC_USERSET,
							0,
							NULL,
							NULL,
							NULL);

	/*
	 * Immediately try to load the extension.
	 *
	 * The GTT "template" tables are resolved through the search_path, which
	 * is only fixed by force_pgtt_namespace() once the extension has been
	 * loaded.  This must therefore be done before the very first command of
	 * the session goes through parse analysis, otherwise that command fails
	 * with "relation ... does not exist" when it references a GTT.
	 *
	 * With PostgreSQL 15 and above, process_session_preload_libraries() is
	 * called from InitPostgres(), inside the transaction started for the
	 * backend initialization, so gtt_try_load() can do its catalog lookups
	 * right away.  With PostgreSQL 14 and below the session preloaded
	 * libraries are loaded later, from PostgresMain(), after that transaction
	 * has been committed: gtt_try_load() would be a no-op there because
	 * IsTransactionState() returns false.  Start a transaction ourselves in
	 * this case.  The same applies when the library is loaded through a plain
	 * LOAD command outside of any transaction.
	 */
	if (IsTransactionState())
		gtt_try_load();
	else if (IsUnderPostmaster && OidIsValid(MyDatabaseId))
	{
		StartTransactionCommand();
		gtt_try_load();
		CommitTransactionCommand();
	}

	/*
	 * Install hooks.
	 */
	prev_ExecutorStart = ExecutorStart_hook;
	ExecutorStart_hook = gtt_ExecutorStart;
	prev_post_parse_analyze_hook = post_parse_analyze_hook;
	post_parse_analyze_hook = gtt_post_parse_analyze;

	prev_ProcessUtility = ProcessUtility_hook;
	ProcessUtility_hook = gtt_ProcessUtility;

	/* set the exit hook */
	on_proc_exit(&exitHook, PointerGetDatum(NULL));
}

/*
 * Module unload callback
 */
void
_PG_fini(void)
{
	elog(DEBUG1, "_PG_fini()");

	/* Uninstall hooks. */
	ExecutorStart_hook = prev_ExecutorStart;
	post_parse_analyze_hook = prev_post_parse_analyze_hook;
	ProcessUtility_hook = prev_ProcessUtility;
}

/*
 * Exit hook.
 */
void
exitHook(int code, Datum arg)
{
	elog(DEBUG1, "exiting with %d", code);
}

static void
gtt_ProcessUtility(GTT_PROCESSUTILITY_PROTO)
{
	elog(DEBUG1, "gtt_ProcessUtility()");

	/* Do not waste time here if the feature is not enabled for this session */
	if (pgtt_is_enabled && NOT_IN_PARALLEL_WORKER)
	{
		/* Try to load pgtt if not already done. */
		gtt_try_load();

		/*
		 * Be sure that extension schema is at end of the search path so that
		 * "template" tables will be find.
		 */
		force_pgtt_namespace();

		/*
		 * gtt_check_command() rewrites the parse tree of some statements
		 * (SET search_path and CREATE GLOBAL TEMPORARY TABLE ... AS).
		 * The tree we receive here can belong to a cached plan, in which
		 * case it must be considered read only: it is reused as is at the
		 * next execution of the same statement.  This is what happens for
		 * any statement executed inside a PL/pgSQL function.  Everything
		 * we would add to such a tree is allocated in a memory context
		 * that is reset at the end of the statement, so the next execution
		 * would read already freed memory.  Work on our own copy of the
		 * tree instead.
		 *
		 * Since PostgreSQL 14 the caller tells us through readOnlyTree
		 * whether the tree may be modified.  When it may not, we just take
		 * over the copy that standard_ProcessUtility() would have done
		 * anyway and clear the flag, so this costs nothing.  On previous
		 * versions there is no such flag and we copy the tree ourselves,
		 * but only for the statements that we can rewrite.
		 */
#if PG_VERSION_NUM >= 140000
		if (readOnlyTree)
		{
			pstmt = copyObject(pstmt);
			readOnlyTree = false;
		}
#elif PG_VERSION_NUM >= 100000
		if (gtt_stmt_is_rewritten(pstmt->utilityStmt))
			pstmt = copyObject(pstmt);
#else
		if (gtt_stmt_is_rewritten(parsetree))
			parsetree = copyObject(parsetree);
#endif

		/*
		 * Check if we have a CREATE GLOBAL TEMPORARY TABLE
		 * in this case do more work than the simple table
		 * creation see SQL file in sql/ subdirectory.
		 *
		 * If the current query use a GTT that is not already
		 * created create it.
		 */
		if (gtt_check_command(GTT_PROCESSUTILITY_ARGS))
		{
			elog(DEBUG1, "Work on GTT from Utility Hook done, get out of UtilityHook immediately.");
			return;
		}
	}

	elog(DEBUG1, "restore ProcessUtility");

	/* Excecute the utility command, we are not concerned */
	PG_TRY();
	{
		if (prev_ProcessUtility)
			prev_ProcessUtility(GTT_PROCESSUTILITY_ARGS);
		else
			standard_ProcessUtility(GTT_PROCESSUTILITY_ARGS);
	}
	PG_CATCH();
	{
		PG_RE_THROW();
	}
	PG_END_TRY();

	elog(DEBUG1, "End of gtt_ProcessUtility()");
}

/*
 * Walk a CREATE TABLE statement's column/constraint list looking for a
 * foreign key constraint, in either the table-level
 * "FOREIGN KEY (...) REFERENCES ..." form (a bare Constraint node in
 * tableElts) or the column-level "col type REFERENCES ..." form (a
 * Constraint node attached to a ColumnDef's own constraint list).
 * Replaces a previous text-regex search for the literal substring
 * "FOREIGN KEY", which only caught the table-level form.
 */
static bool
gtt_tableelts_has_foreign_key(List *tableElts)
{
	ListCell *lc;

	foreach(lc, tableElts)
	{
		Node *elt = (Node *) lfirst(lc);

		if (IsA(elt, Constraint))
		{
			Constraint *constr = (Constraint *) elt;

			if (constr->contype == CONSTR_FOREIGN)
				return true;
		}
		else if (IsA(elt, ColumnDef))
		{
			ColumnDef *coldef = (ColumnDef *) elt;
			ListCell  *lc2;

			foreach(lc2, coldef->constraints)
			{
				Constraint *constr = (Constraint *) lfirst(lc2);

				if (IsA(constr, Constraint) && constr->contype == CONSTR_FOREIGN)
					return true;
			}
		}
	}

	return false;
}

/*
 * Return true if the current user is allowed to DROP the given
 * relation (its owner, a role that inherits ownership rights, or a
 * superuser). Used before pgtt mutates the shared pg_global_temp_tables
 * catalog on behalf of a DROP TABLE statement that targets a relation
 * this backend hasn't cached locally, so that an unprivileged role
 * cannot deregister another user's Global Temporary Table simply by
 * naming it in a DROP TABLE statement that will itself go on to fail
 * PostgreSQL's own ownership check.
 */
static bool
gtt_current_user_can_drop(Oid relid)
{
	if (!OidIsValid(relid))
		return false;

	/*
	 * PostgreSQL 16 replaced the whole family of per-catalog
	 * pg_*_ownercheck() functions (including pg_class_ownercheck())
	 * with a single generic object_ownercheck(classid, objectid,
	 * roleid). Both are declared in utils/acl.h.
	 */
#if PG_VERSION_NUM >= 160000
	return object_ownercheck(RelationRelationId, relid, GetUserId());
#else
	return pg_class_ownercheck(relid, GetUserId());
#endif
}

#if PG_VERSION_NUM < 140000
/*
 * Return true when the statement is one of those whose parse tree is
 * modified by gtt_check_command(). Must be kept in sync with the rewrites
 * done in gtt_check_command(). Only used with PostgreSQL < 14 where the
 * ProcessUtility hook has no readOnlyTree flag to tell us whether the parse
 * tree can be modified.
 */
static bool
gtt_stmt_is_rewritten(Node *parsetree)
{
	if (parsetree == NULL)
		return false;

	switch (nodeTag(parsetree))
	{
		/* the pgtt schema is appended to the list of schemas */
		case T_VariableSetStmt:
		/* the relation is moved to the pgtt schema and set unlogged */
		case T_CreateTableAsStmt:
			return true;
		default:
			return false;
	}
}
#endif

/*
 * Look at utility command to search CREATE TABLE / DROP TABLE
 * and INSERT INTO statements to see if a Global Temporary Table
 * is concerned.
 * Return true if all work is done and the origin statement must
 * be forgotten. False mean that the statement must be processed
 * normally.
 */
static bool
gtt_check_command(GTT_PROCESSUTILITY_PROTO)
{
	bool	preserved = true;
	bool    work_completed = false;
	char	*name = NULL;
#if PG_VERSION_NUM >= 100000
	Node    *parsetree = pstmt->utilityStmt;
#endif

	Assert(parsetree != NULL);
	Assert(queryString != NULL);

	elog(DEBUG1, "gtt_check_command() on query: \"%s\"", queryString);

	if (GttHashTable == NULL)
		return false;

	/* Intercept CREATE / DROP TABLE statements */
	switch (nodeTag(parsetree))
	{
		case T_VariableSetStmt:
		{
			VariableSetStmt *stmt = (VariableSetStmt *) parsetree;

			/*
			 * Forcing search_path is not enough because it does not
			 * handle SET search_path TO ... statement. This code also
			 * add the PGTT schema if not present in the path
			 */
			if (stmt->kind == VAR_SET_VALUE &&
				strcmp(stmt->name, "search_path") == 0)
			{
				ListCell *l;
				bool     found = false;
				char    *nspname;

				if (stmt->args == NIL)
					break;

				nspname = get_namespace_name(pgtt_namespace_oid);
				if (nspname == NULL)
					break;

				foreach(l, stmt->args)
				{
					Node    *arg = (Node *) lfirst(l);
					A_Const *con;
					char    *val;

					if (!IsA(arg, A_Const))
						continue;
					con = (A_Const *) arg;
					if (!IsA(&con->val, String))
						continue;

					val = strVal(&con->val);
					if (strcmp(val, nspname) == 0)
						found = true;
				}

				/* append the extension schema to the arg list. */
				if (!found)
				{
					A_Const *newcon = makeNode(A_Const);

#if PG_VERSION_NUM < 150000
					newcon->val.type = T_String;
					newcon->val.val.str = pstrdup(nspname);
#else
					newcon->val.node.type = T_String;
					newcon->val.sval.sval = pstrdup(nspname);
#endif
					newcon->location = strlen(queryString);
					stmt->args = lappend(stmt->args, newcon);
				}
			}
		}
		break;

		case T_CreateTableAsStmt:
		{
			Gtt gtt;
			int i;
			CreateTableAsStmt *stmt = (CreateTableAsStmt *)parsetree;
			bool skipdata = stmt->into->skipData;
			bool regexec_result;

			/* Get the name of the relation */
			name = stmt->into->rel->relname;

			/*
			 * CREATE TABLE AS is similar as SELECT INTO,
			 * so avoid going further in this last case.
			 */
			if (stmt->is_select_into)
				break;

			/* do not proceed OBJECT_MATVIEW */
			if (STMT_OBJTYPE(stmt) != OBJECT_TABLE)
				break;

			/*
			 * Be sure to have CREATE TEMPORARY TABLE definition
			 */
			if (stmt->into->rel->relpersistence != RELPERSISTENCE_TEMP)
				break;

			/*
			 * We only take care here of statements with the GLOBAL keyword
			 * even if it is deprecated and generate a warning.
			 */
			regexec_result = RE_compile_and_execute(
					cstring_to_text(CREATE_GLOBAL_REGEXP),
					VARDATA_ANY(cstring_to_text((char *) queryString)),
					VARSIZE_ANY_EXHDR(cstring_to_text((char *) queryString)),
					REG_ADVANCED | REG_ICASE | REG_NEWLINE,
					DEFAULT_COLLATION_OID,
					0, NULL);


			if (!regexec_result)
				break;

			/*
			 * What to do at commit time for global temporary relations
			 * default is ON COMMIT PRESERVE ROWS (do nothing)
			 */
			if (stmt->into->onCommit == ONCOMMIT_DELETE_ROWS)
				preserved = false;

			/*
			 * Case of ON COMMIT DROP and GLOBAL TEMPORARY might not be
			 * allowed, this is the same as using a normal temporary table
			 * inside a transaction. Here the table should be dropped after
			 * commit so it will not survive a transaction.
			 * Throw an error to prevent the use of this clause.
			 */
			if (stmt->into->onCommit == ONCOMMIT_DROP)
				ereport(ERROR,
						(errmsg("use of ON COMMIT DROP with GLOBAL TEMPORARY is not allowed"),
						 errhint("Create a local temporary table inside a transaction instead, this is the default behavior.")));

			elog(DEBUG1, "Create table %s, rows persistance: %d",
						name, preserved);

			/* Force creation of the temporary table in our pgtt schema */
			stmt->into->rel->schemaname = pstrdup(pgtt_namespace_name);
			/* replace temporary state from the table to unlogged table */
			stmt->into->rel->relpersistence = RELPERSISTENCE_UNLOGGED;
			/* Do not copy data in the unlogged table */
			stmt->into->skipData = true;

			/*
			 * At this stage the unlogged table will be created with normal
			 * utility hook. What we need now is to register the table in
			 * the pgtt catalog table and create a normal temporary table
			 * using the original statement without the GLOBAL keyword
			 */
			gtt.relid = 0;
			gtt.temp_relid = 0;
			strlcpy(gtt.relname, name, sizeof(gtt.relname));
			gtt.preserved = preserved;
			gtt.created = false;
			/* Extract the AS ... code part from the query */
			gtt.code = pstrdup(queryString);
			for (i = 30; i < strlen(queryString) - 1; i++)
			{
				if (    isspace(queryString[i])
					&& (queryString[i+1] == 'A' || queryString[i+1] == 'a')
					&& (queryString[i+2] == 'S' || queryString[i+2] == 's')
					&& (isspace(queryString[i+3]) || queryString[i+3] == '(') )
					break;
			}
			if (i == strlen(queryString) - 1)
				elog(ERROR, "can not find AS keyword in this CREATE TABLE AS statement.");

			gtt.code += i;

			if (gtt.code[strlen(gtt.code) - 1] == ';')
				gtt.code[strlen(gtt.code) - 1] = 0;

			/* remove WITH DATA from the code */
			strremovestr(gtt.code, "WITH DATA");

			/* Create the necessary object to emulate the GTT */
			gtt_create_table_as(gtt, skipdata);

			work_completed = true;

			break;
		}

		case T_CreateStmt:
		{
			/* CREATE TABLE statement */
			CreateStmt *stmt = (CreateStmt *)parsetree;
			Gtt        gtt;
			int        len, i, start = 0, end = 0;
			bool regexec_result;

			/* Get the name of the relation */
			name = stmt->relation->relname;

			/*
			 * Be sure to have CREATE TEMPORARY TABLE definition
			 */
			if (stmt->relation->relpersistence != RELPERSISTENCE_TEMP)
				break;

			/*
			 * We only take care here of statements with the GLOBAL keyword
			 * even if it is deprecated and generate a warning.
			 */
			regexec_result = RE_compile_and_execute(
					cstring_to_text(CREATE_GLOBAL_REGEXP),
					VARDATA_ANY(cstring_to_text((char *) queryString)),
					VARSIZE_ANY_EXHDR(cstring_to_text((char *) queryString)),
					REG_ADVANCED | REG_ICASE | REG_NEWLINE,
					DEFAULT_COLLATION_OID,
					0, NULL);

			if (!regexec_result)
				break;

			/*
			 * Check if there is a foreign key defined in the statement.
			 * A text-regex search for the literal substring "FOREIGN KEY"
			 * only catches the table-level "FOREIGN KEY (...) REFERENCES
			 * ..." form; it misses the equally valid column-level
			 * "col type REFERENCES ..." form, which contains no such
			 * substring at all and would silently slip through. Inspect
			 * the parsed column/constraint list instead so both forms
			 * are caught, matching how the ALTER TABLE handler below
			 * already checks parsed Constraint nodes rather than text.
			 */
			if (gtt_tableelts_has_foreign_key(stmt->tableElts))
				ereport(ERROR,
						(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
						 errmsg("attempt to create referential integrity constraint on global temporary table")));


#if (PG_VERSION_NUM >= 100000)
			/*
			 * We do not allow partitioning on GTT, not that PostgreSQL can
			 * not do it but because we want to mimic the Oracle or other
			 * RDBMS behavior.
			 */
			if (stmt->partspec != NULL)
				elog(ERROR, "Global Temporary Table do not support partitioning.");
#endif

			/*
			 * What to do at commit time for global temporary relations
			 * default is ON COMMIT PRESERVE ROWS (do nothing)
			 */
			if (stmt->oncommit == ONCOMMIT_DELETE_ROWS)
				preserved = false;

			/*
			 * Case of ON COMMIT DROP and GLOBAL TEMPORARY might not be
			 * allowed, this is the same as using a normal temporary table
			 * inside a transaction. Here the table should be dropped after
			 * commit so it will not survive a transaction.
			 * Throw an error to prevent the use of this clause.
			 */
			if (stmt->oncommit == ONCOMMIT_DROP)
				ereport(ERROR,
						(errmsg("use of ON COMMIT DROP with GLOBAL TEMPORARY is not allowed"),
						 errhint("Create a local temporary table inside a transaction instead, this is the default behavior.")));

			elog(DEBUG1, "Create table %s, rows persistance: %d",
						name, preserved);

			/* Create the Global Temporary Table template and register the table */
			gtt.relid = 0;
			gtt.temp_relid = 0;
			strlcpy(gtt.relname, name, sizeof(gtt.relname));
			gtt.preserved = preserved;
			gtt.created = false;
			gtt.code = NULL;

			/* Extract the definition of the table */
			for (i = 0; i < strlen(queryString); i++)
			{
				if (queryString[i] == '(')
				{
					start = i;
					break;
				}
			}
			start++;
			for (i = start; i < strlen(queryString); i++)
			{
				if (queryString[i] == ')')
				{
					end = i;
				}
			}

			len = end - start;
			if (end > 0 && start > 0)
			{
				gtt.code = palloc0(sizeof(char *) * (len + 1));
				strncpy(gtt.code, queryString+start, len);
				gtt.code[len] = '\0';
			}

			elog(DEBUG1, "code for Global Temporary Table \"%s\" creation is \"%s\"", gtt.relname, gtt.code);

			/* Create the necessary object to emulate the GTT */
			gtt.relid = gtt_create_table_statement(gtt);

			/*
			 * In case of problem during GTT creation previous function
			 * call throw an error so the code that's follow is safe.
			 * Update GTT cache with table flagged as created
			 */
			gtt.created = false;
			GttHashTableDelete(gtt.relname);
			GttHashTableInsert(gtt, gtt.relname);
			work_completed = true;

			elog(DEBUG1, "Global Temporary Table \"%s\" created", gtt.relname);
			break;
		}

		case T_DropStmt:
		{
			DropStmt *drop = (DropStmt *) parsetree;
			if (drop->removeType == OBJECT_TABLE)
			{
				List *relationNameList = NULL;
				int relationNameListLength = 0;
#if PG_VERSION_NUM < 150000
				Value *relationSchemaNameValue = NULL;
				Value *relationNameValue = NULL;
#else
				String *relationSchemaNameValue = NULL;
				String *relationNameValue = NULL;
#endif
				Gtt gtt;

				relationNameList = list_copy((List *) linitial(drop->objects));
				relationNameListLength = list_length(relationNameList);

				switch (relationNameListLength)
				{
					case 1:
					{
						relationNameValue = linitial(relationNameList);
						break;
					}
					case 2:
					{
						relationSchemaNameValue = linitial(relationNameList);
						relationNameValue = lsecond(relationNameList);
						break;
					}
					case 3:
					{
						relationSchemaNameValue = lsecond(relationNameList);
						relationNameValue = lthird(relationNameList);
						break;
					}
					default:
					{
						ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR),
										errmsg("improper relation name: \"%s\"",
											   NameListToString(relationNameList))));
						break;
					}
				}

				/* prefix with schema name if it is not added already */
				if (relationSchemaNameValue == NULL)
				{
#if PG_VERSION_NUM < 150000
					Value *schemaNameValue = makeString(pgtt_namespace_name);
#else
					String *schemaNameValue = makeString(pgtt_namespace_name);
#endif
					relationNameList = lcons(schemaNameValue, relationNameList);
				}

				/*
				 * Check if the table is in the hash list, drop
				 * it if it has already been be created and remove
				 * the cache entry.
				 */
#if PG_VERSION_NUM < 150000
				if (PointerIsValid(relationNameValue->val.str))
#else
				if ((const void*)relationNameValue->sval != NULL)
#endif
				{
#if PG_VERSION_NUM < 150000
					elog(DEBUG1, "looking for dropping table: %s", relationNameValue->val.str);
#else
					elog(DEBUG1, "looking for dropping table: %s", relationNameValue->sval);
#endif
					/* Initialize Gtt object */
					gtt.relid = 0;
					gtt.temp_relid = 0;
					gtt.relname[0] = '\0';
					gtt.preserved = false;
					gtt.code = NULL;
					gtt.created = false;

#if PG_VERSION_NUM < 150000
					elog(DEBUG1, "looking if table %s is a cached GTT", relationNameValue->val.str);
					GttHashTableLookup(relationNameValue->val.str, gtt);
#else
					elog(DEBUG1, "looking if table %s is a cached GTT", relationNameValue->sval);
					GttHashTableLookup(relationNameValue->sval, gtt);
#endif
					if (gtt.relname[0] != '\0')
					{
						/*
						 * When the temporary table have been created
						 * we can not remove the GTT in the same session.
						 * Creating and dropping GTT can only be performed
						 * by a superuser in a "maintenance" session.
						 */
						if (gtt.created)
							elog(ERROR, "can not drop a GTT that is in use.");
						/*
						 * Unregister the Global Temporary Table and its link to the
						 * view stored in pg_global_temp_tables table
						 */
						gtt_unregister_global_temporary_table(gtt.relname);

						/* Remove the table from the hash table */
						GttHashTableDelete(gtt.relname);
					}
					else
					{
						/*
						 * Table is not on current session cache but remove
						 * it from PGTT list if it exists.
						 */
#if PG_VERSION_NUM < 150000
						elog(DEBUG1, "looking if table %s is registered as GTT", relationNameValue->val.str);
						gtt_unregister_gtt_not_cached(relationNameValue->val.str);
#else
						elog(DEBUG1, "looking if table %s is registered as GTT", relationNameValue->sval);
						gtt_unregister_gtt_not_cached(relationNameValue->sval);
#endif
					}
				}
			}
			break;
		}

		case T_RenameStmt:
		{
			/* CREATE TABLE statement */
			RenameStmt *stmt = (RenameStmt *)parsetree;
			Gtt        gtt;

			/* We only take care of tabe renaming to update our internal storage */
			if (stmt->renameType != OBJECT_TABLE || stmt->newname == NULL)
				break;

			gtt.relid = 0;
			/* Look if the table is declared as GTT */
			GttHashTableLookup(stmt->relation->relname, gtt);

			/* Not registered as a GTT, nothing to do here */
			if (gtt.relid == 0)
				break;

			/* If a temporary table have already created do not allow changing name */
			if (gtt.created)
				elog(ERROR, "a temporary table has been created and is active, can not rename the GTT table in this session.");

			/* Rename the table and get the resulting new Oid */
			RenameRelation(stmt);

			elog(DEBUG1, "updating registered table in %s.pg_global_temp_tables.", pgtt_namespace_name);
			strlcpy(gtt.relname, stmt->newname, sizeof(gtt.relname));
			gtt_update_registered_table(gtt);

			/* Delete and recreate the table in cache */
			GttHashTableDelete(stmt->relation->relname);
			GttHashTableInsert(gtt, stmt->newname);
			work_completed = true;

			break;
		}

		case T_CommentStmt:
		{
			/* COMMENT ON TABLE/COLUMN statement */
			CommentStmt   *stmt = (CommentStmt *)parsetree;
			Relation      relation;
			char          *nspname;

			/* We only take care of comment on table or column to update our internal storage */
			if (stmt->objtype != OBJECT_TABLE && stmt->objtype != OBJECT_COLUMN)
				break;

			/*
			 * Get the relation object by calling get_object_address().
			 * get_object_address() will throw an error if the object
			 * does not exist, and will also acquire a lock on the target
			 * to guard against concurrent DROP operations.
			 */
#if (PG_VERSION_NUM < 100000)
			(void) get_object_address(stmt->objtype, stmt->objname, stmt->objargs,
										 &relation, ShareUpdateExclusiveLock, false);
#else
			(void) get_object_address(stmt->objtype, stmt->object,
										&relation, ShareUpdateExclusiveLock, false);
#endif

			/* Just take care that the GTT is not in use */
			nspname = get_namespace_name(RelationGetNamespace(relation));
			relation_close(relation, NoLock);
			if (strcmp(nspname, pgtt_namespace_name) != 0)
			{
				if (strstr(nspname, "pg_temp") != NULL)
					elog(ERROR, "a temporary table has been created and is active, can not add a comment on the GTT table in this session.");
			}

			break;
		}

		case T_AlterTableStmt:
		{
			/* Look for contrainst statement */
			AlterTableStmt   *stmt = (AlterTableStmt *)parsetree;
			ListCell   *lcmd;
			Gtt        gtt;

			if (STMT_OBJTYPE(stmt) != OBJECT_TABLE)
				break;

			/* Look if the table is declared as GTT */
			gtt.relid = 0;
			GttHashTableLookup(stmt->relation->relname, gtt);

			/* Not registered as a GTT, nothing to do here */
			if (gtt.relid == 0)
				break;

			/* We do not allow foreign keys on global temporary table */
			foreach(lcmd, stmt->cmds)
			{
				AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);

				if (cmd->subtype == AT_AddConstraint
#if (PG_VERSION_NUM < 130000)
						|| cmd->subtype == AT_ProcessedConstraint
#endif
				   )
				{
					Constraint *constr = (Constraint *) cmd->def;
					if (constr->contype == CONSTR_FOREIGN)
						ereport(ERROR,
								(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
								 errmsg("attempt to create referential integrity constraint on global temporary table")));
				}
			}

			break;
		}

		case T_IndexStmt:
		{
			/* CREATE INDEX statement */
			IndexStmt  *stmt = (IndexStmt *) parsetree;
			Oid        relid;
			Oid        nspid;
			char       *nspname;
			LOCKMODE lockmode = ShareLock;
			/*
			 * PATCH: Support CREATE INDEX CONCURRENTLY on active GTT instances.
			 * We use ShareUpdateExclusiveLock to avoid blocking reads/writes
			 * on the active session's data.
			 */
			if (stmt->concurrent)
				lockmode = ShareUpdateExclusiveLock;
			relid = RangeVarGetRelidExtended(stmt->relation, lockmode,
#if (PG_VERSION_NUM >= 110000)
				       					0,
#else
									false, false,
#endif
									RangeVarCallbackOwnsRelation,
									NULL);

			/*
			 * Ensure that the global temporary table (GTT) is not currently in use.
			 * A GTT is considered "in use" only when its corresponding local temporary
			 * table has been created in the session.
			 */
			nspid = get_rel_namespace(relid);
			nspname = get_namespace_name(nspid);
			if (is_declared_gtt(relid))
			{
				if (strcmp(nspname, pgtt_namespace_name) != 0)
				{
					if (isTempNamespace(nspid))
					{
						if (!stmt->concurrent)
							ereport(ERROR, (errmsg("a temporary table has been created and is active, can not add an index on the GTT table in this session.")));
					}
				}
			}

			break;
		}

		default:
			break;
	}
	return work_completed;
}

static void
gtt_ExecutorStart(QueryDesc *queryDesc, int eflags)
{
	elog(DEBUG1, "gtt_ExecutorStart()");

	/* Do not waste time here if the feature is not enabled for this session */
	if (pgtt_is_enabled && NOT_IN_PARALLEL_WORKER)
	{
		/* Try to load pgtt if not already done. */
		gtt_try_load();

		/* check if we are working on a GTT and create it if it doesn't exist */
		if (queryDesc->operation == CMD_INSERT
				|| queryDesc->operation == CMD_DELETE
				|| queryDesc->operation == CMD_UPDATE
				|| queryDesc->operation == CMD_SELECT)
		{
			/* Verify if a GTT table is defined, create it if this is not already the case */
			if (gtt_table_exists(queryDesc))
				elog(DEBUG1, "ExecutorStart() statement use a Global Temporary Table");
		}
	}

	elog(DEBUG1, "restore ExecutorStart()");

	/* Continue the normal behavior */
	if (prev_ExecutorStart)
		prev_ExecutorStart(queryDesc, eflags);
	else
		standard_ExecutorStart(queryDesc, eflags);

	elog(DEBUG1, "End of gtt_ExecutorStart()");
}

static bool
gtt_table_exists(QueryDesc *queryDesc)
{
	bool    is_gtt = false;
	char    *name = NULL;
	char    relpersistence;
	RangeTblEntry *rte;
	Relation      rel;
	Gtt           gtt;
	PlannedStmt *pstmt = (PlannedStmt *) queryDesc->plannedstmt;

	if (GttHashTable == NULL || !pstmt)
		return false;

	/* no relation in rtable probably a function call */
	if (list_length(pstmt->rtable) == 0)
		return false;

	/* This must be a valid relation and not a temporary table */
	rte = (RangeTblEntry *) linitial(pstmt->rtable);
	if (rte->relid != InvalidOid && rte->relkind == RELKIND_RELATION
				&& !is_catalog_relid(rte->relid))
	{
#if (PG_VERSION_NUM >= 120000)
		rel = table_open(rte->relid, NoLock);
#else
		rel = heap_open(rte->relid, NoLock);
#endif
		name = RelationGetRelationName(rel);
		relpersistence = rel->rd_rel->relpersistence;
#if (PG_VERSION_NUM >= 120000)
		table_close(rel, NoLock);
#else
		heap_close(rel, NoLock);
#endif

		/* Do not go further with temporary tables, catalog or toast table */
		if (relpersistence != RELPERSISTENCE_TEMP)
			return false;

		gtt.relid = 0;
		gtt.temp_relid = 0;
		gtt.relname[0] = '\0';
		gtt.preserved = false;
		gtt.code = NULL;
		gtt.created = false;

		/* Check if the table is in the hash list and it has not already be created */
		if ((const void*)name != NULL)
			GttHashTableLookup(name, gtt);

		elog(DEBUG1, "gtt_table_exists() looking for table \"%s\" with relid %d into cache.", name, rte->relid);
		if (gtt.relname[0] != '\0')
		{
			elog(DEBUG1, "GTT found in cache with name: %s, relid: %d, temp_relid %d", gtt.relname, gtt.relid, gtt.temp_relid);
			/* Create the temporary table if it does not exists */
			if (!gtt.created)
			{
				ParseState *pstate = make_parsestate(NULL);

				elog(DEBUG1, "global temporary table does not exists create it: %s", gtt.relname);
				/* Call create temporary table */
				if ((gtt.temp_relid = create_temporary_table_internal(pstate, gtt.relid, gtt.preserved)) != InvalidOid)
				{
					elog(DEBUG1, "global temporary table %s (oid: %d) created", gtt.relname, gtt.temp_relid);
					/* Update hash list with table flagged as created */
					gtt.created = true;
					GttHashTableDelete(gtt.relname);
					GttHashTableInsert(gtt, gtt.relname);
					free_parsestate(pstate);
				}
				else
					elog(ERROR, "can not create global temporary table %s", gtt.relname);
			}
			is_gtt = true;
		}
		else
			/* the table is not a global temporary table do nothing*/
			elog(DEBUG1, "table \"%s\" not registered as GTT", name);
	}

	return is_gtt;
}

static bool
is_declared_gtt(Oid relid)
{
	char    *name = NULL;
	char    relpersistence;
	Relation      rel;
	Gtt           gtt;

	if (GttHashTable == NULL)
		return false;

	/* This must be a valid relation and not a temporary table */
	if (relid != InvalidOid && !is_catalog_relid(relid))
	{
#if (PG_VERSION_NUM >= 120000)
		rel = table_open(relid, NoLock);
#else
		rel = heap_open(relid, NoLock);
#endif
		name = RelationGetRelationName(rel);
		relpersistence = rel->rd_rel->relpersistence;
#if (PG_VERSION_NUM >= 120000)
		table_close(rel, NoLock);
#else
		heap_close(rel, NoLock);
#endif

		/* Do not go further with temporary tables, catalog or toast table */
		if (relpersistence != RELPERSISTENCE_TEMP)
			return false;

		/* Check if the table is in the hash list and it has not already be created */
		gtt.relid = 0;
		gtt.temp_relid = 0;
		gtt.relname[0] = '\0';
		gtt.preserved = false;
		gtt.code = NULL;
		gtt.created = false;

		if ((const void*)name != NULL)
			GttHashTableLookup(name, gtt);

		if (gtt.relname[0] != '\0')
			return true;
	}

	return false;
}

/*
 * Create the Global Temporary Table with all associated objects
 * by creating the template table and register the GTT in the
 * pg_global_temp_tables table.
 *
 */
static Oid
gtt_create_table_statement(Gtt gtt)
{
	char    *newQueryString = NULL;
	int     connected = 0;
	int     finished = 0;
	int     result = 0;
	Oid     gttOid = InvalidOid;
	Datum   oidDatum;
	bool    isnull;

	elog(DEBUG1, "proceeding to Global Temporary Table creation.");

	connected = SPI_connect();
	if (connected != SPI_OK_CONNECT)
		ereport(ERROR, (errmsg("could not connect to SPI manager")));

	/* Create the "template" table */
	newQueryString = psprintf("CREATE UNLOGGED TABLE %s.%s (%s)",
			quote_identifier(pgtt_namespace_name),
			quote_identifier(gtt.relname),
			gtt.code);
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

	/* Get Oid of the newly created table */
	newQueryString = psprintf("SELECT c.relfilenode FROM pg_class c JOIN pg_namespace n ON (c.relnamespace=n.oid) WHERE c.relname=%s AND n.nspname = %s",
			quote_literal_cstr(gtt.relname),
			quote_literal_cstr(pgtt_namespace_name));

	result = SPI_exec(newQueryString, 0);
	if (result != SPI_OK_SELECT || SPI_processed != 1)
		ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

	oidDatum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull);

	if (!isnull)
		gttOid = DatumGetInt32(oidDatum);

	if (isnull || !OidIsValid(gttOid))
		ereport(ERROR,
				(errmsg("can not get OID of newly created GTT template table %s",
							quote_identifier(gtt.relname))));

	/* Now register the GTT table */
	newQueryString = psprintf("INSERT INTO %s.pg_global_temp_tables VALUES (%d, %s, %s, '%c', %s)",
			quote_identifier(pgtt_namespace_name),
			gttOid,
			quote_literal_cstr(pgtt_namespace_name),
			quote_literal_cstr(gtt.relname),
			(gtt.preserved) ? 't' : 'f',
			quote_literal_cstr(gtt.code)
		);
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR, (errmsg("can not registrer new global temporary table")));

	/*
	 * Set privilege on the unlogged table. Only SELECT is granted to
	 * PUBLIC here (previously ALL was granted, which let any role
	 * INSERT/UPDATE/DELETE/TRUNCATE data in this table, and attach
	 * triggers to it, regardless of ownership). SELECT is kept so the
	 * documented "SET pgtt.enabled TO off; SELECT * FROM <schema>.<t>"
	 * diagnostic pattern keeps working for any role.
	 */
	newQueryString = psprintf("GRANT SELECT ON TABLE %s.%s TO public",
			quote_identifier(pgtt_namespace_name),
			quote_identifier(gtt.relname));
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));


	/* Mark the GTT as been created before register the table in the cache */
	gtt.created = true;

	finished = SPI_finish();
	if (finished != SPI_OK_FINISH)
		ereport(ERROR, (errmsg("could not disconnect from SPI manager")));

	return gttOid;
}

/*
 * Unregister a Global Temporary Table in pg_global_temp_tables table
 * using his relid.
 */
static void
gtt_unregister_global_temporary_table(const char *relname)
{
	RangeVar     *rv;
	Relation      rel;
	ScanKeyData   key[1];
	SysScanDesc   scan;
	HeapTuple     tuple;

	elog(DEBUG1, "Looking for registered GTT relname = %s", relname);

	/* Set and open the GTT relation */
	rv = makeRangeVar(pgtt_namespace_name, CATALOG_GLOBAL_TEMP_REL, -1);
#if (PG_VERSION_NUM >= 120000)
	rel = table_openrv(rv, RowExclusiveLock);
#else
	rel = heap_openrv(rv, RowExclusiveLock);
#endif
	/* Define scanning */
	ScanKeyInit(&key[0], Anum_pgtt_relname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(relname));

	/* Start search of relation */
	scan = systable_beginscan(rel, 0, true, NULL, 1, key);
	/* Remove the tuples. */
	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
	{
		elog(DEBUG1, "removing tuple with relname = %s", relname);
		simple_heap_delete(rel, &tuple->t_self);
	}
	/* Cleanup. */
	systable_endscan(scan);
#if (PG_VERSION_NUM >= 120000)
	table_close(rel, RowExclusiveLock);
#else
	heap_close(rel, RowExclusiveLock);
#endif
}

/*
 * Unregister a Global Temporary Table in pg_global_temp_tables table
 * that is not cached and using his name only.
 */
static void
gtt_unregister_gtt_not_cached(const char *relname)
{
	RangeVar     *rv;
	Relation      rel;
	ScanKeyData   key[1];
	SysScanDesc   scan;
	HeapTuple     tuple;

	elog(DEBUG1, "Looking for registered GTT relname = %s", relname);

	/* Set and open the GTT relation */
	rv = makeRangeVar(pgtt_namespace_name, CATALOG_GLOBAL_TEMP_REL, -1);
#if (PG_VERSION_NUM >= 120000)
	rel = table_openrv(rv, RowExclusiveLock);
#else
	rel = heap_openrv(rv, RowExclusiveLock);
#endif
	/* Define scanning */
	ScanKeyInit(&key[0], Anum_pgtt_relname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(relname));

	/* Start search of relation */
	scan = systable_beginscan(rel, 0, true, NULL, 1, key);
	/*
	 * Remove the tuples, but only those the current user is actually
	 * allowed to drop. Previously this deleted any matching row
	 * unconditionally, before PostgreSQL's own ownership check on the
	 * subsequent DROP TABLE ever ran -- letting any authenticated role
	 * deregister another user's Global Temporary Table simply by
	 * naming it in a DROP TABLE statement, even though that statement
	 * would itself go on to fail with a permission error.
	 */
	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
	{
		bool  isnull;
		Datum relidDatum = heap_getattr(tuple, Anum_pgtt_relid, RelationGetDescr(rel), &isnull);

		if (isnull || !gtt_current_user_can_drop(DatumGetInt32(relidDatum)))
		{
			systable_endscan(scan);
#if (PG_VERSION_NUM >= 120000)
			table_close(rel, RowExclusiveLock);
#else
			heap_close(rel, RowExclusiveLock);
#endif
			ereport(ERROR,
					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
					 errmsg("must be owner of Global Temporary Table \"%s\" to drop it", relname)));
		}

		elog(DEBUG1, "removing tuple with relname = %s", relname);
		simple_heap_delete(rel, &tuple->t_self);
	}

	/* Cleanup. */
	systable_endscan(scan);
#if (PG_VERSION_NUM >= 120000)
	table_close(rel, RowExclusiveLock);
#else
	heap_close(rel, RowExclusiveLock);
#endif
}

/*
 * Check if pgtt hasn't been loaded yet, and try to load it in that case.
 */
static void
gtt_try_load(void)
{
	/*
	 * Don't try to load if the extension is disabled, if we can't do it now or
	 * if it's already loaded.
	 */
	if (!pgtt_is_enabled || !IsTransactionState() || GttHashTable != NULL)
		return;

	/* Initialize list of Global Temporary Table */
	if (EnableGttManager())
	{
		/*
		 * Load temporary table definition from pg_global_temp_tables table
		 * into our Hash table and pre-create the temporary tables.
		 */
		gtt_load_global_temporary_tables();

		/*
		 * Be sure that extension schema is at end of the search path so that
		 * "template" tables will be found.
		 */
		force_pgtt_namespace();
	}
}

#if PG_VERSION_NUM < 160000
/*
 * From src/backend/commands/extension.c
 */
Oid
get_extension_schema(Oid ext_oid)
{
	Oid                     result;
	Relation        rel;
	SysScanDesc scandesc;
	HeapTuple       tuple;
	ScanKeyData entry[1];

#if (PG_VERSION_NUM >= 120000)
	rel = table_open(ExtensionRelationId, AccessShareLock);
#else
	rel = heap_open(ExtensionRelationId, AccessShareLock);
#endif

	ScanKeyInit(&entry[0],
#if (PG_VERSION_NUM >= 120000)
				Anum_pg_extension_oid,
#else
				ObjectIdAttributeNumber,
#endif
				BTEqualStrategyNumber, F_OIDEQ,
				ObjectIdGetDatum(ext_oid));

	scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
								  NULL, 1, entry);

	tuple = systable_getnext(scandesc);

	/* We assume that there can be at most one matching tuple */
	if (HeapTupleIsValid(tuple))
		result = ((Form_pg_extension) GETSTRUCT(tuple))->extnamespace;
	else
		result = InvalidOid;

	systable_endscan(scandesc);

#if (PG_VERSION_NUM >= 120000)
	table_close(rel, AccessShareLock);
#else
	heap_close(rel, AccessShareLock);
#endif

	return result;
}
#endif


/*
 * EnableGttManager
 *              Enables the GTT management cache at backend startup.
 */
bool
EnableGttManager(void)
{
	Oid extOid = get_extension_oid("pgtt", true);
	RangeVar *rv;
	char *nspname;

	if (!OidIsValid(extOid))
		return false;

	pgtt_namespace_oid = get_extension_schema(extOid);
	if (!OidIsValid(pgtt_namespace_oid))
		elog(ERROR, "namespace %d can not be found.", pgtt_namespace_oid);

	/*
	 * Check if the GTT relation also exist. We might be in the middle of the
	 * extension creation, where the line in pg_extension exists but not the
	 * rest of SQL objects.
	 */
	nspname = get_namespace_name(pgtt_namespace_oid);
	rv = makeRangeVar(nspname, CATALOG_GLOBAL_TEMP_REL, -1);

	if (!OidIsValid(RangeVarGetRelid(rv, AccessShareLock, true)))
		return false;

	if (GttHashTable == NULL)
	{
		HASHCTL         ctl;

		MemSet(&ctl, 0, sizeof(ctl));
		ctl.keysize = NAMEDATALEN;
		ctl.entrysize = sizeof(GttHashEnt);

		/* allocate GTT Cache in the cache context */
		ctl.hcxt = CacheMemoryContext;
		GttHashTable = hash_create("Global Temporary Table hash list",
									GTT_PER_DATABASE,
									&ctl,
#if PG_VERSION_NUM >= 140000
									HASH_STRINGS | HASH_ELEM | HASH_CONTEXT
#else
									HASH_ELEM | HASH_CONTEXT
#endif
						);
		elog(DEBUG1, "GTT cache initialized.");
	}

	/*
	 * Set the OID and name of the extension schema, all objects will be
	 * created in this schema.
	 */
	strlcpy(pgtt_namespace_name, nspname, sizeof(pgtt_namespace_name));

	return true;
}

/*
 * Delete all declared Global Temporary Table.
 *
 */
void
GttHashTableDeleteAll(void)
{
	HASH_SEQ_STATUS status;
	GttHashEnt *lentry = NULL;

	if (GttHashTable == NULL)
		return;

	hash_seq_init(&status, GttHashTable);
	while ((lentry = (GttHashEnt *) hash_seq_search(&status)) != NULL)
	{
		Gtt          gtt = GetGttByName(lentry->name);

		elog(DEBUG1, "Remove GTT %s from our hash table", gtt.relname);
		GttHashTableDelete(lentry->name);
		/* Restart the iteration in case that led to other drops */
		hash_seq_term(&status);
		hash_seq_init(&status, GttHashTable);
	}
}

/*
 * GetGttByName
 *       Returns a Gtt given a table name, or NULL if name is not found.
 *
 * Caller should have made sure that GTT has been properly loaded before
 * calling this function.
 */
Gtt
GetGttByName(const char *name)
{
	Gtt          gtt;

	Assert(GttHashTable != NULL);

	if ((const void*)name != NULL)
		GttHashTableLookup(name, gtt);

	return gtt;
}

/*
 * Execute a utility statement generated by pgtt as a sub-command of the
 * statement being processed.
 */
static void
gtt_exec_utility_subcommand(Node *stmt, const char *querystring)
{
#if PG_VERSION_NUM >= 100000
	PlannedStmt *pstmt = makeNode(PlannedStmt);

	pstmt->commandType       = CMD_UTILITY;
	pstmt->canSetTag         = true;
	pstmt->utilityStmt       = stmt;
	pstmt->stmt_location     = -1;
	pstmt->stmt_len          = 0;
	ProcessUtility(pstmt,
					querystring,
#if PG_VERSION_NUM >= 140000
					false,
#endif
					PROCESS_UTILITY_SUBCOMMAND,
					NULL, NULL,
					None_Receiver,
					NULL);
#else
	ProcessUtility(stmt,
					querystring,
					PROCESS_UTILITY_SUBCOMMAND,
					NULL,
					None_Receiver,
					NULL);
#endif
}

/*
 * Definition of a trigger to be copied on the temporary table.
 */
typedef struct GttTriggerDef
{
	char   *def;			/* CREATE TRIGGER statement */
	char   *tgname;			/* name of the trigger */
	char    tgenabled;		/* tgenabled state on the "template" table */
} GttTriggerDef;

/*
 * Restore on the temporary table the enabled state of a trigger when it
 * is not the default one. pg_get_triggerdef() does not report the
 * tgenabled state so the trigger is always created as ENABLE (fires on
 * origin) and an ALTER TABLE sub-command is required to fix it.
 */
static void
gtt_set_trigger_enabled(const char *relname, const char *tgname, char tgenabled)
{
	AlterTableStmt *atstmt;
	AlterTableCmd  *atcmd;
	const char     *action = NULL;

	atcmd = makeNode(AlterTableCmd);

	switch (tgenabled)
	{
		case TRIGGER_DISABLED:
			atcmd->subtype = AT_DisableTrig;
			action = "DISABLE TRIGGER";
			break;
		case TRIGGER_FIRES_ON_REPLICA:
			atcmd->subtype = AT_EnableReplicaTrig;
			action = "ENABLE REPLICA TRIGGER";
			break;
		case TRIGGER_FIRES_ALWAYS:
			atcmd->subtype = AT_EnableAlwaysTrig;
			action = "ENABLE ALWAYS TRIGGER";
			break;
		default:
			/* TRIGGER_FIRES_ON_ORIGIN is the state set at creation time */
			return;
	}

	atcmd->name = pstrdup(tgname);
	atcmd->behavior = DROP_RESTRICT;
	atcmd->missing_ok = false;

	atstmt = makeNode(AlterTableStmt);
	atstmt->relation = makeRangeVar("pg_temp", pstrdup(relname), -1);
	atstmt->relation->relpersistence = RELPERSISTENCE_TEMP;
	atstmt->cmds = list_make1(atcmd);
	atstmt->missing_ok = false;
	STMT_OBJTYPE(atstmt) = OBJECT_TABLE;

	elog(DEBUG1, "restoring state of trigger \"%s\" on temporary table \"%s\": %s",
			tgname, relname, action);

	gtt_exec_utility_subcommand((Node *) atstmt, "PGTT provide a query string");
	CommandCounterIncrement();
}

/*
 * Copy on the temporary table the triggers defined on the "template"
 * table of a global temporary table.
 *
 * CREATE TABLE ... (LIKE ...) has no INCLUDING TRIGGERS option in
 * PostgreSQL, so the triggers must be replicated by hand once the
 * temporary table has been created. The definition of each trigger is
 * obtained through pg_get_triggerdef(), parsed back, and the relation
 * of the resulting CreateTrigStmt is changed to point to the temporary
 * table before being executed.
 *
 * See https://github.com/darold/pgtt/issues/52
 */
static void
gtt_copy_triggers(Oid parent_relid, const char *relname)
{
	Relation      tgrel;
	SysScanDesc   tgscan;
	ScanKeyData   key;
	HeapTuple     tuple;
	List         *trigger_defs = NIL;
	ListCell     *lc;

	elog(DEBUG1, "looking for triggers to copy from relation with Oid %d", parent_relid);

	/*
	 * Collect the definition of all the triggers of the "template" table
	 * first, the catalog scan must be closed before executing any DDL.
	 */
	tgrel = table_open(TriggerRelationId, AccessShareLock);

	ScanKeyInit(&key,
				Anum_pg_trigger_tgrelid,
				BTEqualStrategyNumber, F_OIDEQ,
				ObjectIdGetDatum(parent_relid));

	tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
								NULL, 1, &key);

	while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
	{
		Form_pg_trigger  trigform = (Form_pg_trigger) GETSTRUCT(tuple);
		GttTriggerDef   *trigdef;
		Oid              trigoid;
		Datum            def;

		/*
		 * Skip triggers created internally by PostgreSQL, they are built
		 * again with the constraints and indexes copied by the LIKE clause.
		 */
		if (trigform->tgisinternal)
			continue;

#if (PG_VERSION_NUM >= 120000)
		trigoid = trigform->oid;
#else
		trigoid = HeapTupleGetOid(tuple);
#endif

#if (PG_VERSION_NUM < 140000)
		def = OidFunctionCall1(F_PG_GET_TRIGGERDEF, ObjectIdGetDatum(trigoid));
#else
		def = OidFunctionCall1(F_PG_GET_TRIGGERDEF_OID, ObjectIdGetDatum(trigoid));
#endif

		trigdef = (GttTriggerDef *) palloc0(sizeof(GttTriggerDef));
		trigdef->def = TextDatumGetCString(def);
		trigdef->tgname = pstrdup(NameStr(trigform->tgname));
		trigdef->tgenabled = trigform->tgenabled;

		trigger_defs = lappend(trigger_defs, trigdef);
	}

	systable_endscan(tgscan);
	table_close(tgrel, AccessShareLock);

	if (trigger_defs == NIL)
		return;

	/* The temporary table must be visible before adding the triggers */
	CommandCounterIncrement();

	foreach (lc, trigger_defs)
	{
		GttTriggerDef *trigdef = (GttTriggerDef *) lfirst(lc);
		List          *raw_parsetree_list;
		ListCell      *lc2;

		elog(DEBUG1, "copying trigger on temporary table: %s", trigdef->def);

#if (PG_VERSION_NUM >= 140000)
		raw_parsetree_list = raw_parser(trigdef->def, RAW_PARSE_DEFAULT);
#else
		raw_parsetree_list = raw_parser(trigdef->def);
#endif

		foreach (lc2, raw_parsetree_list)
		{
			CreateTrigStmt *trigstmt;
#if (PG_VERSION_NUM >= 100000)
			Node *parsetree = ((RawStmt *) lfirst(lc2))->stmt;
#else
			Node *parsetree = (Node *) lfirst(lc2);
#endif

			if (!IsA(parsetree, CreateTrigStmt))
				continue;

			trigstmt = (CreateTrigStmt *) parsetree;

			/* Redirect the trigger creation to the temporary table */
			trigstmt->relation = makeRangeVar("pg_temp", pstrdup(relname), -1);
			trigstmt->relation->relpersistence = RELPERSISTENCE_TEMP;

			gtt_exec_utility_subcommand(parsetree, trigdef->def);
			CommandCounterIncrement();
		}

		/*
		 * The trigger is always created enabled, restore the state it has
		 * on the "template" table when it is a different one.
		 */
		gtt_set_trigger_enabled(relname, trigdef->tgname, trigdef->tgenabled);
	}
}

/*
 * Load Global Temporary Table in memory from pg_global_temp_tables table.
 */
static void
gtt_load_global_temporary_tables(void)
{
	RangeVar       *rv;
	Relation       rel;
#if (PG_VERSION_NUM >= 120000)
	TableScanDesc  scan;
#else
	HeapScanDesc   scan;
#endif
	HeapTuple     tuple;
	int           numberOfAttributes;
	TupleDesc     tupleDesc;
	Snapshot      snapshot;

	elog(DEBUG1, "gtt_load_global_temporary_tables()");

	elog(DEBUG1, "retrieve GTT list from definition table %s.%s", pgtt_namespace_name, CATALOG_GLOBAL_TEMP_REL);

	/* Set and open the GTT definition storage relation */
	rv = makeRangeVar(pgtt_namespace_name, CATALOG_GLOBAL_TEMP_REL, -1);

	/* Open the CATALOG_GLOBAL_TEMP_REL table. We don't want to allow
	 * writable accesses by other session during import. */
	PushActiveSnapshot(GetTransactionSnapshot());
	snapshot = GetActiveSnapshot();

#if (PG_VERSION_NUM >= 120000)
	rel = table_openrv(rv, AccessShareLock);
#if (PG_VERSION_NUM >= 190000)
	scan = table_beginscan(rel, snapshot, 0, (ScanKey) NULL, SO_NONE);
#else
	scan = table_beginscan(rel, snapshot, 0, (ScanKey) NULL);
#endif
#else
	rel = heap_openrv(rv, AccessShareLock);
	scan = heap_beginscan(rel, snapshot, 0, (ScanKey) NULL);
#endif
	tupleDesc = RelationGetDescr(rel);
	numberOfAttributes = tupleDesc->natts;
	while (HeapTupleIsValid(tuple = heap_getnext(scan, ForwardScanDirection)))
	{
		Oid namespaceId;
		Gtt gtt;
		Datum *values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
		bool *isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));

		/* Extract data */
		heap_deform_tuple(tuple, tupleDesc, values, isnull);
		strlcpy(gtt.relname, NameStr(*(DatumGetName(values[2]))), sizeof(gtt.relname));
		gtt.preserved = DatumGetBool(values[3]);
		gtt.code = TextDatumGetCString(values[4]);
		gtt.created = false;
		gtt.temp_relid = 0;
		/* get relation id */
		namespaceId = LookupExplicitNamespace(pgtt_namespace_name, false);
		gtt.relid = get_relname_relid(gtt.relname, namespaceId);
		/* Add table to cache */
		GttHashTableInsert(gtt, gtt.relname);
	}

	/* Cleanup. */
#if (PG_VERSION_NUM >= 120000)
	table_endscan(scan);
	table_close(rel, AccessShareLock);
#else
	heap_endscan(scan);
	heap_close(rel, AccessShareLock);
#endif

	PopActiveSnapshot();
}

static Oid
create_temporary_table_internal(ParseState *pstate, Oid parent_relid, bool preserved)
{
	/* Value to be returned */
	Oid                         temp_relid = InvalidOid; /* safety */
#if (PG_VERSION_NUM >= 130000)
	ObjectAddress               address;
#endif

	/* Parent's namespace and name */
	Oid                         parent_nsp;
	char                       *parent_name,
							   *parent_nsp_name;
	char                        parent_persistence;

	/* Elements of the "CREATE TABLE" query tree */
	RangeVar                   *parent_rv;
	RangeVar                   *table_rv;
	TableLikeClause            *like_clause = makeNode(TableLikeClause);
	CreateStmt                 *createStmt = makeNode(CreateStmt);
	List                       *createStmts;
	ListCell                   *lc;

	elog(DEBUG1, "creating a temporary table like table with Oid %d", parent_relid);

	/* Lock parent and check if it exists */
	LockRelationOid(parent_relid, ShareUpdateExclusiveLock);
	if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(parent_relid)))
		elog(ERROR, "relation %u does not exist", parent_relid);

	/* Cache parent's namespace and name */
	parent_name = get_rel_name(parent_relid);
	parent_nsp = get_rel_namespace(parent_relid);
	parent_nsp_name = get_namespace_name(parent_nsp);
	parent_persistence = get_rel_persistence(parent_relid);

	/* Make up parent's RangeVar */
	parent_rv = makeRangeVar(parent_nsp_name, parent_name, -1);
	parent_rv->relpersistence = parent_persistence;

	elog(DEBUG1, "Parent namespace: %s, parent relname: %s, parent oid: %d",
									parent_rv->schemaname,
									parent_rv->relname,
									parent_relid);

	/* Set name of temporary table same as parent table */
	table_rv = makeRangeVar("pg_temp", parent_rv->relname, -1);
	Assert(table_rv);

	elog(DEBUG1, "Initialize TableLikeClause structure");
	/* Initialize TableLikeClause structure */
	like_clause->relation            = copyObject(parent_rv);
	like_clause->options             = CREATE_TABLE_LIKE_DEFAULTS
						| CREATE_TABLE_LIKE_INDEXES
						| CREATE_TABLE_LIKE_CONSTRAINTS
#if (PG_VERSION_NUM >= 100000)
						| CREATE_TABLE_LIKE_IDENTITY
#endif
#if (PG_VERSION_NUM >= 120000)
						| CREATE_TABLE_LIKE_GENERATED
#endif
						| CREATE_TABLE_LIKE_COMMENTS;

	elog(DEBUG1, "Initialize CreateStmt structure");
	/* Initialize CreateStmt structure */
	createStmt->relation            = copyObject(table_rv);
	createStmt->relation->schemaname = NULL;
	createStmt->relation->relpersistence = RELPERSISTENCE_TEMP;
	createStmt->tableElts           = list_make1(copyObject(like_clause));
	createStmt->inhRelations        = NIL;
	createStmt->ofTypename          = NULL;
	createStmt->constraints         = NIL;
	createStmt->options             = NIL;
#if (PG_VERSION_NUM >= 120000)
	createStmt->accessMethod        = NULL;
#endif
	if (preserved)
		createStmt->oncommit    = ONCOMMIT_PRESERVE_ROWS;
	else
		createStmt->oncommit    = ONCOMMIT_DELETE_ROWS;
	createStmt->tablespacename      = NULL;
	createStmt->if_not_exists       = false;

	elog(DEBUG1, "Obtain the sequence of Stmts to create temporary table");
	/* Obtain the sequence of Stmts to create temporary table */
	createStmts = transformCreateStmt(createStmt, NULL);

	elog(DEBUG1, "Processing list of statements");
	/* Create the temporary table */
	foreach (lc, createStmts)
	{
		/* Fetch current CreateStmt */
		Node *cur_stmt = (Node *) lfirst(lc);

		elog(DEBUG1, "Processing statement of type %d", nodeTag(cur_stmt));
		if (IsA(cur_stmt, CreateStmt))
		{
			Datum           toast_options;
#if PG_VERSION_NUM < 180000
			static char     *validnsps[] = HEAP_RELOPT_NAMESPACES;
#else
			const char     *validnsps[] = HEAP_RELOPT_NAMESPACES;
#endif
			Oid             temp_relowner;

			/* Temporary table owner must be current user */
			temp_relowner = GetUserId();

			elog(DEBUG1, "Creating a temporary table and get its Oid");
                        /* Create a temporary table and save its Oid */
#if (PG_VERSION_NUM < 100000)
			temp_relid = DefineRelation((CreateStmt *) cur_stmt, RELKIND_RELATION, temp_relowner, NULL).objectId;
#elif (PG_VERSION_NUM < 130000)
			temp_relid = DefineRelation((CreateStmt *) cur_stmt, RELKIND_RELATION, temp_relowner, NULL, NULL).objectId;
#else
			address = DefineRelation((CreateStmt *) cur_stmt, RELKIND_RELATION, temp_relowner, NULL, NULL);
			temp_relid = address.objectId;
#endif
			/* Update config one more time */
			CommandCounterIncrement();

			/*
			 * parse and validate reloptions for the toast
			 * table
			 */
			toast_options = transformRelOptions((Datum) 0,
									((CreateStmt *) cur_stmt)->options,
									"toast",
									validnsps,
									true,
									false);

			(void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true);

			NewRelationCreateToastTable(temp_relid, toast_options);
                }
		else if (IsA(cur_stmt, IndexStmt))
		{
			Oid                     relid;
			elog(DEBUG1, "execution statement CREATE INDEX, relation has an index.");

			relid =
				RangeVarGetRelidExtended(((IndexStmt *) cur_stmt)->relation, ShareLock,
#if (PG_VERSION_NUM >= 110000)
										 0,
#else
										 false, false,
#endif
										 RangeVarCallbackOwnsRelation,
										 NULL);

			DefineIndex(
#if (PG_VERSION_NUM >= 190000)
					pstate,
#endif
					relid,      /* OID of heap relation */
					(IndexStmt *) cur_stmt,
					InvalidOid, /* no predefined OID */
#if (PG_VERSION_NUM >= 110000)
					InvalidOid, /* no parent index */
					InvalidOid, /* no parent constraint */
#endif
#if (PG_VERSION_NUM >= 160000)
					-1,/* total parts */
#endif
					false,  /* is_alter_table */
					true,   /* check_rights */
#if (PG_VERSION_NUM > 100000)
					true,   /* check_not_in_use */
#endif
					false,  /* skip_build */
					false); /* quiet */
		}
		else if (IsA(cur_stmt, CommentStmt))
		{
			CommentObject((CommentStmt *) cur_stmt);
		}
#if (PG_VERSION_NUM >= 90600)
		else if (IsA(cur_stmt, TableLikeClause))
		{
			TableLikeClause *like = (TableLikeClause *) cur_stmt;
			RangeVar   *rv = createStmt->relation;
			List       *morestmts;

			morestmts = expandTableLikeClause(rv, like);
			createStmts = list_concat(createStmts, morestmts);
			/* don't need a CCI now */
			continue;
		}
#endif
		else
		{
			/*
			 * Recurse for anything else.
			 */
			gtt_exec_utility_subcommand(cur_stmt, "PGTT provide a query string");

		}

		/* Need CCI between commands */
#if (PG_VERSION_NUM < 130000)
		if (lnext(lc) != NULL)
#else
		if (lnext(createStmts, lc) != NULL)
#endif
			CommandCounterIncrement();
        }

	/*
	 * CREATE TABLE ... (LIKE ...) does not copy the triggers, they must be
	 * replicated on the temporary table by hand. See issue #52.
	 */
	if (OidIsValid(temp_relid))
		gtt_copy_triggers(parent_relid, parent_rv->relname);

	/* release lock on "template" relation */
	UnlockRelationOid(parent_relid, ShareUpdateExclusiveLock);

	elog(DEBUG1, "Create a temporary table done with Oid: %d", temp_relid);
	return temp_relid;
}

/*
 * Post-parse-analysis hook: mark query with a queryId
 */
#if PG_VERSION_NUM >= 190000
static void
gtt_post_parse_analyze(ParseState *pstate, Query *query, const JumbleState *jstate)
#else
#if PG_VERSION_NUM >= 140000
static void
gtt_post_parse_analyze(ParseState *pstate, Query *query, JumbleState *jstate)
#else
static void
gtt_post_parse_analyze(ParseState *pstate, Query *query)
#endif
#endif
{
	/* Try to load pgtt if not already done. */
	gtt_try_load();

	/*
	 * Reroute all the references to a GTT "template" table found in the
	 * query tree, including the ones in sub-queries, CTE and sub-links,
	 * not just the first entry of the top level range table.
	 */
	if (NOT_IN_PARALLEL_WORKER && pgtt_is_enabled && GttHashTable != NULL)
		gtt_rewrite_query(pstate, query);

	/* restore hook */
	if (prev_post_parse_analyze_hook) {
#if PG_VERSION_NUM >= 140000
		prev_post_parse_analyze_hook(pstate, query, jstate);
#else
		prev_post_parse_analyze_hook(pstate, query);
#endif
	}
}

/*
 * Reroute a single range table entry to the temporary table backing the
 * global temporary table, when the relation is a GTT "template" table.
 * The temporary table is created on the fly if it does not exist yet.
 */
static void
gtt_rewrite_rte(ParseState *pstate, Query *query, RangeTblEntry *rte)
{
	Relation      rel;
	Gtt           gtt;
	char          *name = NULL;

	/* This must be a valid relation not from pg_catalog */
	if (rte->rtekind != RTE_RELATION || rte->relid == InvalidOid
			|| rte->relkind != RELKIND_RELATION
			|| is_catalog_relid(rte->relid))
		return;

#if (PG_VERSION_NUM >= 120000)
	rel = table_open(rte->relid, NoLock);
#else
	rel = heap_open(rte->relid, NoLock);
#endif
	name = RelationGetRelationName(rel);
#if (PG_VERSION_NUM >= 120000)
	table_close(rel, NoLock);
#else
	heap_close(rel, NoLock);
#endif

	gtt.relid = 0;
	gtt.temp_relid = 0;
	gtt.relname[0] = '\0';
	gtt.preserved = false;
	gtt.code = NULL;
	gtt.created = false;

	/* Check if the table is in the hash list and it has not already be created */
	if ((const void*)name != NULL)
	{
		elog(DEBUG1, "gtt_rewrite_rte() looking for table \"%s\" with relid %d into cache.", name, rte->relid);
		GttHashTableLookup(name, gtt);
	}
	else
		elog(ERROR, "gtt_rewrite_rte() table to search in cache is not valide pointer, relid: %d.", rte->relid);

	if (gtt.relname[0] == '\0')
	{
		/* the table is not a global temporary table do nothing*/
		elog(DEBUG1, "table \"%s\" not registered as GTT", name);
		return;
	}

	/* After an error and rollback the table is still registered in cache but must be initialized */
	if (gtt.created && OidIsValid(gtt.temp_relid)
			&& !SearchSysCacheExists1(RELOID, ObjectIdGetDatum(gtt.temp_relid))
			)
	{
		elog(DEBUG1, "invalid temporary table with relid %d (%s), reseting.", gtt.temp_relid, gtt.relname);
		gtt.created = false;
		gtt.temp_relid = 0;
	}

	/* Create the temporary table if it does not exists */
	if (!gtt.created)
	{
		elog(DEBUG1, "global temporary table from relid %d does not exists create it: %s", rte->relid, gtt.relname);
		/* Call create temporary table */
		if ((gtt.temp_relid = create_temporary_table_internal(pstate, gtt.relid, gtt.preserved)) != InvalidOid)
		{
			elog(DEBUG1, "global temporary table %s (oid: %d) created", gtt.relname, gtt.temp_relid);
			/* Update hash list with table flagged as created*/
			gtt.created = true;
			GttHashTableDelete(gtt.relname);
			GttHashTableInsert(gtt, gtt.relname);
		}
		else
			elog(ERROR, "can not create global temporary table %s", gtt.relname);
	}

	elog(DEBUG1, "temporary table exists with oid %d", gtt.temp_relid);

	if (rte->relid != gtt.temp_relid)
	{
#if PG_VERSION_NUM >= 160000
		/*
		 * Some RTE do not have any permission info attached, only fix the
		 * relation Oid of the permission info when there is one.
		 */
		if (rte->perminfoindex > 0)
		{
			RTEPermissionInfo *rteperm = list_nth(query->rteperminfos,
								rte->perminfoindex - 1);
			rteperm->relid = gtt.temp_relid;
		}
#endif
		LockRelationOid(gtt.temp_relid, rte->rellockmode);
		if (rte->rellockmode != AccessShareLock)
			UnlockRelationOid(rte->relid, rte->rellockmode);

		elog(DEBUG1, "rerouting relid %d access to %d for GTT table \"%s\"", rte->relid, gtt.temp_relid, name);
		rte->relid = gtt.temp_relid;
	}
}

/*
 * Reroute all the GTT "template" table references of a query and of all
 * its sub-queries (sub-selects, sub-links, CTE, set operations, ...).
 *
 * The previous implementation was only looking at the first entry of the
 * top level range table, so that a GTT referenced in a sub-query or in a
 * secondary FROM item was still reading the empty "template" table. See
 * https://github.com/darold/pgtt/issues/58
 */
static void
gtt_rewrite_query(ParseState *pstate, Query *query)
{
	ListCell *lc;

	if (query == NULL)
		return;

	foreach(lc, query->rtable)
		gtt_rewrite_rte(pstate, query, (RangeTblEntry *) lfirst(lc));

	/* Recurse into any sub-query of this query */
	(void) query_tree_walker(query, gtt_query_walker, (void *) pstate, 0);
}

/*
 * Expression tree walker used to find the sub-queries of a query.
 * Utility statements are not walked by query_tree_walker().
 */
static bool
gtt_query_walker(Node *node, void *context)
{
	if (node == NULL)
		return false;

	if (IsA(node, Query))
	{
		/* gtt_rewrite_query() takes care of the recursion by itself */
		gtt_rewrite_query((ParseState *) context, (Query *) node);
		return false;
	}

	return expression_tree_walker(node, gtt_query_walker, context);
}

static bool
is_catalog_relid(Oid relid)
{
	HeapTuple       reltup;
	Form_pg_class   relform;
	Oid             relnamespace;

	reltup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
	if (!HeapTupleIsValid(reltup))
		elog(ERROR, "cache lookup failed for relation %u", relid);
	relform = (Form_pg_class) GETSTRUCT(reltup);
	relnamespace = relform->relnamespace;
	ReleaseSysCache(reltup);
	if (relnamespace == PG_CATALOG_NAMESPACE || relnamespace == PG_TOAST_NAMESPACE)
	{
		elog(DEBUG1, "relation %d is in pg_catalog or pg_toast schema, nothing to do.", relid);
		return true;
	}

	return false;
}

/*
 * Be sure that extension schema is at end of the search path so that
 * "template" tables will be found.
 */
static void
force_pgtt_namespace(void)
{
	char		   *old_search_path;
	char		   *path_copy;
	List		   *namelist = NIL;
	ListCell	   *l;
	bool			found = false;
	bool			keep_pg_catalog_last = false;
	const char	   *pgtt_schema;
	StringInfoData	search_path;

	if (!IsTransactionState() || GttHashTable == NULL)
		return;

	/* This is a copy of the value, it must be freed before returning. */
	old_search_path = GetConfigOptionByName("search_path", NULL, false);

	/* An empty search_path is set by pg_dump, leave it as this. */
	if (old_search_path != NULL && old_search_path[0] == '\0')
	{
		pfree(old_search_path);
		return;
	}

	if (old_search_path != NULL)
	{
		/*
		 * Look for our schema in the current search path. The schemas must
		 * be compared one by one, looking for the name of our schema in the
		 * whole value would also match a schema whose name just includes it,
		 * "pgtt_schema_old" for example.
		 *
		 * SplitIdentifierString() writes into the string it is given and
		 * returns the schema names as they are used to resolve the relations
		 * (unquoted and lowercased when necessary), this is why a copy of
		 * the value is parsed here.
		 */
		path_copy = pstrdup(old_search_path);
		if (!SplitIdentifierString(path_copy, ',', &namelist))
		{
			/* Not supposed to happen, let PostgreSQL complain about it. */
			list_free(namelist);
			pfree(path_copy);
			pfree(old_search_path);
			return;
		}

		foreach(l, namelist)
		{
			if (strcmp((char *) lfirst(l), pgtt_namespace_name) == 0)
			{
				found = true;
				break;
			}
		}

		/*
		 * When pg_catalog is explicitly set at end of the search path it
		 * must be kept at this place, this is not the same behavior if it
		 * is not kept at the end when there is pg_catalog functions
		 * overloaded in another schema.
		 */
		if (!found && namelist != NIL &&
			strcmp((char *) llast(namelist), "pg_catalog") == 0)
			keep_pg_catalog_last = true;

		list_free(namelist);
		pfree(path_copy);

		/* Nothing to do, our schema is already in the search path. */
		if (found)
		{
			pfree(old_search_path);
			return;
		}
	}

	/* Override the search_path by adding our pgtt schema. */
	pgtt_schema = quote_identifier(pgtt_namespace_name);
	initStringInfo(&search_path);

	if (old_search_path == NULL)
		appendStringInfoString(&search_path, pgtt_schema);
	else if (keep_pg_catalog_last)
	{
		/*
		 * Add our schema just before the trailing pg_catalog. The last comma
		 * of the value is necessarily the separator of the last schema as
		 * pg_catalog can not include a comma.
		 */
		char   *sep = strrchr(old_search_path, ',');

		if (sep != NULL)
		{
			int		len = sep - old_search_path;

			/* remove redundant whitespaces */
			while (len > 0 && isspace((unsigned char) old_search_path[len - 1]))
				len--;

			appendBinaryStringInfo(&search_path, old_search_path, len);
			appendStringInfoString(&search_path, ", ");
		}
		appendStringInfo(&search_path, "%s, pg_catalog", pgtt_schema);
	}
	else
		appendStringInfo(&search_path, "%s, %s", old_search_path, pgtt_schema);

	SetConfigOption("search_path", search_path.data,
					(superuser() ? PGC_SUSET : PGC_USERSET),
					PGC_S_SESSION);

	elog(DEBUG1, "search_path forced to %s.", search_path.data);

	pfree(search_path.data);
	if (pgtt_schema != pgtt_namespace_name)
		pfree((char *) pgtt_schema);
	if (old_search_path != NULL)
		pfree(old_search_path);
}

/*
 * Update a registered Global Temporary Table
 * in the pg_global_temp_tables table.
 *
 */
static void
gtt_update_registered_table(Gtt gtt)
{
	char    *newQueryString = NULL;
	int     connected = 0;
	int     finished = 0;
	int     result = 0;

	elog(DEBUG1, "proceeding to Global Temporary Table modification.");

	connected = SPI_connect();
	if (connected != SPI_OK_CONNECT)
		ereport(ERROR, (errmsg("could not connect to SPI manager")));

	newQueryString = psprintf("UPDATE %s.pg_global_temp_tables SET relname = %s WHERE relid = %d",
			quote_identifier(pgtt_namespace_name),
			quote_literal_cstr(gtt.relname),
			gtt.relid
		);
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR,
				(errmsg("can not update relid %d into %s.pg_global_temp_tables",
						gtt.relid, quote_identifier(pgtt_namespace_name))));

	finished = SPI_finish();
	if (finished != SPI_OK_FINISH)
		ereport(ERROR, (errmsg("could not disconnect from SPI manager")));
}

/*
 * Create the temporary table related to a Global Temporary Table
 * and register the GTT in pg_global_temp_tables table.
 *
 */
static void
gtt_create_table_as(Gtt gtt, bool skipdata)
{
	char    *newQueryString = NULL;
	int     connected = 0;
	int     finished = 0;
	int     result = 0;
	Oid     gttOid = InvalidOid;
	Datum   oidDatum;
	bool    isnull;

	elog(DEBUG1, "proceeding to Global Temporary Table creation.");

	/* This can only be called if GTT has been properly loaded. */
	Assert(GttHashTable != NULL);

	connected = SPI_connect();
	if (connected != SPI_OK_CONNECT)
		ereport(ERROR, (errmsg("could not connect to SPI manager")));

	/* Create the "template" table */
	newQueryString = psprintf("CREATE UNLOGGED TABLE %s.%s %s;",
			quote_identifier(pgtt_namespace_name),
			quote_identifier(gtt.relname),
			gtt.code);
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

	/* Get Oid of the newly created table */
	newQueryString = psprintf("SELECT c.relfilenode FROM pg_class c JOIN pg_namespace n ON (c.relnamespace=n.oid) WHERE c.relname=%s AND n.nspname = %s",
			quote_literal_cstr(gtt.relname),
			quote_literal_cstr(pgtt_namespace_name));

	result = SPI_exec(newQueryString, 0);
	if (result != SPI_OK_SELECT || SPI_processed != 1)
		ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

	oidDatum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull);

	if (!isnull)
		gttOid = DatumGetInt32(oidDatum);

	if (isnull || !OidIsValid(gttOid))
		ereport(ERROR,
				(errmsg("can not get OID of newly created GTT template table %s",
							quote_identifier(gtt.relname))));

	gtt.relid = gttOid;

	/* Create the temporary table only if data from source table must be inserted */
	if (!skipdata)
	{
		char namespaceName[NAMEDATALEN];

		/* Get current temporary namespace name */
		snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d",
#if PG_VERSION_NUM < 170000
				MyBackendId
#else
				MyProcNumber
#endif
				);

		newQueryString = psprintf("CREATE TEMPORARY TABLE %s %s WITH DATA",
				quote_identifier(gtt.relname),
				gtt.code);
		result = SPI_exec(newQueryString, 0);
		if (result < 0)
			ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

		/* Get Oid of the newly created temporary table */
		newQueryString = psprintf("SELECT c.relfilenode FROM pg_class c JOIN pg_namespace n ON (c.relnamespace=n.oid) WHERE c.relname=%s AND n.nspname = %s",
				quote_literal_cstr(gtt.relname),
				quote_literal_cstr(namespaceName));

		result = SPI_exec(newQueryString, 0);
		if (result != SPI_OK_SELECT || SPI_processed != 1)
			ereport(ERROR, (errmsg("execution failure on query: \"%s\"", newQueryString)));

		oidDatum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull);

		if (!isnull)
			gtt.temp_relid = DatumGetInt32(oidDatum);

		if (isnull || !OidIsValid(gtt.temp_relid))
			ereport(ERROR,
					(errmsg("can not get OID of newly created temporary table %s",
								quote_identifier(gtt.relname))));
		gtt.created = true;
	}

	/* Now register the GTT table */
	newQueryString = psprintf("INSERT INTO %s.pg_global_temp_tables VALUES (%d, %s, %s, '%c', %s)",
			quote_identifier(pgtt_namespace_name),
			gtt.relid,
			quote_literal_cstr(pgtt_namespace_name),
			quote_literal_cstr(gtt.relname),
			(gtt.preserved) ? 't' : 'f',
			quote_literal_cstr(gtt.code)
		);
	result = SPI_exec(newQueryString, 0);
	if (result < 0)
		ereport(ERROR, (errmsg("can not registrer new global temporary table")));

	finished = SPI_finish();
	if (finished != SPI_OK_FINISH)
		ereport(ERROR, (errmsg("could not disconnect from SPI manager")));

	/* registrer the table in the cache */
	GttHashTableDelete(gtt.relname);
	GttHashTableInsert(gtt, gtt.relname);
}

int
strremovestr(char *src, char *toremove)
{
	while( *src )
	{
		char *k=toremove,*s=src;
		while( *k && *k==*s ) ++k,++s;
		if( !*k )
		{
			while( *s ) *src++=*s++;
			*src=0;
			return 1;
		}
		++src;
	}
	return 0;
}