Make renaming a temp table behave sensibly. We don't need to touch

tglsfdc · tglsfdc · commit 9f1a22304695 · 2000-06-20T06:41:13.000Z
the underlying table at all, just change the mapping entry ... but
that logic was missing.
diff --git a/src/backend/commands/rename.c b/src/backend/commands/rename.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.45 2000/05/25 21:30:20 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.46 2000/06/20 06:41:13 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,6 +29,7 @@
 #include "utils/acl.h"
 #include "utils/relcache.h"
 #include "utils/syscache.h"
+#include "utils/temprel.h"
 
 
 /*
@@ -199,6 +200,13 @@ renamerel(const char *oldrelname, const char *newrelname)
 		elog(ERROR, "renamerel: Illegal class name: \"%s\" -- pg_ is reserved for system catalogs",
 			 newrelname);
 
+	/*
+	 * Check for renaming a temp table, which only requires altering
+	 * the temp-table mapping, not the physical table.
+	 */
+	if (rename_temp_relation(oldrelname, newrelname))
+		return;					/* all done... */
+
 	/*
 	 * Instead of using heap_openr(), do it the hard way, so that we
 	 * can rename indexes as well as regular relations.
diff --git a/src/backend/utils/cache/temprel.c b/src/backend/utils/cache/temprel.c
@@ -8,22 +8,29 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/temprel.c,v 1.23 2000/05/30 00:49:54 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/temprel.c,v 1.24 2000/06/20 06:41:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 /*
  * This implements temp tables by modifying the relname cache lookups
  * of pg_class.
- * When a temp table is created, a linked list of temp table tuples is
- * stored here.  When a relname cache lookup is done, references to user-named
- * temp tables are converted to the internal temp table names.
+ *
+ * When a temp table is created, normal entries are made for it in pg_class,
+ * pg_type, etc using a unique "physical" relation name.  We also make an
+ * entry in the temp table list maintained by this module.  Subsequently,
+ * relname lookups are filtered through the temp table list, and attempts
+ * to look up a temp table name are changed to look up the physical name.
+ * This allows temp table names to mask a regular table of the same name
+ * for the duration of the session.  The temp table list is also used
+ * to drop the underlying physical relations at session shutdown.
  */
 
 #include <sys/types.h>
 
 #include "postgres.h"
+
 #include "catalog/heap.h"
 #include "catalog/index.h"
 #include "utils/catcache.h"
@@ -39,39 +46,47 @@ static List *temp_rels = NIL;
 
 typedef struct TempTable
 {
-	char	   *user_relname;
-	char	   *relname;
-	Oid			relid;
+	char	   *user_relname;	/* logical name of temp table */
+	char	   *relname;		/* underlying unique name */
+	Oid			relid;			/* needed properties of rel */
 	char		relkind;
-	TransactionId xid;
+	TransactionId xid;			/* xact in which temp tab was created */
 } TempTable;
 
 
+/*
+ * Create a temp-relation list entry given the logical temp table name
+ * and the already-created pg_class tuple for the underlying relation.
+ *
+ * NB: we assume a check has already been made for a duplicate logical name.
+ */
 void
 create_temp_relation(const char *relname, HeapTuple pg_class_tuple)
 {
+	Form_pg_class pg_class_form = (Form_pg_class) GETSTRUCT(pg_class_tuple);
 	MemoryContext oldcxt;
 	TempTable  *temp_rel;
 
 	oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
 
-	temp_rel = palloc(sizeof(TempTable));
-	temp_rel->user_relname = palloc(NAMEDATALEN);
-	temp_rel->relname = palloc(NAMEDATALEN);
+	temp_rel = (TempTable *) palloc(sizeof(TempTable));
+	temp_rel->user_relname = (char *) palloc(NAMEDATALEN);
+	temp_rel->relname = (char *) palloc(NAMEDATALEN);
 
-	/* save user-supplied name */
-	strcpy(temp_rel->user_relname, relname);
-	StrNCpy(temp_rel->relname, NameStr(((Form_pg_class)
-					  GETSTRUCT(pg_class_tuple))->relname), NAMEDATALEN);
+	StrNCpy(temp_rel->user_relname, relname, NAMEDATALEN);
+	StrNCpy(temp_rel->relname, NameStr(pg_class_form->relname), NAMEDATALEN);
 	temp_rel->relid = pg_class_tuple->t_data->t_oid;
-	temp_rel->relkind = ((Form_pg_class) GETSTRUCT(pg_class_tuple))->relkind;
+	temp_rel->relkind = pg_class_form->relkind;
 	temp_rel->xid = GetCurrentTransactionId();
 
 	temp_rels = lcons(temp_rel, temp_rels);
 
 	MemoryContextSwitchTo(oldcxt);
 }
 
