TableAM: add relation_reindex

Author: e-ivkov

src/backend/access/heap/heapam_handler.c

@@ -982,6 +982,12 @@ heapam_relation_nontransactional_truncate(Relation rel)
 	RelationTruncate(rel, 0);
 }
 
+static bool
+heapam_relation_reindex(Relation rel, int flags, ReindexParams *params)
+{
+	return reindex_relation(rel, flags, params);
+}
+
 static void
 heapam_relation_copy_data(Relation rel, const RelFileLocator *newrlocator)
 {
@@ -2955,6 +2961,7 @@ static const TableAmRoutine heapam_methods = {
 
 	.relation_set_new_filelocator = heapam_relation_set_new_filelocator,
 	.relation_nontransactional_truncate = heapam_relation_nontransactional_truncate,
+	.relation_reindex = heapam_relation_reindex,
 	.relation_copy_data = heapam_relation_copy_data,
 	.relation_copy_for_cluster = heapam_relation_copy_for_cluster,
 	.relation_vacuum = heap_vacuum_rel,

src/backend/catalog/index.c

@@ -3891,25 +3891,15 @@ reindex_index(Oid indexId, bool skip_constraint_checks, char persistence,
  * index rebuild.
  */
 bool
-reindex_relation(Oid relid, int flags, ReindexParams *params)
+reindex_relation(Relation rel, int flags, ReindexParams *params)
 {
-	Relation	rel;
 	Oid			toast_relid;
 	List	   *indexIds;
 	char		persistence;
 	bool		result;
 	ListCell   *indexId;
 	int			i;
 
-	/*
-	 * Open and lock the relation.  ShareLock is sufficient since we only need
-	 * to prevent schema and data changes in it.  The lock level used here
-	 * should match ReindexTable().
-	 */
-	if ((params->options & REINDEXOPT_MISSING_OK) != 0)
-		rel = try_table_open(relid, ShareLock);
-	else
-		rel = table_open(relid, ShareLock);
 
 	/* if relation is gone, leave */
 	if (!rel)
@@ -4001,11 +3991,6 @@ reindex_relation(Oid relid, int flags, ReindexParams *params)
 		i++;
 	}
 
-	/*
-	 * Close rel, but continue to hold the lock.
-	 */
-	table_close(rel, NoLock);
-
 	result = (indexIds != NIL);
 
 	/*
@@ -4021,10 +4006,20 @@ reindex_relation(Oid relid, int flags, ReindexParams *params)
 		 * This rule is enforced by setting tablespaceOid to InvalidOid.
 		 */
 		ReindexParams newparams = *params;
+	  	/*
+	  	 * Open and lock the relation.  ShareLock is sufficient since we only need
+	  	 * to prevent schema and data changes in it.  The lock level used here
+	  	 * should match ReindexTable().
+	  	 */
+	  	Relation toast_rel = table_open(toast_relid, ShareLock);
 
 		newparams.options &= ~(REINDEXOPT_MISSING_OK);
 		newparams.tablespaceOid = InvalidOid;
-		result |= reindex_relation(toast_relid, flags, &newparams);
+		result |= reindex_relation(toast_rel, flags, &newparams);
+		/*
+		 * Close rel, but continue to hold the lock.
+		 */
+		table_close(toast_rel, NoLock);
 	}
 
 	return result;

src/backend/commands/cluster.c

@@ -1462,6 +1462,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	int			reindex_flags;
 	ReindexParams reindex_params = {0};
 	int			i;
+	Relation	oldHeap;
 
 	/* Report that we are now swapping relation files */
 	pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
@@ -1517,8 +1518,19 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	/* Report that we are now reindexing relations */
 	pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,
 								 PROGRESS_CLUSTER_PHASE_REBUILD_INDEX);
+	/*
+	 * Open and lock the relation.  ShareLock is sufficient since we only need
+	 * to prevent schema and data changes in it.  The lock level used here
+	 * should match ReindexTable().
+	 */
+	oldHeap = table_open(OIDOldHeap, ShareLock);
+
+	reindex_relation(oldHeap, reindex_flags, &reindex_params);
+	/*
+	 * Close rel, but continue to hold the lock.
+	 */
+	table_close(oldHeap, NoLock);
 
-	reindex_relation(OIDOldHeap, reindex_flags, &reindex_params);
 
 	/* Report that we are now doing clean up */
 	pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE,

src/backend/commands/indexcmds.c

@@ -2943,12 +2943,23 @@ ReindexTable(RangeVar *relation, ReindexParams *params, bool isTopLevel)
 	else
 	{
 		ReindexParams newparams = *params;
+		Relation rel;
 
 		newparams.options |= REINDEXOPT_REPORT_PROGRESS;
-		result = reindex_relation(heapOid,
-								  REINDEX_REL_PROCESS_TOAST |
-								  REINDEX_REL_CHECK_CONSTRAINTS,
-								  &newparams);
+		if ((newparams.options & REINDEXOPT_MISSING_OK) != 0)
+			rel = try_table_open(heapOid, ShareLock);
+		else
+			rel = table_open(heapOid, ShareLock);
+
+		result = table_relation_reindex(rel,
+										REINDEX_REL_PROCESS_TOAST |
+										REINDEX_REL_CHECK_CONSTRAINTS,
+										&newparams);
+		/*
+		 * Close rel, but continue to hold the lock.
+		 */
+		table_close(rel, NoLock);
+
 		if (!result)
 			ereport(NOTICE,
 					(errmsg("table \"%s\" has no indexes to reindex",
@@ -3376,13 +3387,24 @@ ReindexMultipleInternal(List *relids, ReindexParams *params)
 		{
 			bool		result;
 			ReindexParams newparams = *params;
+			Relation rel;
 
 			newparams.options |=
 				REINDEXOPT_REPORT_PROGRESS | REINDEXOPT_MISSING_OK;
-			result = reindex_relation(relid,
+			/*
+			 * Open and lock the relation.  ShareLock is sufficient since we only need
+			 * to prevent schema and data changes in it.  The lock level used here
+			 * should match ReindexTable().
+			 */
+			rel = try_table_open(relid, ShareLock);
+			result = table_relation_reindex(rel,
 									  REINDEX_REL_PROCESS_TOAST |
 									  REINDEX_REL_CHECK_CONSTRAINTS,
 									  &newparams);
+			/*
+			 * Close rel, but continue to hold the lock.
+			 */
+			table_close(rel, NoLock);
 
 			if (result && (params->options & REINDEXOPT_VERBOSE) != 0)
 				ereport(INFO,

src/backend/commands/tablecmds.c

@@ -2037,7 +2037,6 @@ ExecuteTruncateGuts(List *explicit_rels,
 		}
 		else
 		{
-			Oid			heap_relid;
 			Oid			toast_relid;
 			ReindexParams reindex_params = {0};
 
@@ -2058,8 +2057,6 @@ ExecuteTruncateGuts(List *explicit_rels,
 			 */
 			RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence);
 
-			heap_relid = RelationGetRelid(rel);
-
 			/*
 			 * The same for the toast table, if any.
 			 */
@@ -2077,7 +2074,7 @@ ExecuteTruncateGuts(List *explicit_rels,
 			/*
 			 * Reconstruct the indexes to match, and we're done.
 			 */
-			reindex_relation(heap_relid, REINDEX_REL_PROCESS_TOAST,
+			table_relation_reindex(rel, REINDEX_REL_PROCESS_TOAST,
 							 &reindex_params);
 		}
 

src/include/access/tableam.h

@@ -27,6 +27,7 @@
 #include "utils/guc.h"
 #include "utils/rel.h"
 #include "utils/snapshot.h"
+#include "catalog/index.h"
 
 
 #define DEFAULT_TABLE_ACCESS_METHOD	"heap"
@@ -639,6 +640,9 @@ typedef struct TableAmRoutine
 	 */
 	void		(*relation_nontransactional_truncate) (Relation rel);
 
+	/* See reindex_relation for reference about parameters */
+	bool        (*relation_reindex) (Relation rel, int flags, ReindexParams *params);
+
 	/*
 	 * See table_relation_copy_data().
 	 *
@@ -1687,6 +1691,13 @@ table_relation_nontransactional_truncate(Relation rel)
 	rel->rd_tableam->relation_nontransactional_truncate(rel);
 }
 
+/* See reindex_relation for reference about parameters */
+static inline bool
+table_relation_reindex(Relation rel, int flags, ReindexParams *params)
+{
+	return rel->rd_tableam->relation_reindex(rel, flags, params);
+}
+
 /*
  * Copy data from `rel` into the new relfilelocator `newrlocator`. The new
  * relfilelocator may not have storage associated before this function is

src/include/catalog/index.h

@@ -158,7 +158,7 @@ extern void reindex_index(Oid indexId, bool skip_constraint_checks,
 #define REINDEX_REL_FORCE_INDEXES_UNLOGGED	0x08
 #define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10
 
-extern bool reindex_relation(Oid relid, int flags, ReindexParams *params);
+extern bool reindex_relation(Relation rel, int flags, ReindexParams *params);
 
 extern bool ReindexIsProcessingHeap(Oid heapOid);
 extern bool ReindexIsProcessingIndex(Oid indexOid);