Added back the ENR checks for Babelfish temp tables in various functions missed during

cherry-picking

SearchSysCacheLocked1 is used when searching in catcache for oids. This
function, apart from searching the catcache, also locks the catalog
tuple entry for in-place update. But since system catalogs for ENR are
maintained locally in-memory, we don't want to do an inplace-update.
Hence, for ENRs we will use SearchSysCache1.
Also, when doing a cache invalidation, we want to use
PrepareInvalidationState instead of PrepareInplaceInvalidationState

Task: BABEL-5965

Signed-off-by: Ayush Shah <ayushdsh@amazon.com>

cr: https://code.amazon.com/reviews/CR-219295985
(cherry picked from commit 8eec60901bd3b8134ba36281623ef503270c3408)

Author: ayushdsh

src/backend/access/heap/heapam.c

@@ -45,6 +45,7 @@
 #include "commands/vacuum.h"
 #include "pgstat.h"
 #include "port/pg_bitutils.h"
+#include "parser/parser.h"
 #include "storage/lmgr.h"
 #include "storage/predicate.h"
 #include "storage/procarray.h"
@@ -6491,7 +6492,7 @@ heap_inplace_update_and_unlock(Relation relation,
 							   HeapTuple oldtup, HeapTuple tuple,
 							   Buffer buffer)
 {
-	HeapTupleHeader htup = oldtup->t_data;
+	HeapTupleHeader htup;
 	uint32		oldlen;
 	uint32		newlen;
 	char	   *dst;
@@ -6515,6 +6516,7 @@ heap_inplace_update_and_unlock(Relation relation,
 	if (ENRUpdateTuple(relation, tuple))
 		return;
 
+	htup = oldtup->t_data;
 	Assert(ItemPointerEquals(&oldtup->t_self, &tuple->t_self));
 	oldlen = oldtup->t_len - htup->t_hoff;
 	newlen = tuple->t_len - tuple->t_data->t_hoff;

src/backend/access/index/genam.c

@@ -894,6 +894,11 @@ systable_inplace_update_begin(Relation relation,
 			return;
 		}
 
+		if (scan->enr)
+		{
+			break;
+		}
+
 		slot = scan->slot;
 		Assert(TTS_IS_BUFFERTUPLE(slot));
 		bslot = (BufferHeapTupleTableSlot *) slot;
@@ -937,8 +942,17 @@ systable_inplace_update_cancel(void *state)
 	Relation	relation = scan->heap_rel;
 	TupleTableSlot *slot = scan->slot;
 	BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-	HeapTuple	oldtup = bslot->base.tuple;
-	Buffer		buffer = bslot->buffer;
+	HeapTuple	oldtup;
+	Buffer		buffer;
+
+	if (scan->enr)
+	{
+		systable_endscan(scan);
+		return;
+	}
+
+	oldtup = bslot->base.tuple;
+	buffer = bslot->buffer;
 
 	heap_inplace_unlock(relation, oldtup, buffer);
 	systable_endscan(scan);

src/backend/catalog/aclchk.c

@@ -1814,7 +1814,7 @@ ExecGrant_Relation(InternalGrant *istmt)
 		Oid			ownerId;
 		HeapTuple	tuple;
 		ListCell   *cell_colprivs;
-		bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, relOid, ENR_TSQL_TEMP));
+		bool 		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(relOid));
 
 		if (is_enr)
 			tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relOid));
@@ -2164,9 +2164,13 @@ ExecGrant_common(InternalGrant *istmt, Oid classid, AclMode default_privs,
 		int			nnewmembers;
 		Oid		   *oldmembers;
 		Oid		   *newmembers;
-		bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, objectid, ENR_TSQL_TEMP));
+		bool 		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(objectid));
 
 
+		/*
+		 * Exclude objects ENR that are not backed by storage since the logic in
+		 * SearchSysCacheLocked1 to lock tuples does not apply.
+		 */
 		if (is_enr)
 			tuple = SearchSysCache1(cacheid, ObjectIdGetDatum(objectid));
 		else