+/*
+ * Remove underlying relations for all temp rels at backend shutdown.
+ */
 void
 remove_all_temp_relations(void)
 {
@@ -87,7 +102,7 @@ remove_all_temp_relations(void)
 	l = temp_rels;
 	while (l != NIL)
 	{
-		TempTable  *temp_rel = lfirst(l);
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
 
 		next = lnext(l);		/* do this first, l is deallocated */
 
@@ -108,11 +123,14 @@ remove_all_temp_relations(void)
 	CommitTransactionCommand();
 }
 
-/* we don't have the relname for indexes, so we just pass the oid */
+/*
+ * Remove a temp relation map entry (part of DROP TABLE on a temp table)
+ *
+ * we don't have the relname for indexes, so we just pass the oid
+ */
 void
 remove_temp_relation(Oid relid)
 {
-
 	MemoryContext oldcxt;
 	List	   *l,
 			   *prev;
@@ -123,7 +141,7 @@ remove_temp_relation(Oid relid)
 	l = temp_rels;
 	while (l != NIL)
 	{
-		TempTable  *temp_rel = lfirst(l);
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
 
 		if (temp_rel->relid == relid)
 		{
@@ -154,7 +172,12 @@ remove_temp_relation(Oid relid)
 	MemoryContextSwitchTo(oldcxt);
 }
 
-/* remove entries from aborted transactions */
+/*
+ * Remove freshly-created map entries during transaction abort.
+ *
+ * The underlying physical rel will be removed by normal abort processing.
+ * We just have to delete the map entry.
+ */
 void
 invalidate_temp_relations(void)
 {
@@ -168,7 +191,7 @@ invalidate_temp_relations(void)
 	l = temp_rels;
 	while (l != NIL)
 	{
-		TempTable  *temp_rel = lfirst(l);
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
 
 		if (temp_rel->xid == GetCurrentTransactionId())
 		{
@@ -194,35 +217,96 @@ invalidate_temp_relations(void)
 			prev = l;
 			l = lnext(l);
 		}
-
 	}
 
 	MemoryContextSwitchTo(oldcxt);
 }
 
+/*
+ * To implement ALTER TABLE RENAME on a temp table, we shouldn't touch
+ * the underlying physical table at all, just change the map entry!
+ *
+ * This routine is invoked early in ALTER TABLE RENAME to check for
+ * the temp-table case.  If oldname matches a temp table name, change
+ * the map entry to the new logical name and return TRUE (or elog if
+ * there is a conflict with another temp table name).  If there is
+ * no match, return FALSE indicating that normal rename should proceed.
+ *
+ * We also reject an attempt to rename a normal table to a name in use
+ * as a temp table name.  That would fail later on anyway when rename.c
+ * looks for a rename conflict, but we can give a more specific error 
+ * message for the problem here.
+ *
+ * It might seem that we need to check for attempts to rename the physical
+ * file underlying a temp table, but that'll be rejected anyway because
+ * pg_tempXXX looks like a system table name.
+ *
+ * A nitpicker might complain that the rename should be undone if the
+ * current xact is later aborted, but I'm not going to fix that now.
+ * This whole mapping mechanism ought to be replaced with something
+ * schema-based, anyhow.
+ */
+bool
+rename_temp_relation(const char *oldname,
+					 const char *newname)
+{
+	List	   *l;
+
+	foreach(l, temp_rels)
+	{
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
+
+		if (strcmp(temp_rel->user_relname, oldname) == 0)
+		{
+			if (get_temp_rel_by_username(newname) != NULL)
+				elog(ERROR, "Cannot rename temp table \"%s\": temp table \"%s\" already exists",
+					 oldname, newname);
+			/* user_relname was palloc'd NAMEDATALEN, so safe to re-use it */
+			StrNCpy(temp_rel->user_relname, newname, NAMEDATALEN);
+			return true;
+		}
+	}
+
+	/* Old name does not match any temp table name, what about new? */
+	if (get_temp_rel_by_username(newname) != NULL)
+		elog(ERROR, "Cannot rename \"%s\" to \"%s\": a temp table by that name already exists",
+			 oldname, newname);
+
+	return false;
+}
+
+
+/*
+ * Map user name to physical name --- returns NULL if no entry.
+ *
+ * This is the normal way to test whether a name is a temp table name.
+ */
 char *
 get_temp_rel_by_username(const char *user_relname)
 {
 	List	   *l;
 
 	foreach(l, temp_rels)
 	{
-		TempTable  *temp_rel = lfirst(l);
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
 
 		if (strcmp(temp_rel->user_relname, user_relname) == 0)
 			return temp_rel->relname;
 	}
 	return NULL;
 }
 
+/*
+ * Map physical name to user name --- returns pstrdup'd input if no match.
+ */
 char *
 get_temp_rel_by_physicalname(const char *relname)
 {
 	List	   *l;
 
 	foreach(l, temp_rels)
 	{
-		TempTable  *temp_rel = lfirst(l);
+		TempTable  *temp_rel = (TempTable *) lfirst(l);
 
 		if (strcmp(temp_rel->relname, relname) == 0)
 			return temp_rel->user_relname;
diff --git a/src/include/utils/temprel.h b/src/include/utils/temprel.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: temprel.h,v 1.9 2000/04/12 17:16:55 momjian Exp $
+ * $Id: temprel.h,v 1.10 2000/06/20 06:41:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -16,11 +16,16 @@
 
 #include "access/htup.h"
 
-void		create_temp_relation(const char *relname, HeapTuple pg_class_tuple);
-void		remove_all_temp_relations(void);
-void		invalidate_temp_relations(void);
-void		remove_temp_relation(Oid relid);
-char	   *get_temp_rel_by_username(const char *user_relname);
-char	   *get_temp_rel_by_physicalname(const char *relname);
+extern void create_temp_relation(const char *relname,
+								 HeapTuple pg_class_tuple);
+extern void remove_temp_relation(Oid relid);
+extern bool rename_temp_relation(const char *oldname,
+								 const char *newname);
+
+extern void remove_all_temp_relations(void);
+extern void invalidate_temp_relations(void);
+
+extern char *get_temp_rel_by_username(const char *user_relname);
+extern char *get_temp_rel_by_physicalname(const char *relname);
 
 #endif	 /* TEMPREL_H */
