Fix uninitialized index information access during apply.

The issue happens when building conflict information during apply of
INSERT or UPDATE operations that violate unique constraints on leaf
partitions.

The problem was introduced in commit 9ff68679b5, which removed the
redundant calls to ExecOpenIndices/ExecCloseIndices. The previous code was
relying on the redundant ExecOpenIndices call in
apply_handle_tuple_routing() to build the index information required for
unique key conflict detection.

The fix is to delay building the index information until a conflict is
detected instead of relying on ExecOpenIndices to do the same. The
additional benefit of this approach is that it avoids building index
information when there is no conflict.

Author: Hou Zhijie <houzj.fnst@fujitsu.com>
Reviewed-by:Reviewed-by: Amit Kapila <amit.kapila16@gmail.com>
Discussion: https://postgr.es/m/TYAPR01MB57244ADA33DDA57119B9D26494A62@TYAPR01MB5724.jpnprd01.prod.outlook.com

2 files changed, 32 insertions, 3 deletions

diff --git a/src/backend/executor/execIndexing.c b/src/backend/executor/execIndexing.c
index e3fe9b78bb5..bdf862b2406 100644
--- a/src/backend/executor/execIndexing.c
+++ b/src/backend/executor/execIndexing.c
@@ -214,9 +214,8 @@ ExecOpenIndices(ResultRelInfo *resultRelInfo, bool speculative)
 		ii = BuildIndexInfo(indexDesc);
 
 		/*
-		 * If the indexes are to be used for speculative insertion or conflict
-		 * detection in logical replication, add extra information required by
-		 * unique index entries.
+		 * If the indexes are to be used for speculative insertion, add extra
+		 * information required by unique index entries.
 		 */
 		if (speculative && ii->ii_Unique && !indexDesc->rd_index->indisexclusion)
 			BuildSpeculativeIndexInfo(indexDesc, ii);
diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c
index ede89ea3cf9..53ddd25c42d 100644
--- a/src/backend/executor/execReplication.c
+++ b/src/backend/executor/execReplication.c
@@ -432,6 +432,30 @@ retry:
 }
 
 /*
+ * Build additional index information necessary for conflict detection.
+ */
+static void
+BuildConflictIndexInfo(ResultRelInfo *resultRelInfo, Oid conflictindex)
+{
+	for (int i = 0; i < resultRelInfo->ri_NumIndices; i++)
+	{
+		Relation	indexRelation = resultRelInfo->ri_IndexRelationDescs[i];
+		IndexInfo  *indexRelationInfo = resultRelInfo->ri_IndexRelationInfo[i];
+
+		if (conflictindex != RelationGetRelid(indexRelation))
+			continue;
+
+		/*
+		 * This Assert will fail if BuildSpeculativeIndexInfo() is called
+		 * twice for the given index.
+		 */
+		Assert(indexRelationInfo->ii_UniqueOps == NULL);
+
+		BuildSpeculativeIndexInfo(indexRelation, indexRelationInfo);
+	}
+}
+
+/*
  * Find the tuple that violates the passed unique index (conflictindex).
  *
  * If the conflicting tuple is found return true, otherwise false.
@@ -452,6 +476,12 @@ FindConflictTuple(ResultRelInfo *resultRelInfo, EState *estate,
 
 	*conflictslot = NULL;
 
+	/*
+	 * Build additional information required to check constraints violations.
+	 * See check_exclusion_or_unique_constraint().
+	 */
+	BuildConflictIndexInfo(resultRelInfo, conflictindex);
+
 retry:
 	if (ExecCheckIndexConstraints(resultRelInfo, slot, estate,
 								  &conflictTid, &slot->tts_tid,