src/backend/commands/dbcommands.c

@@ -54,6 +54,7 @@
 #include "parser/parser.h"
 #include "pgstat.h"
 #include "postmaster/bgwriter.h"
+#include "parser/parser.h"
 #include "replication/slot.h"
 #include "storage/copydir.h"
 #include "storage/fd.h"
@@ -1977,7 +1978,7 @@ RenameDatabase(const char *oldname, const char *newname)
 				 errdetail_busy_db(notherbackends, npreparedxacts)));
 
 	/* rename */
-	is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, db_id, ENR_TSQL_TEMP));
+	is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(db_id));
 	if (is_enr)
 		newtup = SearchSysCacheCopy1(DATABASEOID, ObjectIdGetDatum(db_id));
 	else
@@ -1987,6 +1988,10 @@ RenameDatabase(const char *oldname, const char *newname)
 	otid = newtup->t_self;
 	namestrcpy(&(((Form_pg_database) GETSTRUCT(newtup))->datname), newname);
 	CatalogTupleUpdate(rel, &otid, newtup);
+	/* 
+	 * ENR relations being backend-local are not locked 
+	 * and hence don't need to be unlocked 
+	 */
 	if (!is_enr)
 		UnlockTuple(rel, &otid, InplaceUpdateTupleLock);
 

src/backend/commands/indexcmds.c

@@ -4579,7 +4579,7 @@ update_relispartition(Oid relationId, bool newval)
 	HeapTuple	tup;
 	Relation	classRel;
 	ItemPointerData otid;
-	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, relationId, ENR_TSQL_TEMP));
+	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(relationId));
 
 	classRel = table_open(RelationRelationId, RowExclusiveLock);
 	if (is_enr)
@@ -4592,6 +4592,10 @@ update_relispartition(Oid relationId, bool newval)
 	Assert(((Form_pg_class) GETSTRUCT(tup))->relispartition != newval);
 	((Form_pg_class) GETSTRUCT(tup))->relispartition = newval;
 	CatalogTupleUpdate(classRel, &otid, tup);
+	/* 
+	 * ENR relations being backend-local are not locked 
+	 * and hence don't need to be unlocked 
+	 */
 	if (!is_enr)
 		UnlockTuple(classRel, &otid, InplaceUpdateTupleLock);
 	heap_freetuple(tup);

src/backend/commands/tablecmds.c

@@ -3819,15 +3819,14 @@ SetRelationTableSpace(Relation rel,
 	ItemPointerData otid;
 	Form_pg_class rd_rel;
 	Oid			reloid = RelationGetRelid(rel);
-	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, reloid, ENR_TSQL_TEMP));
+	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(reloid));
 
 	Assert(CheckRelationTableSpaceMove(rel, newTableSpaceId));
 
 	/* Get a modifiable copy of the relation's pg_class row. */
 	pg_class = table_open(RelationRelationId, RowExclusiveLock);
-
 	if (is_enr)
-			tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(reloid));
+		tuple = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(reloid));
 	else
 		tuple = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(reloid));
 	if (!HeapTupleIsValid(tuple))
@@ -3841,6 +3840,10 @@ SetRelationTableSpace(Relation rel,
 	if (RelFileNumberIsValid(newRelFilenumber))
 		rd_rel->relfilenode = newRelFilenumber;
 	CatalogTupleUpdate(pg_class, &otid, tuple);
+	/* 
+	 * ENR relations being backend-local are not locked 
+	 * and hence don't need to be unlocked 
+	 */
 	if (!is_enr)
 		UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
 
@@ -4344,7 +4347,7 @@ RenameRelationInternal(Oid myrelid, const char *newrelname, bool is_internal, bo
 	HeapTuple	reltup;
 	Form_pg_class relform;
 	Oid			namespaceId;
-	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, myrelid, ENR_TSQL_TEMP));
+	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(myrelid));
 
 	/*
 	 * Grab a lock on the target relation, which we will NOT release until end
@@ -4396,6 +4399,10 @@ RenameRelationInternal(Oid myrelid, const char *newrelname, bool is_internal, bo
 	namestrcpy(&(relform->relname), newrelname);
 
 	CatalogTupleUpdate(relrelation, &otid, reltup);
+	/* 
+	 * ENR relations being backend-local are not locked 
+	 * and hence don't need to be unlocked 
+	 */
 	if (!is_enr)
 		UnlockTuple(relrelation, &otid, InplaceUpdateTupleLock);
 
@@ -6220,7 +6227,7 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap)
 	BulkInsertState bistate;
 	int			ti_options;
 	ExprState  *partqualstate = NULL;
-
+	
 	/*
 	 * Open the relation(s).  We have surely already locked the existing
 	 * table.
@@ -6231,8 +6238,11 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap)
 
 	if (OidIsValid(OIDNewHeap))
 	{
-		Assert(CheckRelationOidLockedByMe(OIDNewHeap, AccessExclusiveLock,
-										  false));
+		/*
+		 * With ENRs, we don't hold locks on relation tuples.
+		 */
+		Assert((sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(OIDNewHeap)) 
+				|| CheckRelationOidLockedByMe(OIDNewHeap, AccessExclusiveLock,false));
 		newrel = table_open(OIDNewHeap, NoLock);
 	}
 	else
@@ -16770,7 +16780,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
 
 	/* Fetch heap tuple */
 	relid = RelationGetRelid(rel);
-	is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, relid, ENR_TSQL_TEMP));
+	is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(relid));
 	if (is_enr)
 		tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
 	else
@@ -19172,13 +19182,13 @@ AlterRelationNamespaceInternal(Relation classRel, Oid relOid,
 	Form_pg_class classForm;
 	ObjectAddress thisobj;
 	bool		already_done = false;
-	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, relOid, ENR_TSQL_TEMP));
+	bool		is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(relOid));
 
-	/* no rel lock for relkind=c so use LOCKTAG_TUPLE */
 	if (is_enr)
 		classTup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relOid));
-	else
+	else /* no rel lock for relkind=c so use LOCKTAG_TUPLE */
 		classTup = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(relOid));
+
 	if (!HeapTupleIsValid(classTup))
 		elog(ERROR, "cache lookup failed for relation %u", relOid);
 	classForm = (Form_pg_class) GETSTRUCT(classTup);
@@ -19212,22 +19222,30 @@ AlterRelationNamespaceInternal(Relation classRel, Oid relOid,
 		classForm->relnamespace = newNspOid;
 
 		CatalogTupleUpdate(classRel, &otid, classTup);
+		/* 
+		 * ENR relations being backend-local are not locked 
+		 * and hence don't need to be unlocked 
+		 */
 		if (!is_enr)
 			UnlockTuple(classRel, &otid, InplaceUpdateTupleLock);
 
-
-		/* Update dependency on schema if caller said so */
 		if (hasDependEntry &&
 			changeDependencyFor(RelationRelationId,
 								relOid,
 								NamespaceRelationId,
-								oldNspOid,
 								newNspOid) != 1)
 			elog(ERROR, "could not change schema dependency for relation \"%s\"",
 				 NameStr(classForm->relname));
 	}
-	else if (!is_enr)
-		UnlockTuple(classRel, &classTup->t_self, InplaceUpdateTupleLock);
+	else
+	{
+		/* 
+		 * ENR relations being backend-local are not locked 
+		 * and hence don't need to be unlocked 
+		 */
+		if (!is_enr)
+			UnlockTuple(classRel, &classTup->t_self, InplaceUpdateTupleLock);
+	}	
 	if (!already_done)
 	{
 		add_exact_object_address(&thisobj, objsMoved);

src/backend/executor/execMain.c

@@ -597,6 +597,7 @@ ExecCheckPermissions(List *rangeTable, List *rteperminfos,
 	foreach(l, rangeTable)
 	{
 		RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
+		bool 		  is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(rte->relid));
 
 		if (rte->perminfoindex != 0)
 		{
@@ -610,6 +611,22 @@ ExecCheckPermissions(List *rangeTable, List *rteperminfos,
 				   (rte->rtekind == RTE_SUBQUERY &&
 					rte->relkind == RELKIND_VIEW));
 
+			/*
+			 * Ensure that we have at least an AccessShareLock on relations
+			 * whose permissions need to be checked.
+			 *
+			 * Skip this check in a parallel worker because locks won't be
+			 * taken until ExecInitNode() performs plan initialization.
+			 * 
+			 * Skip this check if this relation is in ENR since we don't hold
+			 * locks for relations in ENRs
+			 * 
+			 * XXX: ExecCheckPermissions() in a parallel worker may be
+			 * redundant with the checks done in the leader process, so this
+			 * should be reviewed to ensure it’s necessary.
+			 */
+			Assert(IsParallelWorker() || is_enr || CheckRelationOidLockedByMe(rte->relid, AccessShareLock, true));
+
 			(void) getRTEPermissionInfo(rteperminfos, rte);
 			/* Many-to-one mapping not allowed */
 			Assert(!bms_is_member(rte->perminfoindex, indexset));

src/backend/utils/cache/inval.c

@@ -1756,7 +1756,7 @@ CacheInvalidateENRHeapTuple(Relation relation,
 								HeapTuple newtuple)
 {
 	CacheInvalidateENRHeapTupleCommon(relation, tuple, newtuple,
-								   PrepareInplaceInvalidationState);
+								   PrepareInvalidationState);
 }
 
 /*

src/backend/utils/cache/relcache.c

@@ -3782,7 +3782,7 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 	MultiXactId minmulti = InvalidMultiXactId;
 	TransactionId freezeXid = InvalidTransactionId;
 	RelFileLocator newrlocator;
-	bool			is_enr = false;
+	bool		   is_enr = false;
 
 	if (!IsBinaryUpgrade)
 	{
@@ -3819,14 +3819,13 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 	 * Get a writable copy of the pg_class tuple for the given relation.
 	 */
 	pg_class = table_open(RelationRelationId, RowExclusiveLock);
-
-	is_enr = (sql_dialect == SQL_DIALECT_TSQL && get_ENR_withoid(currentQueryEnv, RelationGetRelid(relation), ENR_TSQL_TEMP));
+	is_enr = (sql_dialect == SQL_DIALECT_TSQL && GetENRTempTableWithOid(RelationGetRelid(relation)));
 	if (is_enr)
 		tuple = SearchSysCacheCopy1(RELOID,
-									ObjectIdGetDatum(RelationGetRelid(relation)));
+									  ObjectIdGetDatum(RelationGetRelid(relation)));
 	else
 		tuple = SearchSysCacheLockedCopy1(RELOID,
-										  ObjectIdGetDatum(RelationGetRelid(relation)));
+									  ObjectIdGetDatum(RelationGetRelid(relation)));
 	if (!HeapTupleIsValid(tuple))
 		elog(ERROR, "could not find tuple for relation %u",
 			 RelationGetRelid(relation));
@@ -3953,7 +3952,10 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 
 		CatalogTupleUpdate(pg_class, &otid, tuple);
 	}
-
+	/* 
+	 * ENR relations being backend-local are not locked 
+	 * and hence don't need to be unlocked 
+	 */
 	if (!is_enr)
 		UnlockTuple(pg_class, &otid, InplaceUpdateTupleLock);
 	heap_freetuple(tuple);

src/backend/utils/cache/syscache.c

@@ -308,7 +308,7 @@ ReleaseSysCache(HeapTuple tuple)
  *
  * The returned tuple may be the subject of an uncommitted update, so this
  * doesn't prevent the "tuple concurrently updated" error.
- * 
+ *
  * Note: For Babelfish, this function should not be used if the target tuple is
  * for an ENR entry, as there is no physical tid for ENR catalog tuples (since ENR
  * entries hold all catalog data internally in their cache). Use SearchSysCache1() instead