From 5fc2e2be7fe2fb8ba7765e24ab623d3e6993b72f Mon Sep 17 00:00:00 2001
From: Viktor Kurilko <murlockkinght@gmail.com>
Date: Fri, 13 Oct 2023 12:13:37 +0300
Subject: [PATCH 01/22] Fix deadlock in case of the bottleneck HashJoin with
 shared scan below (#620)

Disabling the prefetch_inner mechanism for HashJoin, when the join is on the
bottleneck, could lead to a deadlock if there is a SharedScan in both parts of
the join. The deadlock occured because SharedScan producer in the inner part of
the join, and consumer in the outer. Thus consumer couldn't perform the shared
scan without prefetching the inner part.

The SharedScan producer for HashJoin is always created under the inner part,
because shareinput_walker function always processes HashJoin node from the Hash
part. For CTEs the prefetching was enabled for all cases, except the bottleneck
join, because CTE path is marked as motionHazard. Therefore, if prefetch_inner
is disabled, the executor can start performing join from the outer part while
the SharedScan producer will be inside the inner part and this will probably
lead to the deadlock if the SharedScan is cross-slice.

This patch fixes this by enabling prefetch_inner for HashJoin on bottleneck when
traversing the plan in shareinput_mutator_dag_to_tree if there are shared scans
in the plan and join is on the bottleneck.
---
 src/backend/cdb/cdbmutate.c        | 17 +++++++++++++++++
 src/test/regress/expected/with.out | 19 +++++++++++++++++++
 src/test/regress/sql/with.sql      | 18 ++++++++++++++++++
 3 files changed, 54 insertions(+)

diff --git a/src/backend/cdb/cdbmutate.c b/src/backend/cdb/cdbmutate.c
index fedee52c7f00..21da452b71a2 100644
--- a/src/backend/cdb/cdbmutate.c
+++ b/src/backend/cdb/cdbmutate.c
@@ -2086,7 +2086,24 @@ shareinput_mutator_dag_to_tree(Node *node, PlannerInfo *root, bool fPop)
 	Plan	   *plan = (Plan *) node;
 
 	if (fPop)
+	{
+		/*
+		 * If there is a shared scan under HashJoin, producer is in the inner
+		 * subplan and consumer is in the outer, then we need to enable
+		 * prefetch_inner to avoid deadlock. The deadlock can occur when
+		 * prefetch_inner is disabled and the executor can start performing the
+		 * join from the outer part. In the case of bottleneck, we can turn off
+		 * prefetch_inner for optimization reasons in the create_join_plan
+		 * function. So we need to turn it back on. To simplify the logic, we
+		 * enable prefetch_inner for all hash joins located on bottleneck if
+		 * there is a shared scan in the plan.
+		 */
+		if (IsA(plan, HashJoin) && ctxt->producer_count > 0 &&
+			CdbPathLocus_IsBottleneck(*(plan->flow)))
+			((Join*) plan)->prefetch_inner = true;
+
 		return true;
+	}
 
 	if (IsA(plan, ShareInputScan))
 	{
diff --git a/src/test/regress/expected/with.out b/src/test/regress/expected/with.out
index d02090be3412..4f449766740e 100644
--- a/src/test/regress/expected/with.out
+++ b/src/test/regress/expected/with.out
@@ -2261,3 +2261,22 @@ SELECT * FROM cte1 a JOIN cte1 b USING (c1);
 (1 row)
 
 DROP TABLE t1;
+-- Ensure that prefetch is not disabled for HashJoin in case of join at single segment.
+-- Test Shared Scan producer is executed under inner part of join first and the
+-- deadlock between Shared Scans does not occur
+SET optimizer = off;
+--start_ignore
+DROP TABLE IF EXISTS d;
+--end_ignore
+CREATE TABLE d (c1 int, c2 int) DISTRIBUTED BY (c1);
+INSERT INTO d VALUES ( 2, 0 ),( 2, 0 );
+WITH cte AS (
+	SELECT count(*) c1 FROM d
+) SELECT * FROM cte a JOIN (SELECT * FROM d JOIN cte USING (c1) LIMIT 1) b USING (c1);
+ c1 | c2 
+----+----
+  2 |  0
+(1 row)
+
+RESET optimizer;
+DROP TABLE d;
diff --git a/src/test/regress/sql/with.sql b/src/test/regress/sql/with.sql
index b8e60a346035..72b89a0f0c97 100644
--- a/src/test/regress/sql/with.sql
+++ b/src/test/regress/sql/with.sql
@@ -1065,3 +1065,21 @@ WITH cte1 AS (
 SELECT * FROM cte1 a JOIN cte1 b USING (c1);
 
 DROP TABLE t1;
+
+-- Ensure that prefetch is not disabled for HashJoin in case of join at single segment.
+-- Test Shared Scan producer is executed under inner part of join first and the
+-- deadlock between Shared Scans does not occur
+SET optimizer = off;
+--start_ignore
+DROP TABLE IF EXISTS d;
+--end_ignore
+CREATE TABLE d (c1 int, c2 int) DISTRIBUTED BY (c1);
+
+INSERT INTO d VALUES ( 2, 0 ),( 2, 0 );
+
+WITH cte AS (
+	SELECT count(*) c1 FROM d
+) SELECT * FROM cte a JOIN (SELECT * FROM d JOIN cte USING (c1) LIMIT 1) b USING (c1);
+
+RESET optimizer;
+DROP TABLE d;

From e971286894929db3e071aa87198ae97905e2f14d Mon Sep 17 00:00:00 2001
From: Alexandr Barulev <huston.mavr@gmail.com>
Date: Thu, 19 Oct 2023 06:30:06 +0300
Subject: [PATCH 02/22] ADBDEV-4349: gplogfilter: fix timerange validation
 (#627)

Previously the time range filtering of log files was incorrect: there
was a check for belonging a log file to specified time range which
worked like a binary `AND` (if time < begin AND time > end - skip
file), but something like binary `OR` is needed here. Thus file
filtering never worked. Also this validation was executed after the
file was opened, so in case of failed validation there was a redundant
`open/close` operations. This patch fixes such behavior, by:
- moving the logic of belonging log file name the user specified range
  to the separate function (it's also helps to cover corner cases)
- skip file processing, if it doesn't belong to range, at the
  begin of loop to prevent redundant `open/close` operations
---
 gpMgmt/bin/gplogfilter                        |  63 ++++-----
 gpMgmt/bin/gppylib/logfilter.py               | 121 ++++++++++++++++
 .../gppylib/test/unit/test_unit_logfilter.py  | 132 ++++++++++++++++++
 gpMgmt/test/behave/mgmt_utils/environment.py  |   9 +-
 .../behave/mgmt_utils/gplogfilter.feature     |  67 +++++++++
 .../behave/mgmt_utils/steps/gplogfilter.py    |  43 ++++++
 6 files changed, 395 insertions(+), 40 deletions(-)
 create mode 100644 gpMgmt/bin/gppylib/test/unit/test_unit_logfilter.py
 create mode 100644 gpMgmt/test/behave/mgmt_utils/gplogfilter.feature
 create mode 100644 gpMgmt/test/behave/mgmt_utils/steps/gplogfilter.py

diff --git a/gpMgmt/bin/gplogfilter b/gpMgmt/bin/gplogfilter
index 09f36cf2f162..f57807f8a1e8 100755
--- a/gpMgmt/bin/gplogfilter
+++ b/gpMgmt/bin/gplogfilter
@@ -361,6 +361,12 @@ if (options.zip is None and
     options.zip = '9'
 
 try:
+    if (begin and end) and begin >= end:
+        raise IOError(
+            'Invalid arguments: "begin" date (%s) is >= "end" date (%s)'
+            % (begin, end)
+        )
+
     # If no inputfile arg, try MASTER_DATA_DIRECTORY environment variable
     if len(args) == 0:
         s = os.getenv('MASTER_DATA_DIRECTORY')
@@ -400,44 +406,27 @@ try:
                    % (begin or 'beginning of data', end or 'end of data'))
             print >> sys.stderr, msg
 
-        # Loop over input files
-        for ifn in args:
-            """ 
-            Open each file in the logs directory. Check to see if the file name
-            looks anything like a log file name with a time stamp that we 
-            recognize. If true, and the user specified a time range, skip the
-            file if it is outside the range. That is, close the file and any
-            associated temporary files.
-
-            All other files with names that do not look like time stamps are
-            processed. That is, their log information is extracted, and if 
-            the user specified a time range, only those entries that are
-            within that range are kept.
-            """
+        # transform given array of log names (args array) into corresponding
+        # array of LogNameInfo structures. Final array is concatenation of
+        # LogNameInfo arrays with and without timestamps in log names.
+        # Both arrays are ordered:
+        # - first part is ordered by the time stamp of log name and after by
+        #   name (in case of time stamp equality)
+        # - second part is ordered by name and lays out at the end
+        # All LogNameInfo structures are marked for belonging to the user
+        # specified time range. Log names without time stamp always should
+        # be processed, because them may contain log entries inside specified
+        # range, so LogNameInfo for such names always marked as belonging to
+        # the range.
+        logsInfoArr = getLogInfoArrayByNamesOrderedAndMarkedInTSRange(args, begin, end)
+
+        for logInfo in logsInfoArr:
+            if not logInfo.belongsToTimeRangeFilter:
+                print >> sys.stderr, "SKIP file: %s" % logInfo.name
+                continue
+
             # Open next input file
-            fileIn, inputFilesToClose, ifn, zname = openInputFile(ifn, options)
-
-            # if we can skip the whole file, let's do so
-            if zname.startswith('gpdb') and zname.endswith('.csv'):
-                goodFormat = True
-                try:
-                    # try format YYYY-MM-DD_HHMMSS
-                    filedate = datetime.strptime(zname[5:-4], '%Y-%m-%d_%H%M%S')
-                except:
-                    try:
-                        # try format YYYY-MM-DD
-                        filedate = datetime.strptime(zname[5:-4], '%Y-%m-%d')
-                    except:
-                        # the format isn't anything I understand
-                        goodFormat = False
-
-                if goodFormat and begin and filedate < begin:
-                    if end and filedate > end:
-                        print >> sys.stderr, "SKIP file: %s" % zname
-                        for f in inputFilesToClose:
-                            f.close()
-                        inputFilesToClose = []
-                        continue
+            fileIn, inputFilesToClose, ifn, zname = openInputFile(logInfo.name, options)
 
             # Announce each input file *before* its output file if --out is dir
             if options.verbose and outputFilePerInputFile:
diff --git a/gpMgmt/bin/gppylib/logfilter.py b/gpMgmt/bin/gppylib/logfilter.py
index 6bcbcfd28267..d3eb86263641 100644
--- a/gpMgmt/bin/gppylib/logfilter.py
+++ b/gpMgmt/bin/gppylib/logfilter.py
@@ -57,6 +57,14 @@
 # A timezone specifier may follow the timestamp, but we ignore that.
 
 
+# This pattern matches the date and time stamp at the log file name of a
+# GPDB log file. The timestamp format is: YYYY-MM-DD_HHMMSS or the
+# YYYY-MM-DD (to preserve an old behaviour).
+logNameTSPattern = re.compile(
+    '^.*gpdb-(?P<datetime>\d+-\d+-\d+(?P<time>_\d+)?)\.csv$'
+)
+
+
 def FilterLogEntries(iterable,
                      msgfile=sys.stderr,
                      verbose=False,
@@ -981,3 +989,116 @@ def spiffInterval(begin=None, end=None, duration=None):
 
     return begin, end
 
+class LogNameInfo(object):
+    """
+    Object to store main information about log file name:
+    - name of log file
+    - parsed time stamp from name, if exists
+    - belonging to user specified time range
+    """
+    def __init__(self, name, dateTime=None, belongsToTimeRangeFilter=True):
+        self.name = name
+        self.dateTime = dateTime
+        self.belongsToTimeRangeFilter = belongsToTimeRangeFilter
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            raise TypeError('comparing different types: %s and %s' % (type(self), type(other)))
+
+        return (self.name == other.name and self.dateTime == other.dateTime
+                and self.belongsToTimeRangeFilter == other.belongsToTimeRangeFilter)
+
+def _parseLogFileName(name):
+    """
+    Parses log file into LogNameInfo. The log name may contain the time
+    stamp, when it was created, so if log name matches `logNameTSPattern`
+    the result LogNameInfo would contain this time stamp, but there may be
+    other log files that doesn't match such format (for ex. startup.log) in
+    such case result won't contain time stamp.
+    """
+
+    # matchedGroup in case of match would be not None and contains next
+    # groups:
+    # - group(0) - whole file name
+    # - group('datetime') - timestamp of log (may be without time suffix)
+    # - group('time') - not None if time suffix exists
+    matchedGroup = logNameTSPattern.match(name)
+
+    if not matchedGroup:
+        return LogNameInfo(name)
+
+    pattern = '%Y-%m-%d'
+    if matchedGroup.group('time'):
+        # we have time preix, so use extended pattern
+        pattern = '%Y-%m-%d_%H%M%S'
+
+    dt = None
+    try:
+        dt = datetime.strptime(matchedGroup.group('datetime'), pattern)
+    except:
+        pass
+
+    return LogNameInfo(name, dt)
+
+def _getOrderedLogNameInfoArrByNameTS(fileNames):
+    """
+    By the given array of log names this function returns ordered LogNameInfo
+    array. The returned array is a concatenation of two LogNameInfo arrays
+    with time stamp in log name and without. Both arrays are ordered:
+    - first part is ordered by the time stamp of log name and after by the log
+    name. Ordering by name is used for test purposes, because under the normal
+    conditions log directory shouldn't contain different log files with the same
+    time stamp, but with different string representation of time stamp (for ex.
+    gpdb-2023-1-1_000000.csv and gpdb-2023-01-01_000000.csv, the last variant is
+    a correct representation of log name with time stamp).
+    - the second part is ordered only by name.
+    """
+
+    withTS = []
+    withoutTS = []
+    for name in fileNames:
+        info = _parseLogFileName(name)
+        if info.dateTime:
+            withTS.append(info)
+        else:
+            withoutTS.append(info)
+
+    withTS.sort(key = lambda x: (x.dateTime, x.name))
+    withoutTS.sort(key = lambda x: x.name)
+    return withTS + withoutTS
+
+
+def getLogInfoArrayByNamesOrderedAndMarkedInTSRange(logNames, begin, end):
+    """
+    By the given array of log names and time range filters `begin` (inclusive)
+    and `end` (exclusive) this function returns the ordered array of LogNameInfo,
+    where each LogNameInfo is marked for belonging to the given range.
+    Array is ordered by the log time stamp (and in case of equaltiy by the name)
+    log file names without time stamp is ordered by name and lays out at the end
+    of array.
+    """
+
+    orderedInfoArr = _getOrderedLogNameInfoArrByNameTS(logNames)
+
+    # we should find the nearest date before (or equal) the user-specified
+    # `begin` inside dates from log file names, because of each file with time
+    # stamp contain log entries with time stamp, matching next range:
+    # time stamp of log name <= time stamp of log entry AND
+    # time stamp of log entry < (log name time stamp + GUC:`log_rotation_age`) or restart time
+    beginDateRounded = begin
+    if beginDateRounded:
+        for info in orderedInfoArr:
+            if info.dateTime is None or begin < info.dateTime:
+                break
+            beginDateRounded = info.dateTime
+
+    for info in orderedInfoArr:
+        dt = info.dateTime
+        if dt is None:
+            # file names without time stamp - no need to process
+            break
+
+        if (beginDateRounded and dt < beginDateRounded) or (end and end <= dt):
+            info.belongsToTimeRangeFilter = False
+
+    return orderedInfoArr
diff --git a/gpMgmt/bin/gppylib/test/unit/test_unit_logfilter.py b/gpMgmt/bin/gppylib/test/unit/test_unit_logfilter.py
new file mode 100644
index 000000000000..c4f0aa53d090
--- /dev/null
+++ b/gpMgmt/bin/gppylib/test/unit/test_unit_logfilter.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+
+import unittest
+import yaml
+from datetime import datetime
+import gppylib.logfilter as lf
+
+class GppylibLogFilterTestCase(unittest.TestCase):
+    def test_parse_log_name(self):
+        testData = [
+            ('gp_era', lf.LogNameInfo('gp_era', None, True)),
+            ('startup.log', lf.LogNameInfo('startup.log', None, True)),
+            ('gpdb-2023-10-05_090100.csv', lf.LogNameInfo('gpdb-2023-10-05_090100.csv', datetime(2023, 10, 5, 9, 1), True)),
+            ('gpdb-2023-10-05_09050.csv', lf.LogNameInfo('gpdb-2023-10-05_09050.csv', datetime(2023, 10, 5, 9, 5), True)),
+            ('gpdb-2023-10-05.csv', lf.LogNameInfo('gpdb-2023-10-05.csv', datetime(2023, 10, 5, 0, 0), True)),
+            ('gpdb-2023-10-05_09010.csv', lf.LogNameInfo('gpdb-2023-10-05_09010.csv', datetime(2023, 10, 5, 9, 1), True)),
+            ('gpdb-23-10-05_09011.csv', lf.LogNameInfo('gpdb-23-10-05_09011.csv', None, True)), # invalid format %Y should have 4 digits
+            ('gpdb-2023-1-05_2000.csv', lf.LogNameInfo('gpdb-2023-1-05_2000.csv', datetime(2023, 1, 5, 20, 0), True)),
+            ('gpdb-2023-1-5_0000.csv', lf.LogNameInfo('gpdb-2023-1-5_0000.csv', datetime(2023, 1, 5, 0, 0), True)),
+        ]
+
+        for testTuple in testData:
+            got = lf._parseLogFileName(testTuple[0])
+            expected = testTuple[1]
+            self.assertEqual(got, expected, '\nEXPECTED:\n%s\nGOT:\n%s' % (yaml.dump(got), yaml.dump(expected)))
+
+    def test_getOrderedLogNameInfoArrByNameTS(self):
+        # only file names without timestamp
+        fNamesWithoutTS = ['b', 'c', 'a']
+        expectedOrderWithoutTS = [
+            lf.LogNameInfo('a'), lf.LogNameInfo('b'), lf.LogNameInfo('c'),
+        ]
+        self.assertEqual(lf._getOrderedLogNameInfoArrByNameTS(fNamesWithoutTS), expectedOrderWithoutTS)
+
+        # only fiile names with timestamp
+        fNamesWithTS = ['gpdb-2023-10-05_090100.csv', 'gpdb-2023-01-05_090100.csv', 'gpdb-2023-2-05_080000.csv']
+        expectedOrderWithTS = [
+            lf.LogNameInfo('gpdb-2023-01-05_090100.csv', datetime(2023, 1, 5, 9, 1), True),
+            lf.LogNameInfo('gpdb-2023-2-05_080000.csv', datetime(2023, 2, 5, 8, 0), True),
+            lf.LogNameInfo('gpdb-2023-10-05_090100.csv', datetime(2023, 10, 5, 9, 1), True),
+        ]
+        self.assertEqual(lf._getOrderedLogNameInfoArrByNameTS(fNamesWithTS), expectedOrderWithTS)
+
+        # combination of file names with and w/o timestamps
+        self.assertEqual(
+            lf._getOrderedLogNameInfoArrByNameTS(fNamesWithoutTS + fNamesWithTS),
+            expectedOrderWithTS + expectedOrderWithoutTS
+        )
+
+    def test_getLogInfoArrayByNamesOrderedAndMarkedInTSRange_corner(self):
+        fnToTest = lf.getLogInfoArrayByNamesOrderedAndMarkedInTSRange
+
+        ########################
+        # empty input
+        self.assertEqual([], fnToTest([], None, None))
+
+        ########################
+        # test `begin` date: there would be always one file which is not skipped even begin date is
+        # greater than it's time stamp
+        testArr = ['gpdb-2023-10-05_000000.csv']
+        expectedArr = [lf.LogNameInfo('gpdb-2023-10-05_000000.csv', datetime(2023, 10, 5), True)]
+        self.assertEqual(expectedArr, fnToTest(testArr, None, None))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 10, 5), None))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 10, 6), None))
+
+        ########################
+        # test `end`` date
+        self.assertEqual(expectedArr, fnToTest(testArr, None, datetime(2023, 10, 6)))
+
+        expectedArr[0].belongsToTimeRangeFilter = False
+        self.assertEqual(expectedArr, fnToTest(testArr, None, datetime(2023, 10, 5)))
+        self.assertEqual(expectedArr, fnToTest(testArr, None, datetime(2023, 10, 4)))
+
+        ########################
+        # test file that doesn't match time stamp pattern it would be always not skipped
+        testArr = ['status.log']
+        expectedArr = [lf.LogNameInfo('status.log', None, True)]
+        self.assertEqual(expectedArr, fnToTest(testArr, None, None))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 10, 5), None))
+        self.assertEqual(expectedArr, fnToTest(testArr, None, datetime(2023, 10, 5)))
+
+        ########################
+        # test complex queries
+        testArr = [
+            'gp_era',
+            'startup.log',
+            'gpdb-2023-10-05_090100.csv',
+            'gpdb-2023-10-05_09050.csv',
+            'gpdb-2023-10-05.csv',
+            'gpdb-2023-10-5.csv',
+            'gpdb-2023-10-05_09010.csv',
+            'gpdb-23-10-05_09011.csv',
+            'gpdb-2023-1-05_2000.csv',
+            'gpdb-2023-1-5_0000.csv',
+            'gpdb-9999-12-31_235959.csv'
+        ]
+
+        # ordered by the time stamp and after by name (file names without timestamp are considered as
+        # datetime.max)
+        expectedArr = [
+            lf.LogNameInfo('gpdb-2023-1-5_0000.csv', datetime(2023, 1, 5, 0, 0), True), # format changed - first number of day is skipped and time doesn't contain seconds
+            lf.LogNameInfo('gpdb-2023-1-05_2000.csv', datetime(2023, 1, 5, 20, 0), True), # format changed - time doesn't contain seconds
+            lf.LogNameInfo('gpdb-2023-10-05.csv', datetime(2023, 10, 5, 0, 0), True), # format changed - no time prefix
+            lf.LogNameInfo('gpdb-2023-10-5.csv', datetime(2023, 10, 5, 0, 0), True), # format changed - first number of day is skipped
+            lf.LogNameInfo('gpdb-2023-10-05_09010.csv', datetime(2023, 10, 5, 9, 1), True), # format changed - last second is skipped
+            lf.LogNameInfo('gpdb-2023-10-05_090100.csv', datetime(2023, 10, 5, 9, 1), True),
+            lf.LogNameInfo('gpdb-2023-10-05_09050.csv', datetime(2023, 10, 5, 9, 5), True), # format changed - last second skipped
+            lf.LogNameInfo('gpdb-9999-12-31_235959.csv', datetime(9999, 12, 31, 23, 59, 59), True), # timestamp is around datetime.max
+            # files without timestamps
+            lf.LogNameInfo('gp_era', None, True),
+            lf.LogNameInfo('gpdb-23-10-05_09011.csv', None, True),
+            lf.LogNameInfo('startup.log', None, True),
+        ]
+
+        # all matches
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime.min, datetime.max))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime.min, datetime.max))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 1, 5, 10), datetime.max))
+
+        # first element doesn't match the `begin` date
+        expectedArr[0].belongsToTimeRangeFilter = False
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 1, 5, 20), datetime.max))
+        self.assertEqual(expectedArr, fnToTest(testArr, datetime(2023, 1, 5, 21), datetime.max))
+
+        # `end` date is added
+        expectedArr[-4].belongsToTimeRangeFilter = False
+        expectedArr[-5].belongsToTimeRangeFilter = False
+        expectedArr[-6].belongsToTimeRangeFilter = False
+        expectedArr[-7].belongsToTimeRangeFilter = False
+        self.assertEqual(expectedArr,
+            fnToTest(testArr, datetime(2023, 1, 5, 20), datetime(2023, 10, 5, 9, 1))
+        )
diff --git a/gpMgmt/test/behave/mgmt_utils/environment.py b/gpMgmt/test/behave/mgmt_utils/environment.py
index 07011b840136..92f0b51312f6 100644
--- a/gpMgmt/test/behave/mgmt_utils/environment.py
+++ b/gpMgmt/test/behave/mgmt_utils/environment.py
@@ -21,7 +21,8 @@ def before_all(context):
 def before_feature(context, feature):
     # we should be able to run gpexpand without having a cluster initialized
     tags_to_skip = ['gpexpand', 'gpaddmirrors', 'gpstate', 'gpmovemirrors',
-                    'gpconfig', 'gpssh-exkeys', 'gpstop', 'gpinitsystem', 'cross_subnet']
+                    'gpconfig', 'gpssh-exkeys', 'gpstop', 'gpinitsystem', 'cross_subnet',
+                    'gplogfilter']
     if set(context.feature.tags).intersection(tags_to_skip):
         return
 
@@ -119,7 +120,8 @@ def before_scenario(context, scenario):
         context.gpssh_exkeys_context = GpsshExkeysMgmtContext(context)
 
     tags_to_skip = ['gpexpand', 'gpaddmirrors', 'gpstate', 'gpmovemirrors',
-                    'gpconfig', 'gpssh-exkeys', 'gpstop', 'gpinitsystem', 'cross_subnet']
+                    'gpconfig', 'gpssh-exkeys', 'gpstop', 'gpinitsystem', 'cross_subnet',
+                    'gplogfilter']
     if set(context.feature.tags).intersection(tags_to_skip):
         return
 
@@ -151,7 +153,8 @@ def after_scenario(context, scenario):
 
     # NOTE: gpconfig after_scenario cleanup is in the step `the gpconfig context is setup`
     tags_to_skip = ['gpexpand', 'gpaddmirrors', 'gpinitstandby',
-                    'gpconfig', 'gpstop', 'gpinitsystem', 'cross_subnet']
+                    'gpconfig', 'gpstop', 'gpinitsystem', 'cross_subnet',
+                    'gplogfilter']
     if set(context.feature.tags).intersection(tags_to_skip):
         return
 
diff --git a/gpMgmt/test/behave/mgmt_utils/gplogfilter.feature b/gpMgmt/test/behave/mgmt_utils/gplogfilter.feature
new file mode 100644
index 000000000000..de5611de1d38
--- /dev/null
+++ b/gpMgmt/test/behave/mgmt_utils/gplogfilter.feature
@@ -0,0 +1,67 @@
+@gplogfilter
+Feature: gplogfilter tests
+    Scenario: invalid begin and end arguments
+        When the user runs "gplogfilter -b "2023-10-05 09:01" -e "2023-10-05 09:01""
+        Then gplogfilter should print "gplogfilter: \(IOError\) "Invalid arguments: "begin" date \(2023-10-05 09:01:00\) is >= "end" date \(2023-10-05 09:01:00\)"" error message
+        When the user runs "gplogfilter -b "2023-10-05 09:01:01" -e "2023-10-05 09:00:00""
+        Then gplogfilter should print "gplogfilter: \(IOError\) "Invalid arguments: "begin" date \(2023-10-05 09:01:01\) is >= "end" date \(2023-10-05 09:00:00\)"" error message
+
+    Scenario: time range covers all files
+        Given log directory with files
+            | name                       |
+            | status.log                 |
+            | gpdb-2023-1-1_000000.csv   |
+            | gpdb-2022-12-31_235959.csv |
+        When under changed DATA_DIR user runs "gplogfilter"
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2022-12-31_235959.csv |
+            | gpdb-2023-1-1_000000.csv   |
+            | status.log                 |
+        When under changed DATA_DIR user runs "gplogfilter -b "1990-1-1" -e "9999-12-31""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2022-12-31_235959.csv |
+            | gpdb-2023-1-1_000000.csv   |
+            | status.log                 |
+        When under changed DATA_DIR user runs "gplogfilter -b "2022-12-31""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2022-12-31_235959.csv |
+            | gpdb-2023-1-1_000000.csv   |
+            | status.log                 |
+        When under changed DATA_DIR user runs "gplogfilter -e "2024-1-1""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2022-12-31_235959.csv |
+            | gpdb-2023-1-1_000000.csv   |
+            | status.log                 |
+
+    Scenario: time range doesn't covers all files
+        Given log directory with files
+            | name                       |
+            | status.log                 |
+            | gpdb-2023-1-5_0000.csv     |
+            | gpdb-2023-1-05_2000.csv    |
+            | gpdb-2023-10-05_09010.csv  |
+            | gpdb-2023-10-05_090100.csv |
+            | gpdb-2023-10-05_09050.csv  |
+        When under changed DATA_DIR user runs "gplogfilter -b "2023-10-05 09:01""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2023-10-05_09010.csv  |
+            | gpdb-2023-10-05_090100.csv |
+            | gpdb-2023-10-05_09050.csv  |
+            | status.log                 |
+        When under changed DATA_DIR user runs "gplogfilter -e "2023-01-05 20:00""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2023-1-5_0000.csv     |
+            | status.log                 |
+        When under changed DATA_DIR user runs "gplogfilter -b "2023-10-05" -e "2023-10-05 09:05""
+        Then gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)
+            | name                       |
+            | gpdb-2023-1-05_2000.csv    |
+            | gpdb-2023-10-05_09010.csv  |
+            | gpdb-2023-10-05_090100.csv |
+            | status.log                 |
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/gplogfilter.py b/gpMgmt/test/behave/mgmt_utils/steps/gplogfilter.py
new file mode 100644
index 000000000000..2d0c6ce1fe09
--- /dev/null
+++ b/gpMgmt/test/behave/mgmt_utils/steps/gplogfilter.py
@@ -0,0 +1,43 @@
+import os
+import tempfile
+import yaml
+
+from behave import given, when, then
+from test.behave_utils.utils import *
+
+def parse_processed_files(cmdOutput):
+    res = []
+    for line in cmdOutput.splitlines():
+        if line.startswith('-'):
+            res.append(os.path.basename(line.strip('- ')))
+    return res
+
+@given('log directory with files')
+def impl(context):
+    newMasterDir = tempfile.mkdtemp()
+    fNames = [r["name"] for r in context.table]
+
+    logDir = os.path.join(newMasterDir, 'pg_log')
+    os.mkdir(logDir)
+    for name in fNames:
+        open(os.path.join(logDir, name), 'a').close()
+
+    context.newMasterDir = newMasterDir
+
+@when('under changed DATA_DIR user runs "{command}"')
+def impl(context, command):
+    run_gpcommand(context, command, "MASTER_DATA_DIRECTORY=%s" % context.newMasterDir)
+
+@then("gplogiflter shouldn't skip next files from directory (files ordered by time stamp and by name)")
+def impl(context):
+    processed = parse_processed_files(context.error_message)
+    expected = [row["name"] for row in context.table]
+
+    if len(processed) != len(expected):
+        raise Exception('got:\n%s\ndiffers with expected:\n%s'
+                        % (yaml.dump(processed), yaml.dump(expected)))
+
+    for i in range(0, len(processed)):
+        if processed[i] != context.table[i]["name"]:
+            raise Exception('got:\n%s\ndiffers with expected:\n%s'
+                            % (yaml.dump(processed), yaml.dump(expected)))

From 725622788f4704311c265d38e162baa3e5254c26 Mon Sep 17 00:00:00 2001
From: Evgeniy Ratkov <e.ratkov@arenadata.io>
Date: Sun, 1 Oct 2023 20:49:21 +0300
Subject: [PATCH 03/22] arenadata_tookit: replace using pg_partitions(#629)

There was getting data from pg_partitions at function 'adb_collect_table_stats'.
'pg_partitions' generates from a lot of joins ('pg_class', 'pg_namespace',
'pg_partition_rule' and etc). It takes a lot of time and resources (query plan
of getting all data from 'pg_partitions' contains ~60 rows).

'pg_partitions' was replaces to some joins, which are need for
'adb_collect_table_stats'. Query plans have halved than query with 'pg_partitions'.

New test 'adb_collect_table_stat_test' was added. It checks, that function
'adb_collect_table_stats' generates new partitions for 'db_files_history' correctly.
---
 gpcontrib/arenadata_toolkit/Makefile          |   8 +-
 .../arenadata_toolkit--1.1--1.2.sql           | 124 +++++++
 .../arenadata_toolkit.control                 |   2 +-
 .../expected/adb_collect_table_stats_test.out | 319 ++++++++++++++++++
 .../sql/adb_collect_table_stats_test.sql      |  92 +++++
 5 files changed, 541 insertions(+), 4 deletions(-)
 create mode 100644 gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
 create mode 100644 gpcontrib/arenadata_toolkit/expected/adb_collect_table_stats_test.out
 create mode 100644 gpcontrib/arenadata_toolkit/sql/adb_collect_table_stats_test.sql

diff --git a/gpcontrib/arenadata_toolkit/Makefile b/gpcontrib/arenadata_toolkit/Makefile
index a1f9857ba355..97a38ebfdcc2 100644
--- a/gpcontrib/arenadata_toolkit/Makefile
+++ b/gpcontrib/arenadata_toolkit/Makefile
@@ -3,17 +3,19 @@
 MODULES = arenadata_toolkit
 
 EXTENSION = arenadata_toolkit
-EXTENSION_VERSION = 1.1
+EXTENSION_VERSION = 1.2
 DATA = \
        arenadata_toolkit--1.0.sql \
-       arenadata_toolkit--1.0--1.1.sql
+       arenadata_toolkit--1.0--1.1.sql \
+       arenadata_toolkit--1.1--1.2.sql
 
 DATA_built = $(EXTENSION)--$(EXTENSION_VERSION).sql
 
 $(DATA_built): $(DATA)
 	cat $(DATA) > $(DATA_built)
 
-REGRESS = arenadata_toolkit_test arenadata_toolkit_skew_test adb_get_relfilenodes_test
+REGRESS = arenadata_toolkit_test arenadata_toolkit_skew_test adb_get_relfilenodes_test \
+          adb_collect_table_stats_test
 REGRESS_OPTS += --init-file=$(top_srcdir)/src/test/regress/init_file
 
 ifdef USE_PGXS
diff --git a/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
new file mode 100644
index 000000000000..211d51047699
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
@@ -0,0 +1,124 @@
+/* gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql */
+
+/*
+ This is part of arenadata_toolkit API for ADB Bundle.
+ This function collects information in db_files_current and db_files_history tables.
+ */
+CREATE OR REPLACE FUNCTION arenadata_toolkit.adb_collect_table_stats()
+RETURNS VOID
+AS $$
+BEGIN
+	IF NOT EXISTS (
+		SELECT 1
+		FROM pg_partition pp
+		JOIN pg_class cl1 ON pp.parrelid = cl1.oid
+		JOIN pg_partition_rule pr ON pr.paroid = pp.oid
+		JOIN pg_class cl2 ON cl2.oid = pr.parchildrelid
+		JOIN pg_namespace n1 ON cl1.relnamespace = n1.oid
+		JOIN pg_namespace n2 ON cl2.relnamespace = n2.oid
+		WHERE
+			pp.paristemplate = false
+			AND
+			n1.nspname = 'arenadata_toolkit'
+			AND
+			n2.nspname = 'arenadata_toolkit'
+			AND
+			cl1.relname = 'db_files_history'
+			AND
+			now() BETWEEN CAST(
+				substring(pg_get_expr(pr.parrangestart, pr.parchildrelid) FROM '#"%#"::%' FOR '#')
+				AS TIMESTAMP WITHOUT TIME ZONE)
+			AND
+			CAST(substring(pg_get_expr(pr.parrangeend, pr.parchildrelid) FROM '#"%#"::%' FOR '#')
+				AS TIMESTAMP WITHOUT TIME ZONE)
+			AND
+			pp.parkind = 'r'  --range
+			AND
+			pr.parrangestartincl = 't')
+	THEN
+		EXECUTE FORMAT($fmt$ALTER TABLE arenadata_toolkit.db_files_history SPLIT DEFAULT PARTITION
+			START (date %1$L) INCLUSIVE
+			END (date %2$L) EXCLUSIVE
+			INTO (PARTITION %3$I, default partition);$fmt$,
+				to_char(now(), 'YYYY-MM-01'),
+				to_char(now() + interval '1 month','YYYY-MM-01'),
+				'p'||to_char(now(), 'YYYYMM'));
+	END IF;
+
+	CREATE TEMPORARY TABLE IF NOT EXISTS db_files_current
+	(
+		oid BIGINT,
+		table_name TEXT,
+		table_schema TEXT,
+		type CHAR(1),
+		storage CHAR(1),
+		table_parent_table TEXT,
+		table_parent_schema TEXT,
+		table_database TEXT,
+		table_tablespace TEXT,
+		"content" INTEGER,
+		segment_preferred_role CHAR(1),
+		hostname TEXT,
+		address TEXT,
+		file TEXT,
+		modifiedtime TIMESTAMP WITHOUT TIME ZONE,
+		file_size BIGINT
+	)
+	DISTRIBUTED RANDOMLY;
+
+	/*
+		Since this table is temporary and user can call this several times in a session
+		then we need to truncate it (an alternative will be to drop it).
+	 */
+	TRUNCATE TABLE db_files_current;
+
+	/* We use temporary table in this case, because we don't want to add own own unmapped
+	   relfilenode oids in a db_files_current and db_files_history tables. The downside of
+	   this approach that if time between calls to adb_collect_table_stats will be less
+	   then checkpointing interval (there will be no unlink peformed), than these unmapped
+	   files will still go to db_files_current and db_files_history as unmapped.
+	*/
+	INSERT INTO db_files_current
+	SELECT
+		f.oid,
+		f.table_name,
+		f.table_schema,
+		f.type,
+		f.storage,
+		cl.relname AS table_parent_table,
+		n.nspname AS table_parent_schema,
+		f.table_database,
+		f.table_tablespace,
+		f."content",
+		f.segment_preferred_role,
+		f.hostname,
+		f.address,
+		f.file,
+		CURRENT_TIMESTAMP AS modifiedtime,
+		f.file_size
+	FROM arenadata_toolkit.__db_files_current AS f
+	LEFT JOIN pg_partition_rule pr ON pr.parchildrelid = f.oid
+	LEFT JOIN pg_partition pp ON pr.paroid = pp.oid
+	LEFT JOIN pg_class cl ON cl.oid = pp.parrelid
+	LEFT JOIN pg_namespace n ON cl.relnamespace = n.oid;
+
+	/*
+	 Here we may truncate it, it's relfilenodes aren't in db_files_current temporary table.
+	 */
+	TRUNCATE TABLE arenadata_toolkit.db_files_current;
+
+	INSERT INTO arenadata_toolkit.db_files_current
+	SELECT *
+	FROM db_files_current;
+
+	INSERT INTO arenadata_toolkit.db_files_history
+	SELECT *, now() AS collecttime
+	FROM arenadata_toolkit.db_files_current;
+END$$
+LANGUAGE plpgsql VOLATILE
+EXECUTE ON MASTER;
+
+/*
+	Only for admin usage.
+ */
+REVOKE ALL ON FUNCTION arenadata_toolkit.adb_collect_table_stats() FROM public;
diff --git a/gpcontrib/arenadata_toolkit/arenadata_toolkit.control b/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
index f65a243a3abd..69986410bab2 100644
--- a/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
+++ b/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
@@ -1,5 +1,5 @@
 # arenadata_toolkit extension
 comment = 'extension is used for manipulation of objects created by adb-bundle'
-default_version = '1.1'
+default_version = '1.2'
 module_pathname = '$libdir/arenadata_toolkit'
 relocatable = false
diff --git a/gpcontrib/arenadata_toolkit/expected/adb_collect_table_stats_test.out b/gpcontrib/arenadata_toolkit/expected/adb_collect_table_stats_test.out
new file mode 100644
index 000000000000..c2085ebb4e4c
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/expected/adb_collect_table_stats_test.out
@@ -0,0 +1,319 @@
+CREATE EXTENSION arenadata_toolkit;
+SET search_path = arenadata_toolkit;
+-- Need to disable notice messages from plpgsql functions
+SET client_min_messages=WARNING;
+CREATE FUNCTION remove_partition_from_db_files_history()
+RETURNS VOID
+AS $$
+BEGIN
+	EXECUTE FORMAT($fmt$ALTER TABLE db_files_history DROP PARTITION %1$I$fmt$,
+				'p'||to_char(now(), 'YYYYMM'));
+END$$
+LANGUAGE plpgsql VOLATILE
+EXECUTE ON MASTER;
+-- There are not "db_files_history" and partitions
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+ count 
+-------
+     0
+(1 row)
+
+SELECT adb_create_tables();
+ adb_create_tables 
+-------------------
+ 
+(1 row)
+
+-- There are "db_files_history" and two partitions (default and for current month)
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+ count 
+-------
+     2
+(1 row)
+
+-- Remove partition from "db_files_history" for current month
+SELECT remove_partition_from_db_files_history();
+ remove_partition_from_db_files_history 
+----------------------------------------
+ 
+(1 row)
+
+-- There is only default partition for "db_files_history"
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+ count 
+-------
+     1
+(1 row)
+
+SELECT adb_collect_table_stats();
+ adb_collect_table_stats 
+-------------------------
+ 
+(1 row)
+
+-- There are "db_files_history" and two partitions (default and for current month)
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+ count 
+-------
+     2
+(1 row)
+
+SELECT adb_collect_table_stats();
+ adb_collect_table_stats 
+-------------------------
+ 
+(1 row)
+
+-- There is not any new partitions for "db_files_history"
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+ count 
+-------
+     2
+(1 row)
+
+-- Create table with partitions for test "INSERT INTO arenadata_toolkit.db_files_current"
+CREATE TABLE part_table (id INT, a INT, b INT, c INT, d INT, str TEXT)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (a)
+	SUBPARTITION BY RANGE (b)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (c)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (d)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY LIST (str)
+		SUBPARTITION TEMPLATE (
+			SUBPARTITION sub_prt1 VALUES ('sub_prt1'),
+			SUBPARTITION sub_prt2 VALUES ('sub_prt2'))
+	(START (1) END (3) EVERY (1));
+-- add small data to all parts of table
+INSERT INTO part_table
+	SELECT i+1, mod(i/16,2)+1, mod(i/8,2)+1, mod(i/4,2)+1, mod(i/2,2)+1, 'sub_prt' || mod(i,2)+1
+	FROM generate_series(0,399) as i;
+-- add a lot of data for one part
+-- distributing by first columnt is helps to us to put all data to one segment
+INSERT INTO part_table SELECT 1,1,1,1,1,'sub_prt1' FROM generate_series(1,10000) AS i;
+-- update arenadata_toolkit.db_files_current
+select arenadata_toolkit.adb_collect_table_stats();
+ adb_collect_table_stats 
+-------------------------
+ 
+(1 row)
+
+select table_name, table_schema, table_parent_table, table_parent_schema, file_size
+FROM arenadata_toolkit.db_files_current
+where table_name LIKE 'part_table%'
+ORDER BY oid;
+                        table_name                         |   table_schema    | table_parent_table | table_parent_schema | file_size 
+-----------------------------------------------------------+-------------------+--------------------+---------------------+-----------
+ part_table                                                | arenadata_toolkit |                    |                     |         0
+ part_table                                                | arenadata_toolkit |                    |                     |         0
+ part_table                                                | arenadata_toolkit |                    |                     |         0
+ part_table_1_prt_1                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |    622592
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     98304
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_1_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2                                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_1_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2                                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_1_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2                        | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_1_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2                | arenadata_toolkit | part_table         | arenadata_toolkit   |         0
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt1 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+ part_table_1_prt_2_2_prt_2_3_prt_2_4_prt_2_5_prt_sub_prt2 | arenadata_toolkit | part_table         | arenadata_toolkit   |     32768
+(190 rows)
+
+-- Cleanup
+DROP TABLE part_table;
+DROP FUNCTION remove_partition_from_db_files_history();
+DROP EXTENSION arenadata_toolkit;
diff --git a/gpcontrib/arenadata_toolkit/sql/adb_collect_table_stats_test.sql b/gpcontrib/arenadata_toolkit/sql/adb_collect_table_stats_test.sql
new file mode 100644
index 000000000000..2901deeaf487
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/sql/adb_collect_table_stats_test.sql
@@ -0,0 +1,92 @@
+CREATE EXTENSION arenadata_toolkit;
+SET search_path = arenadata_toolkit;
+
+-- Need to disable notice messages from plpgsql functions
+SET client_min_messages=WARNING;
+
+CREATE FUNCTION remove_partition_from_db_files_history()
+RETURNS VOID
+AS $$
+BEGIN
+	EXECUTE FORMAT($fmt$ALTER TABLE db_files_history DROP PARTITION %1$I$fmt$,
+				'p'||to_char(now(), 'YYYYMM'));
+END$$
+LANGUAGE plpgsql VOLATILE
+EXECUTE ON MASTER;
+
+-- There are not "db_files_history" and partitions
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+
+SELECT adb_create_tables();
+
+-- There are "db_files_history" and two partitions (default and for current month)
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+
+-- Remove partition from "db_files_history" for current month
+SELECT remove_partition_from_db_files_history();
+
+-- There is only default partition for "db_files_history"
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+
+SELECT adb_collect_table_stats();
+
+-- There are "db_files_history" and two partitions (default and for current month)
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+
+SELECT adb_collect_table_stats();
+
+-- There is not any new partitions for "db_files_history"
+SELECT count(inhrelid)
+FROM pg_inherits
+LEFT JOIN pg_class ON oid = inhparent
+WHERE relname = 'db_files_history';
+
+-- Create table with partitions for test "INSERT INTO arenadata_toolkit.db_files_current"
+CREATE TABLE part_table (id INT, a INT, b INT, c INT, d INT, str TEXT)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (a)
+	SUBPARTITION BY RANGE (b)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (c)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (d)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY LIST (str)
+		SUBPARTITION TEMPLATE (
+			SUBPARTITION sub_prt1 VALUES ('sub_prt1'),
+			SUBPARTITION sub_prt2 VALUES ('sub_prt2'))
+	(START (1) END (3) EVERY (1));
+
+-- add small data to all parts of table
+INSERT INTO part_table
+	SELECT i+1, mod(i/16,2)+1, mod(i/8,2)+1, mod(i/4,2)+1, mod(i/2,2)+1, 'sub_prt' || mod(i,2)+1
+	FROM generate_series(0,399) as i;
+
+-- add a lot of data for one part
+-- distributing by first columnt is helps to us to put all data to one segment
+INSERT INTO part_table SELECT 1,1,1,1,1,'sub_prt1' FROM generate_series(1,10000) AS i;
+
+-- update arenadata_toolkit.db_files_current
+select arenadata_toolkit.adb_collect_table_stats();
+
+select table_name, table_schema, table_parent_table, table_parent_schema, file_size
+FROM arenadata_toolkit.db_files_current
+where table_name LIKE 'part_table%'
+ORDER BY oid;
+
+-- Cleanup
+DROP TABLE part_table;
+DROP FUNCTION remove_partition_from_db_files_history();
+DROP EXTENSION arenadata_toolkit;

From 6b28182122cc4cf8c26a4d857a9ea8b711d6463c Mon Sep 17 00:00:00 2001
From: Evgeniy Ratkov <e.ratkov@arenadata.io>
Date: Tue, 17 Oct 2023 12:16:16 +0300
Subject: [PATCH 04/22] arenadata_tooklit: change temp db_files_current to
 pg_temp.db_files_current (#629)

At "adb_collect_table_stats" temporary table "db_files_current" is used for collecting
data from view "arenadata_toolkit.__db_files_current". Schema "arenadata_toolkit" contains
not temporary table "db_files_current". If schema "arenadata_toolkit" is set by default
it may be get collison at table names.

Temporary table "db_files_current" was renamed to "pg_temp.db_files_current".
---
 .../arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql     | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
index 211d51047699..7e5f03f36c5d 100644
--- a/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
+++ b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.1--1.2.sql
@@ -45,7 +45,7 @@ BEGIN
 				'p'||to_char(now(), 'YYYYMM'));
 	END IF;
 
-	CREATE TEMPORARY TABLE IF NOT EXISTS db_files_current
+	CREATE TEMPORARY TABLE IF NOT EXISTS pg_temp.db_files_current
 	(
 		oid BIGINT,
 		table_name TEXT,
@@ -70,7 +70,7 @@ BEGIN
 		Since this table is temporary and user can call this several times in a session
 		then we need to truncate it (an alternative will be to drop it).
 	 */
-	TRUNCATE TABLE db_files_current;
+	TRUNCATE TABLE pg_temp.db_files_current;
 
 	/* We use temporary table in this case, because we don't want to add own own unmapped
 	   relfilenode oids in a db_files_current and db_files_history tables. The downside of
@@ -78,7 +78,7 @@ BEGIN
 	   then checkpointing interval (there will be no unlink peformed), than these unmapped
 	   files will still go to db_files_current and db_files_history as unmapped.
 	*/
-	INSERT INTO db_files_current
+	INSERT INTO pg_temp.db_files_current
 	SELECT
 		f.oid,
 		f.table_name,
@@ -109,7 +109,7 @@ BEGIN
 
 	INSERT INTO arenadata_toolkit.db_files_current
 	SELECT *
-	FROM db_files_current;
+	FROM pg_temp.db_files_current;
 
 	INSERT INTO arenadata_toolkit.db_files_history
 	SELECT *, now() AS collecttime

From 742bf6f9389dce4c449fc9bcb26b06698116d84b Mon Sep 17 00:00:00 2001
From: Viktor Kurilko <murlockkinght@gmail.com>
Date: Mon, 30 Oct 2023 22:37:07 +0300
Subject: [PATCH 05/22] Fix inconsistency between the format of queries_now.dat
 and the queries_now_fast external table (#636)

gpperfmon writes a string to queries_now.dat in the expectation that it will be
processed by gpmon_catqrynow.py, but the queries_now_fast external table reads
from the file directly. This leads to an error, because queries_now.dat contains
the query_hash column that is not declared in the queries_now_fast table. Also
queries_now.dat contains empty columns at the end that should be filled by
python script. These columns are not declared in the table too.

This patch fixes this issue by removing extra columns from queries_now.dat and
adding them directly in the python script and in the write_qlog_full (write into
queries_tail.dat) function.

Co-authored-by: Andrey Sokolov <a.sokolov@arenadata.io>
---
 gpAux/gpperfmon/src/gpmon/gpmon_agg.c             | 14 +++++++-------
 gpAux/gpperfmon/src/gpmon/gpmon_catqrynow.py      |  6 +++++-
 gpMgmt/test/behave/mgmt_utils/gpperfmon.feature   |  7 +++++++
 gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py |  5 +++++
 4 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/gpAux/gpperfmon/src/gpmon/gpmon_agg.c b/gpAux/gpperfmon/src/gpmon/gpmon_agg.c
index 5264755f7558..914707aaed49 100644
--- a/gpAux/gpperfmon/src/gpmon/gpmon_agg.c
+++ b/gpAux/gpperfmon/src/gpmon/gpmon_agg.c
@@ -1304,7 +1304,6 @@ static void fmt_qlog(char* line, const int line_size, qdnode_t* qdnode, const ch
 	char timfinished[GPMON_DATE_BUF_SIZE];
 	double cpu_skew = 0.0f;
 	double row_skew = 0.0f;
-	int query_hash = 0;
 	apr_int64_t rowsout = 0;
 	float cpu_current;
 	cpu_skew = get_cpu_skew(qdnode);
@@ -1340,7 +1339,7 @@ static void fmt_qlog(char* line, const int line_size, qdnode_t* qdnode, const ch
 		snprintf(timfinished, GPMON_DATE_BUF_SIZE,  "null");
 	}
 
-	snprintf(line, line_size, "%s|%d|%d|%d|%s|%s|%d|%s|%s|%s|%s|%" FMT64 "|%" FMT64 "|%.4f|%.2f|%.2f|%d",
+	snprintf(line, line_size, "%s|%d|%d|%d|%s|%s|%d|%s|%s|%s|%s|%" FMT64 "|%" FMT64 "|%.4f|%.2f|%.2f",
 		nowstr,
 		qdnode->qlog.key.tmid,
 		qdnode->qlog.key.ssid,
@@ -1356,8 +1355,7 @@ static void fmt_qlog(char* line, const int line_size, qdnode_t* qdnode, const ch
 		qdnode->qlog.cpu_elapsed,
 		cpu_current,
 		cpu_skew,
-		row_skew,
-		query_hash);
+		row_skew);
 }
 
 
@@ -1377,8 +1375,8 @@ static apr_uint32_t write_qlog(FILE* fp, qdnode_t *qdnode, const char* nowstr, a
 	}
 	else
 	{
-		/* Query text "joined" by python script */
-		fprintf(fp, "%s|||||\n", line);
+		fputs(line, fp);
+		fputc('\n', fp);
 		return bytes_written;
 	}
 }
@@ -1476,7 +1474,9 @@ static apr_uint32_t write_qlog_full(FILE* fp, qdnode_t *qdnode, const char* nows
 		return 0;
 	}
 
-	fprintf(fp, "%s", line);
+	/* The query hash column is always 0 */
+	fprintf(fp, "%s|0", line);
+	bytes_written += 2;
 
 	snprintf(qfname, qfname_size, GPMON_DIR "q%d-%d-%d.txt", qdnode->qlog.key.tmid,
             qdnode->qlog.key.ssid, qdnode->qlog.key.ccnt);
diff --git a/gpAux/gpperfmon/src/gpmon/gpmon_catqrynow.py b/gpAux/gpperfmon/src/gpmon/gpmon_catqrynow.py
index 676889b8e790..dc6f73da684a 100644
--- a/gpAux/gpperfmon/src/gpmon/gpmon_catqrynow.py
+++ b/gpAux/gpperfmon/src/gpmon/gpmon_catqrynow.py
@@ -9,7 +9,11 @@
 #	print the line
 
 for line in open(os.path.join(GPMONDIR, "queries_now.dat")):
-    line = line.split('|')
+    line = line.strip().split('|')
+    line.append('0') # query hash
+    # allocate space for qrytxt, query plan, appname, rsqname and priority
+    line.extend(['']*5)
+
     (tmid, xid, cid) = line[1:4]
     qrytxt = ''
     appname = ''
diff --git a/gpMgmt/test/behave/mgmt_utils/gpperfmon.feature b/gpMgmt/test/behave/mgmt_utils/gpperfmon.feature
index 7c6768799bab..cca923a31742 100644
--- a/gpMgmt/test/behave/mgmt_utils/gpperfmon.feature
+++ b/gpMgmt/test/behave/mgmt_utils/gpperfmon.feature
@@ -29,6 +29,13 @@ Feature: gpperfmon
         Given the database "gpperfmon" does not exist
         Then gpperfmon is configured and running in qamode
 
+    @gpperfmon_query_now
+    Scenario: get info about current queries
+        Given gpperfmon is configured and running in qamode
+        Then run query for 20 seconds
+        And wait until the results from boolean sql "select count(*) > 0 from queries_now" is "true"
+        And wait until the results from boolean sql "select count(*) > 0 from queries_now_fast" is "true"
+
     @gpperfmon_database_history
     Scenario: gpperfmon adds to database_history table
         Given gpperfmon is configured and running in qamode
diff --git a/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py b/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
index 12ae3912ce8c..f4d70f534702 100644
--- a/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
+++ b/gpMgmt/test/behave/mgmt_utils/steps/mgmt_utils.py
@@ -4299,3 +4299,8 @@ def impl(context):
 		os.environ['LC_ALL'] = default_locale
 	else:
 		del os.environ['LC_ALL']
+
+@then('run query for {second} seconds')
+def impl(context, second):
+	cmd = Command(name='psql', cmdStr="-c 'SELECT * from generate_series(1, %s) a where pg_sleep(1) is not null;'" % second)
+	cmd.runNoWait()

From 03e575eae83ed8c8b93dee7b2966a1a4118c5bca Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 31 Jan 2017 18:42:24 -0300
Subject: [PATCH 06/22] Tweak catalog indexing abstraction for upcoming WARM

Split the existing CatalogUpdateIndexes into two different routines,
CatalogTupleInsert and CatalogTupleUpdate, which do both the heap
insert/update plus the index update.  This removes over 300 lines of
boilerplate code all over src/backend/catalog/ and src/backend/commands.
The resulting code is much more pleasing to the eye.

Also, by encapsulating what happens in detail during an UPDATE, this
facilitates the upcoming WARM patch, which is going to add a few more
lines to the update case making the boilerplate even more boring.

The original CatalogUpdateIndexes is removed; there was only one use
left, and since it's just three lines, we can as well expand it in place
there.  We could keep it, but WARM is going to break all the UPDATE
out-of-core callsites anyway, so there seems to be no benefit in doing
so.

This is backport of 2f5c9d9
CatalogTupleInsertFrozen is taken from 19cd1cf
This patch replaces simple_heap_insert and CatalogUpdateIndexes to CatalogTupleInsert,
and simple_heap_update and CatalogUpdateIndexes to CatalogTupleUpdate

Author: Pavan Deolasee
Discussion: https://www.postgr.es/m/CABOikdOcFYSZ4vA2gYfs=M2cdXzXX4qGHeEiW3fu9PCfkHLa2A@mail.gmail.com
---
 src/backend/access/aocs/aocssegfiles.c        |   3 +-
 .../appendonly/appendonly_visimap_store.c     |   6 +-
 .../appendonly/appendonlyblockdirectory.c     |   6 +-
 src/backend/catalog/aclchk.c                  |  77 ++--------
 src/backend/catalog/gp_fastsequence.c         |   9 +-
 src/backend/catalog/heap.c                    |  44 ++----
 src/backend/catalog/index.c                   |  14 +-
 src/backend/catalog/indexing.c                |  62 +++++++-
 src/backend/catalog/pg_aggregate.c            |   4 +-
 src/backend/catalog/pg_appendonly.c           |  15 +-
 src/backend/catalog/pg_attribute_encoding.c   |   3 +-
 src/backend/catalog/pg_collation.c            |   5 +-
 src/backend/catalog/pg_constraint.c           |  23 +--
 src/backend/catalog/pg_conversion.c           |   5 +-
 src/backend/catalog/pg_db_role_setting.c      |  15 +-
 src/backend/catalog/pg_depend.c               |   3 +-
 src/backend/catalog/pg_enum.c                 |  10 +-
 src/backend/catalog/pg_extprotocol.c          |   4 +-
 src/backend/catalog/pg_exttable.c             |   4 +-
 src/backend/catalog/pg_inherits.c             |   3 +-
 src/backend/catalog/pg_largeobject.c          |   4 +-
 src/backend/catalog/pg_namespace.c            |   4 +-
 src/backend/catalog/pg_operator.c             |  23 +--
 src/backend/catalog/pg_proc.c                 |   6 +-
 src/backend/catalog/pg_proc_callback.c        |   3 +-
 src/backend/catalog/pg_range.c                |   3 +-
 src/backend/catalog/pg_shdepend.c             |  20 +--
 src/backend/catalog/pg_type.c                 |  23 +--
 src/backend/catalog/toasting.c                |   5 +-
 src/backend/cdb/cdbcat.c                      |   9 +-
 src/backend/cdb/cdbpartition.c                |  21 +--
 src/backend/commands/alter.c                  |   9 +-
 src/backend/commands/analyze.c                |   7 +-
 src/backend/commands/cluster.c                |  16 +-
 src/backend/commands/comment.c                |  16 +-
 src/backend/commands/dbcommands.c             |  21 +--
 src/backend/commands/event_trigger.c          |   9 +-
 src/backend/commands/extension.c              |  15 +-
 src/backend/commands/foreigncmds.c            |  29 ++--
 src/backend/commands/functioncmds.c           |  15 +-
 src/backend/commands/indexcmds.c              |   6 +-
 src/backend/commands/matview.c                |   4 +-
 src/backend/commands/opclasscmds.c            |  16 +-
 src/backend/commands/proclang.c               |   7 +-
 src/backend/commands/queue.c                  |  12 +-
 src/backend/commands/resgroupcmds.c           |   9 +-
 src/backend/commands/schemacmds.c             |   6 +-
 src/backend/commands/seclabel.c               |  15 +-
 src/backend/commands/tablecmds.c              | 144 +++++-------------
 src/backend/commands/tablespace.c             |  10 +-
 src/backend/commands/trigger.c                |  18 +--
 src/backend/commands/tsearchcmds.c            |  31 +---
 src/backend/commands/typecmds.c               |  21 +--
 src/backend/commands/user.c                   |  24 +--
 src/backend/fts/fts.c                         |   6 +-
 src/backend/rewrite/rewriteDefine.c           |  19 +--
 src/backend/rewrite/rewriteSupport.c          |   5 +-
 src/backend/storage/large_object/inv_api.c    |  12 +-
 src/backend/utils/cache/relcache.c            |   3 +-
 src/backend/utils/cache/syscache.c            |   6 +-
 src/backend/utils/gp/segadmin.c               |   6 +-
 src/include/catalog/indexing.h                |   5 +-
 62 files changed, 307 insertions(+), 651 deletions(-)

diff --git a/src/backend/access/aocs/aocssegfiles.c b/src/backend/access/aocs/aocssegfiles.c
index fdb092972fa1..9aba722eaf36 100644
--- a/src/backend/access/aocs/aocssegfiles.c
+++ b/src/backend/access/aocs/aocssegfiles.c
@@ -115,8 +115,7 @@ InsertInitialAOCSFileSegInfo(Relation prel, int32 segno, int32 nvp)
 
 	segtup = heap_form_tuple(RelationGetDescr(segrel), values, nulls);
 
-	simple_heap_insert(segrel, segtup);
-	CatalogUpdateIndexes(segrel, segtup);
+	CatalogTupleInsert(segrel, segtup);
 
 	heap_freetuple(segtup);
 	heap_close(segrel, RowExclusiveLock);
diff --git a/src/backend/access/appendonly/appendonly_visimap_store.c b/src/backend/access/appendonly/appendonly_visimap_store.c
index 2ead54be8fe8..e2027f653d03 100644
--- a/src/backend/access/appendonly/appendonly_visimap_store.c
+++ b/src/backend/access/appendonly/appendonly_visimap_store.c
@@ -149,15 +149,13 @@ AppendOnlyVisimapStore_Store(
 	 */
 	if (ItemPointerIsValid(&visiMapEntry->tupleTid))
 	{
-		simple_heap_update(visimapRelation, &visiMapEntry->tupleTid, tuple);
+		CatalogTupleUpdate(visimapRelation, &visiMapEntry->tupleTid, tuple);
 	}
 	else
 	{
-		simple_heap_insert(visimapRelation, tuple);
+		CatalogTupleInsert(visimapRelation, tuple);
 	}
 
-	CatalogUpdateIndexes(visimapRelation, tuple);
-
 	heap_freetuple(tuple);
 
 	MemoryContextSwitchTo(oldContext);
diff --git a/src/backend/access/appendonly/appendonlyblockdirectory.c b/src/backend/access/appendonly/appendonlyblockdirectory.c
index b0f7ddb138d9..48f7961424ac 100644
--- a/src/backend/access/appendonly/appendonlyblockdirectory.c
+++ b/src/backend/access/appendonly/appendonlyblockdirectory.c
@@ -1194,7 +1194,7 @@ write_minipage(AppendOnlyBlockDirectory *blockDirectory,
 						  columnGroupNo, minipageInfo->numMinipageEntries,
 						  minipageInfo->minipage->entry[0].firstRowNum)));
 
-		simple_heap_update(blkdirRel, &minipageInfo->tupleTid, tuple);
+		CatalogTupleUpdate(blkdirRel, &minipageInfo->tupleTid, tuple);
 	}
 	else
 	{
@@ -1206,11 +1206,9 @@ write_minipage(AppendOnlyBlockDirectory *blockDirectory,
 						  columnGroupNo, minipageInfo->numMinipageEntries,
 						  minipageInfo->minipage->entry[0].firstRowNum)));
 
-		simple_heap_insert(blkdirRel, tuple);
+		CatalogTupleInsert(blkdirRel, tuple);
 	}
 
-	CatalogUpdateIndexes(blkdirRel, tuple);
-
 	heap_freetuple(tuple);
 
 	MemoryContextSwitchTo(oldcxt);
diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c
index bd9a1086eb32..f322630269cd 100644
--- a/src/backend/catalog/aclchk.c
+++ b/src/backend/catalog/aclchk.c
@@ -1406,7 +1406,7 @@ SetDefaultACL(InternalDefaultACL *iacls)
 			values[Anum_pg_default_acl_defaclacl - 1] = PointerGetDatum(new_acl);
 
 			newtuple = heap_form_tuple(RelationGetDescr(rel), values, nulls);
-			simple_heap_insert(rel, newtuple);
+			CatalogTupleInsert(rel, newtuple);
 		}
 		else
 		{
@@ -1416,12 +1416,9 @@ SetDefaultACL(InternalDefaultACL *iacls)
 
 			newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
 										 values, nulls, replaces);
-			simple_heap_update(rel, &newtuple->t_self, newtuple);
+			CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 		}
 
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(rel, newtuple);
-
 		/* these dependencies don't change in an update */
 		if (isNew)
 		{
@@ -1851,10 +1848,7 @@ ExecGrant_Attribute(InternalGrant *istmt, Oid relOid, const char *relname,
 		newtuple = heap_modify_tuple(attr_tuple, RelationGetDescr(attRelation),
 									 values, nulls, replaces);
 
-		simple_heap_update(attRelation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(attRelation, newtuple);
+		CatalogTupleUpdate(attRelation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(RelationRelationId, relOid, attnum,
@@ -2112,10 +2106,7 @@ ExecGrant_Relation(InternalGrant *istmt)
 			newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation),
 										 values, nulls, replaces);
 
-			simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-			/* keep the catalog indexes up to date */
-			CatalogUpdateIndexes(relation, newtuple);
+			CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 			/* Update the shared dependency ACL info */
 			updateAclDependencies(RelationRelationId, relOid, 0,
@@ -2302,10 +2293,7 @@ CopyRelationAcls(Oid srcId, Oid destId)
 	newTuple = heap_modify_tuple(destTuple, RelationGetDescr(pg_class_rel),
 								 values, nulls, replaces);
 
-	simple_heap_update(pg_class_rel, &newTuple->t_self, newTuple);
-
-	/* keep the catalog indexes up to date */
-	CatalogUpdateIndexes(pg_class_rel, newTuple);
+	CatalogTupleUpdate(pg_class_rel, &newTuple->t_self, newTuple);
 
 	/* Update the shared dependency ACL info */
 	ownerId = pg_class_tuple->relowner;
@@ -2361,10 +2349,7 @@ CopyRelationAcls(Oid srcId, Oid destId)
 		newTuple = heap_modify_tuple(attDestTuple, RelationGetDescr(pg_attribute_rel),
 									 values, nulls, replaces);
 
-		simple_heap_update(pg_attribute_rel, &newTuple->t_self, newTuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(pg_attribute_rel, newTuple);
+		CatalogTupleUpdate(pg_attribute_rel, &newTuple->t_self, newTuple);
 
 		/* Update the shared dependency ACL info */
 		ownerId = pg_class_tuple->relowner;
@@ -2486,10 +2471,7 @@ ExecGrant_Database(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* MPP-6929: metadata tracking */
 		if (Gp_role == GP_ROLE_DISPATCH)
@@ -2620,10 +2602,7 @@ ExecGrant_Fdw(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(ForeignDataWrapperRelationId,
@@ -2745,10 +2724,7 @@ ExecGrant_ForeignServer(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(ForeignServerRelationId,
@@ -2869,10 +2845,7 @@ ExecGrant_Function(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(ProcedureRelationId, funcId, 0,
@@ -2999,10 +2972,7 @@ ExecGrant_Language(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(LanguageRelationId, HeapTupleGetOid(tuple), 0,
@@ -3138,10 +3108,7 @@ ExecGrant_Largeobject(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation),
 									 values, nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(LargeObjectRelationId,
@@ -3263,10 +3230,7 @@ ExecGrant_Namespace(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* MPP-6929: metadata tracking */
 		if (Gp_role == GP_ROLE_DISPATCH)
@@ -3396,10 +3360,7 @@ ExecGrant_Tablespace(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* MPP-6929: metadata tracking */
 		if (Gp_role == GP_ROLE_DISPATCH)
@@ -3542,10 +3503,7 @@ ExecGrant_Type(InternalGrant *istmt)
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
 									 nulls, replaces);
 
-		simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relation, newtuple);
+		CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
 		/* Update the shared dependency ACL info */
 		updateAclDependencies(TypeRelationId, typId, 0,
@@ -3710,10 +3668,7 @@ ExecGrant_ExtProtocol(InternalGrant *istmt)
         newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
                                      nulls, replaces);
 
-        simple_heap_update(relation, &newtuple->t_self, newtuple);
-
-        /* keep the catalog indexes up to date */
-        CatalogUpdateIndexes(relation, newtuple);
+        CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
         /* Update the shared dependency ACL info */
         updateAclDependencies(ExtprotocolRelationId,
diff --git a/src/backend/catalog/gp_fastsequence.c b/src/backend/catalog/gp_fastsequence.c
index 456b953438d1..c029b35e6ee2 100644
--- a/src/backend/catalog/gp_fastsequence.c
+++ b/src/backend/catalog/gp_fastsequence.c
@@ -77,15 +77,13 @@ InsertInitialFastSequenceEntries(Oid objid)
 	/* Insert enrty for segfile 0 */
 	values[Anum_gp_fastsequence_objmod - 1] = Int64GetDatum(RESERVED_SEGNO);
 	tuple = heaptuple_form_to(tupleDesc, values, nulls, NULL, NULL);
-	simple_heap_insert(gp_fastsequence_rel, tuple);
-	CatalogUpdateIndexes(gp_fastsequence_rel, tuple);
+	CatalogTupleInsert(gp_fastsequence_rel, tuple);
 	heap_freetuple(tuple);
 
 	/* Insert entry for segfile 1 */
 	values[Anum_gp_fastsequence_objmod - 1] = Int64GetDatum(1);
 	tuple = heaptuple_form_to(tupleDesc, values, nulls, NULL, NULL);
-	simple_heap_insert(gp_fastsequence_rel, tuple);
-	CatalogUpdateIndexes(gp_fastsequence_rel, tuple);
+	CatalogTupleInsert(gp_fastsequence_rel, tuple);
 	heap_freetuple(tuple);
 
 	heap_close(gp_fastsequence_rel, RowExclusiveLock);
@@ -181,8 +179,7 @@ insert_or_update_fastsequence(Relation gp_fastsequence_rel,
 
 		newTuple = heaptuple_form_to(tupleDesc, values, nulls, NULL, NULL);
 
-		frozen_heap_insert(gp_fastsequence_rel, newTuple);
-		CatalogUpdateIndexes(gp_fastsequence_rel, newTuple);
+		CatalogTupleInsertFrozen(gp_fastsequence_rel, newTuple);
 
 		heap_freetuple(newTuple);
 	}
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 5e7cfe26558c..5b115d0d07af 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -748,15 +748,13 @@ static void MetaTrackAddUpdInternal(Oid			classid,
 		new_tuple = heap_modify_tuple(old_tuple, RelationGetDescr(rel),
 									  values,
 									  isnull, new_record_repl);
-		simple_heap_update(rel, &old_tuple->t_self, new_tuple);
-		CatalogUpdateIndexes(rel, new_tuple);
+		CatalogTupleUpdate(rel, &old_tuple->t_self, new_tuple);
 	}
 	else
 	{
 		new_tuple = heap_form_tuple(RelationGetDescr(rel), values, isnull);
 
-		simple_heap_insert(rel, new_tuple);
-		CatalogUpdateIndexes(rel, new_tuple);
+		CatalogTupleInsert(rel, new_tuple);
 	}
 
 	if (HeapTupleIsValid(old_tuple))
@@ -988,7 +986,13 @@ InsertPgAttributeTuple(Relation pg_attribute_rel,
 	if (indstate != NULL)
 		CatalogIndexInsert(indstate, tup);
 	else
-		CatalogUpdateIndexes(pg_attribute_rel, tup);
+	{
+		CatalogIndexState indstate;
+
+		indstate = CatalogOpenIndexes(pg_attribute_rel);
+		CatalogIndexInsert(indstate, tup);
+		CatalogCloseIndexes(indstate);
+	}
 
 	heap_freetuple(tup);
 }
@@ -1172,9 +1176,7 @@ InsertPgClassTuple(Relation pg_class_desc,
 	HeapTupleSetOid(tup, new_rel_oid);
 
 	/* finally insert the new tuple, update the indexes, and clean up */
-	simple_heap_insert(pg_class_desc, tup);
-
-	CatalogUpdateIndexes(pg_class_desc, tup);
+	CatalogTupleInsert(pg_class_desc, tup);
 
 	heap_freetuple(tup);
 }
@@ -2217,10 +2219,7 @@ RemoveAttributeById(Oid relid, AttrNumber attnum)
 				 "........pg.dropped.%d........", attnum);
 		namestrcpy(&(attStruct->attname), newattname);
 
-		simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-		/* keep the system catalog indexes current */
-		CatalogUpdateIndexes(attr_rel, tuple);
+		CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 	}
 
 	/*
@@ -2349,10 +2348,7 @@ RemoveAttrDefaultById(Oid attrdefId)
 
 	((Form_pg_attribute) GETSTRUCT(tuple))->atthasdef = false;
 
-	simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-	/* keep the system catalog indexes current */
-	CatalogUpdateIndexes(attr_rel, tuple);
+	CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
 	/*
 	 * Our update of the pg_attribute row will force a relcache rebuild, so
@@ -2563,9 +2559,7 @@ StoreAttrDefault(Relation rel, AttrNumber attnum,
 	adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
 
 	tuple = heap_form_tuple(adrel->rd_att, values, nulls);
-	attrdefOid = simple_heap_insert(adrel, tuple);
-
-	CatalogUpdateIndexes(adrel, tuple);
+	attrdefOid = CatalogTupleInsert(adrel, tuple);
 
 	defobject.classId = AttrDefaultRelationId;
 	defobject.objectId = attrdefOid;
@@ -2595,9 +2589,7 @@ StoreAttrDefault(Relation rel, AttrNumber attnum,
 	if (!attStruct->atthasdef)
 	{
 		attStruct->atthasdef = true;
-		simple_heap_update(attrrel, &atttup->t_self, atttup);
-		/* keep catalog indexes current */
-		CatalogUpdateIndexes(attrrel, atttup);
+		CatalogTupleUpdate(attrrel, &atttup->t_self, atttup);
 	}
 	heap_close(attrrel, RowExclusiveLock);
 	heap_freetuple(atttup);
@@ -3153,8 +3145,7 @@ MergeWithExistingConstraint(Relation rel, char *ccname, Node *expr,
 				Assert(is_local);
 				con->connoinherit = true;
 			}
-			simple_heap_update(conDesc, &tup->t_self, tup);
-			CatalogUpdateIndexes(conDesc, tup);
+			CatalogTupleUpdate(conDesc, &tup->t_self, tup);
 			break;
 		}
 	}
@@ -3194,10 +3185,7 @@ SetRelationNumChecks(Relation rel, int numchecks)
 	{
 		relStruct->relchecks = numchecks;
 
-		simple_heap_update(relrel, &reltup->t_self, reltup);
-
-		/* keep catalog indexes current */
-		CatalogUpdateIndexes(relrel, reltup);
+		CatalogTupleUpdate(relrel, &reltup->t_self, reltup);
 	}
 	else
 	{
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index ad708d5521bb..923b0c4362a4 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -716,10 +716,7 @@ UpdateIndexRelation(Oid indexoid,
 	/*
 	 * insert the tuple into the pg_index catalog
 	 */
-	simple_heap_insert(pg_index, tuple);
-
-	/* update the indexes on pg_index */
-	CatalogUpdateIndexes(pg_index, tuple);
+	CatalogTupleInsert(pg_index, tuple);
 
 	/*
 	 * close the relation and free the tuple
@@ -1482,8 +1479,7 @@ index_constraint_create(Relation heapRelation,
 
 		if (dirty)
 		{
-			simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-			CatalogUpdateIndexes(pg_index, indexTuple);
+			CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
 			InvokeObjectPostAlterHookArg(IndexRelationId, indexRelationId, 0,
 										 InvalidOid, is_internal);
@@ -2411,8 +2407,7 @@ index_build(Relation heapRelation,
 		Assert(!indexForm->indcheckxmin);
 
 		indexForm->indcheckxmin = true;
-		simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-		CatalogUpdateIndexes(pg_index, indexTuple);
+		CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
 		heap_freetuple(indexTuple);
 		heap_close(pg_index, RowExclusiveLock);
@@ -3994,8 +3989,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks)
 			indexForm->indisvalid = true;
 			indexForm->indisready = true;
 			indexForm->indislive = true;
-			simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-			CatalogUpdateIndexes(pg_index, indexTuple);
+			CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 
 			/*
 			 * Invalidate the relcache for the table, so that after we commit
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index 8bb53cd288e0..ee09fc6d62be 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -163,19 +163,67 @@ CatalogIndexInsert(CatalogIndexState indstate, HeapTuple heapTuple)
 }
 
 /*
- * CatalogUpdateIndexes - do all the indexing work for a new catalog tuple
+ * CatalogTupleInsert - do heap and indexing work for a new catalog tuple
  *
- * This is a convenience routine for the common case where we only need
- * to insert or update a single tuple in a system catalog.  Avoid using it for
- * multiple tuples, since opening the indexes and building the index info
- * structures is moderately expensive.
+ * This is a convenience routine for the common case of inserting a single
+ * tuple in a system catalog; it inserts a new heap tuple, keeping indexes
+ * current.  Avoid using it for multiple tuples, since opening the indexes and
+ * building the index info structures is moderately expensive.
+ *
+ * The Oid of the inserted tuple is returned.
+ */
+Oid
+CatalogTupleInsert(Relation heapRel, HeapTuple tup)
+{
+	CatalogIndexState indstate;
+	Oid		oid;
+
+	indstate = CatalogOpenIndexes(heapRel);
+
+	oid = simple_heap_insert(heapRel, tup);
+
+	CatalogIndexInsert(indstate, tup);
+	CatalogCloseIndexes(indstate);
+
+	return oid;
+}
+
+/*
+ * CatalogTupleUpdate - do heap and indexing work for updating a catalog tuple
+ *
+ * This is a convenience routine for the common case of updating a single
+ * tuple in a system catalog; it updates one heap tuple (identified by otid)
+ * with tup, keeping indexes current.  Avoid using it for multiple tuples,
+ * since opening the indexes and building the index info structures is
+ * moderately expensive.
  */
 void
-CatalogUpdateIndexes(Relation heapRel, HeapTuple heapTuple)
+CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
 {
 	CatalogIndexState indstate;
 
 	indstate = CatalogOpenIndexes(heapRel);
-	CatalogIndexInsert(indstate, heapTuple);
+
+	simple_heap_update(heapRel, otid, tup);
+
+	CatalogIndexInsert(indstate, tup);
+	CatalogCloseIndexes(indstate);
+}
+
+/*
+ * Greenplum: this interface is used to insert tuples into gp_fastsequence
+ * and aoseg relations during an appendoptimized (row as well as column)
+ * insert transaction.
+ */
+void
+CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup)
+{
+	CatalogIndexState indstate;
+
+	indstate = CatalogOpenIndexes(heapRel);
+
+	frozen_heap_insert(heapRel, tup);
+
+	CatalogIndexInsert(indstate, tup);
 	CatalogCloseIndexes(indstate);
 }
diff --git a/src/backend/catalog/pg_aggregate.c b/src/backend/catalog/pg_aggregate.c
index 2c7a9f790d1b..bd152946f444 100644
--- a/src/backend/catalog/pg_aggregate.c
+++ b/src/backend/catalog/pg_aggregate.c
@@ -676,9 +676,7 @@ AggregateCreate(const char *aggName,
 	tupDesc = aggdesc->rd_att;
 
 	tup = heap_form_tuple(tupDesc, values, nulls);
-	simple_heap_insert(aggdesc, tup);
-
-	CatalogUpdateIndexes(aggdesc, tup);
+	CatalogTupleInsert(aggdesc, tup);
 
 	heap_close(aggdesc, RowExclusiveLock);
 
diff --git a/src/backend/catalog/pg_appendonly.c b/src/backend/catalog/pg_appendonly.c
index e55767ecbcd1..3e349de613a0 100644
--- a/src/backend/catalog/pg_appendonly.c
+++ b/src/backend/catalog/pg_appendonly.c
@@ -91,8 +91,7 @@ InsertAppendOnlyEntry(Oid relid,
 	pg_appendonly_tuple = heap_form_tuple(RelationGetDescr(pg_appendonly_rel), values, nulls);
 
 	/* insert a new tuple */
-	simple_heap_insert(pg_appendonly_rel, pg_appendonly_tuple);
-	CatalogUpdateIndexes(pg_appendonly_rel, pg_appendonly_tuple);
+	CatalogTupleInsert(pg_appendonly_rel, pg_appendonly_tuple);
 
 	/*
      * Close the pg_appendonly_rel relcache entry without unlocking.
@@ -308,8 +307,7 @@ UpdateAppendOnlyEntryAuxOids(Oid relid,
 	}
 	newTuple = heap_modify_tuple(tuple, RelationGetDescr(pg_appendonly),
 								 newValues, newNulls, replace);
-	simple_heap_update(pg_appendonly, &newTuple->t_self, newTuple);
-	CatalogUpdateIndexes(pg_appendonly, newTuple);
+	CatalogTupleUpdate(pg_appendonly, &newTuple->t_self, newTuple);
 
 	heap_freetuple(newTuple);
 
@@ -528,8 +526,7 @@ TransferAppendonlyEntry(Oid sourceRelId, Oid targetRelId)
 	tupleCopy = heap_modify_tuple(tupleCopy, pg_appendonly_dsc,
 								  newValues, newNulls, replace);
 
-	simple_heap_insert(pg_appendonly_rel, tupleCopy);
-	CatalogUpdateIndexes(pg_appendonly_rel, tupleCopy);
+	CatalogTupleInsert(pg_appendonly_rel, tupleCopy);
 
 	heap_freetuple(tupleCopy);
 
@@ -622,8 +619,7 @@ SwapAppendonlyEntries(Oid entryRelId1, Oid entryRelId2)
 	tupleCopy1 = heap_modify_tuple(tupleCopy1, pg_appendonly_dsc,
 								  newValues, newNulls, replace);
 
-	simple_heap_insert(pg_appendonly_rel, tupleCopy1);
-	CatalogUpdateIndexes(pg_appendonly_rel, tupleCopy1);
+	CatalogTupleInsert(pg_appendonly_rel, tupleCopy1);
 
 	heap_freetuple(tupleCopy1);
 
@@ -632,8 +628,7 @@ SwapAppendonlyEntries(Oid entryRelId1, Oid entryRelId2)
 	tupleCopy2 = heap_modify_tuple(tupleCopy2, pg_appendonly_dsc,
 								  newValues, newNulls, replace);
 
-	simple_heap_insert(pg_appendonly_rel, tupleCopy2);
-	CatalogUpdateIndexes(pg_appendonly_rel, tupleCopy2);
+	CatalogTupleInsert(pg_appendonly_rel, tupleCopy2);
 
 	heap_freetuple(tupleCopy2);
 
diff --git a/src/backend/catalog/pg_attribute_encoding.c b/src/backend/catalog/pg_attribute_encoding.c
index 2b2d39e75182..dc2634ba8cc4 100644
--- a/src/backend/catalog/pg_attribute_encoding.c
+++ b/src/backend/catalog/pg_attribute_encoding.c
@@ -59,8 +59,7 @@ add_attribute_encoding_entry(Oid relid, AttrNumber attnum, Datum attoptions)
 	tuple = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
 	/* insert a new tuple */
-	simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
diff --git a/src/backend/catalog/pg_collation.c b/src/backend/catalog/pg_collation.c
index ffcf90684b7f..0c03fe6c5bf3 100644
--- a/src/backend/catalog/pg_collation.c
+++ b/src/backend/catalog/pg_collation.c
@@ -181,12 +181,9 @@ CollationCreate(const char *collname, Oid collnamespace,
 	tup = heap_form_tuple(tupDesc, values, nulls);
 
 	/* insert a new tuple */
-	oid = simple_heap_insert(rel, tup);
+	oid = CatalogTupleInsert(rel, tup);
 	Assert(OidIsValid(oid));
 
-	/* update the index if any */
-	CatalogUpdateIndexes(rel, tup);
-
 	/* set up dependencies for the new collation */
 	myself.classId = CollationRelationId;
 	myself.objectId = oid;
diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c
index 722d6127914f..9dbfb74a777a 100644
--- a/src/backend/catalog/pg_constraint.c
+++ b/src/backend/catalog/pg_constraint.c
@@ -225,10 +225,7 @@ CreateConstraintEntry(const char *constraintName,
 
 	tup = heap_form_tuple(RelationGetDescr(conDesc), values, nulls);
 
-	conOid = simple_heap_insert(conDesc, tup);
-
-	/* update catalog indexes */
-	CatalogUpdateIndexes(conDesc, tup);
+	conOid = CatalogTupleInsert(conDesc, tup);
 
 	conobject.classId = ConstraintRelationId;
 	conobject.objectId = conOid;
@@ -583,9 +580,7 @@ RemoveConstraintById(Oid conId)
 					 RelationGetRelationName(rel));
 			classForm->relchecks--;
 
-			simple_heap_update(pgrel, &relTup->t_self, relTup);
-
-			CatalogUpdateIndexes(pgrel, relTup);
+			CatalogTupleUpdate(pgrel, &relTup->t_self, relTup);
 
 			heap_freetuple(relTup);
 
@@ -681,10 +676,7 @@ RenameConstraintById(Oid conId, const char *newname)
 	/* OK, do the rename --- tuple is a copy, so OK to scribble on it */
 	namestrcpy(&(con->conname), newname);
 
-	simple_heap_update(conDesc, &tuple->t_self, tuple);
-
-	/* update the system catalog indexes */
-	CatalogUpdateIndexes(conDesc, tuple);
+	CatalogTupleUpdate(conDesc, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(ConstraintRelationId, conId, 0);
 
@@ -750,8 +742,7 @@ AlterConstraintNamespaces(Oid ownerId, Oid oldNspId,
 
 			conform->connamespace = newNspId;
 
-			simple_heap_update(conRel, &tup->t_self, tup);
-			CatalogUpdateIndexes(conRel, tup);
+			CatalogTupleUpdate(conRel, &tup->t_self, tup);
 
 			/*
 			 * Note: currently, the constraint will not have its own
@@ -801,8 +792,7 @@ ConstraintSetParentConstraint(Oid childConstrId, Oid parentConstrId)
 		constrForm->conislocal = false;
 		constrForm->coninhcount++;
 
-		simple_heap_update(constrRel, &tuple->t_self, newtup);
-		CatalogUpdateIndexes(constrRel, newtup);
+		CatalogTupleUpdate(constrRel, &tuple->t_self, newtup);
 
 		ObjectAddressSet(referenced, ConstraintRelationId, parentConstrId);
 		ObjectAddressSet(depender, ConstraintRelationId, childConstrId);
@@ -820,8 +810,7 @@ ConstraintSetParentConstraint(Oid childConstrId, Oid parentConstrId)
 		deleteDependencyRecordsForClass(ConstraintRelationId, childConstrId,
 										ConstraintRelationId,
 										DEPENDENCY_INTERNAL_AUTO);
-		simple_heap_update(constrRel, &tuple->t_self, newtup);
-		CatalogUpdateIndexes(constrRel, newtup);
+		CatalogTupleUpdate(constrRel, &tuple->t_self, newtup);
 	}
 	
 	ReleaseSysCache(tuple);
diff --git a/src/backend/catalog/pg_conversion.c b/src/backend/catalog/pg_conversion.c
index 70f37932c435..93f826614c68 100644
--- a/src/backend/catalog/pg_conversion.c
+++ b/src/backend/catalog/pg_conversion.c
@@ -106,12 +106,9 @@ ConversionCreate(const char *conname, Oid connamespace,
 	tup = heap_form_tuple(tupDesc, values, nulls);
 
 	/* insert a new tuple */
-	oid = simple_heap_insert(rel, tup);
+	oid = CatalogTupleInsert(rel, tup);
 	Assert(OidIsValid(oid));
 
-	/* update the index if any */
-	CatalogUpdateIndexes(rel, tup);
-
 	myself.classId = ConversionRelationId;
 	myself.objectId = HeapTupleGetOid(tup);
 	myself.objectSubId = 0;
diff --git a/src/backend/catalog/pg_db_role_setting.c b/src/backend/catalog/pg_db_role_setting.c
index 2271fa909f2a..22342cf38fcd 100644
--- a/src/backend/catalog/pg_db_role_setting.c
+++ b/src/backend/catalog/pg_db_role_setting.c
@@ -96,10 +96,7 @@ AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt)
 
 				newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
 											 repl_val, repl_null, repl_repl);
-				simple_heap_update(rel, &tuple->t_self, newtuple);
-
-				/* Update indexes */
-				CatalogUpdateIndexes(rel, newtuple);
+				CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
 			}
 			else
 				simple_heap_delete(rel, &tuple->t_self);
@@ -137,10 +134,7 @@ AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt)
 
 			newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
 										 repl_val, repl_null, repl_repl);
-			simple_heap_update(rel, &tuple->t_self, newtuple);
-
-			/* Update indexes */
-			CatalogUpdateIndexes(rel, newtuple);
+			CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
 		}
 		else
 			simple_heap_delete(rel, &tuple->t_self);
@@ -163,10 +157,7 @@ AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt)
 		values[Anum_pg_db_role_setting_setconfig - 1] = PointerGetDatum(a);
 		newtuple = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
-		simple_heap_insert(rel, newtuple);
-
-		/* Update indexes */
-		CatalogUpdateIndexes(rel, newtuple);
+		CatalogTupleInsert(rel, newtuple);
 	}
 
 	InvokeObjectPostAlterHookArg(DbRoleSettingRelationId,
diff --git a/src/backend/catalog/pg_depend.c b/src/backend/catalog/pg_depend.c
index 726d7f9eedc2..18e5f4d354ca 100644
--- a/src/backend/catalog/pg_depend.c
+++ b/src/backend/catalog/pg_depend.c
@@ -426,8 +426,7 @@ changeDependencyFor(Oid classId, Oid objectId,
 
 				depform->refobjid = newRefObjectId;
 
-				simple_heap_update(depRel, &tup->t_self, tup);
-				CatalogUpdateIndexes(depRel, tup);
+				CatalogTupleUpdate(depRel, &tup->t_self, tup);
 
 				heap_freetuple(tup);
 			}
diff --git a/src/backend/catalog/pg_enum.c b/src/backend/catalog/pg_enum.c
index bf3b457ddffa..d5ea7a05bdd0 100644
--- a/src/backend/catalog/pg_enum.c
+++ b/src/backend/catalog/pg_enum.c
@@ -131,8 +131,7 @@ EnumValuesCreate(Oid enumTypeOid, List *vals)
 		tup = heap_form_tuple(RelationGetDescr(pg_enum), values, nulls);
 		HeapTupleSetOid(tup, oids[elemno]);
 
-		simple_heap_insert(pg_enum, tup);
-		CatalogUpdateIndexes(pg_enum, tup);
+		CatalogTupleInsert(pg_enum, tup);
 		heap_freetuple(tup);
 
 		elemno++;
@@ -450,8 +449,7 @@ AddEnumLabel(Oid enumTypeOid,
 	values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel);
 	enum_tup = heap_form_tuple(RelationGetDescr(pg_enum), values, nulls);
 	HeapTupleSetOid(enum_tup, newOid);
-	simple_heap_insert(pg_enum, enum_tup);
-	CatalogUpdateIndexes(pg_enum, enum_tup);
+	CatalogTupleInsert(pg_enum, enum_tup);
 	heap_freetuple(enum_tup);
 
 	heap_close(pg_enum, RowExclusiveLock);
@@ -504,9 +502,7 @@ RenumberEnumType(Relation pg_enum, HeapTuple *existing, int nelems)
 		{
 			en->enumsortorder = newsortorder;
 
-			simple_heap_update(pg_enum, &newtup->t_self, newtup);
-
-			CatalogUpdateIndexes(pg_enum, newtup);
+			CatalogTupleUpdate(pg_enum, &newtup->t_self, newtup);
 		}
 
 		heap_freetuple(newtup);
diff --git a/src/backend/catalog/pg_extprotocol.c b/src/backend/catalog/pg_extprotocol.c
index 69a3d7b08c10..fa8996cfb5e7 100644
--- a/src/backend/catalog/pg_extprotocol.c
+++ b/src/backend/catalog/pg_extprotocol.c
@@ -144,9 +144,7 @@ ExtProtocolCreate(const char *protocolName,
 	tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
 	/* insert a new tuple */
-	protOid = simple_heap_insert(rel, tup);
-
-	CatalogUpdateIndexes(rel, tup);
+	protOid = CatalogTupleInsert(rel, tup);
 
 	heap_close(rel, RowExclusiveLock);
 
diff --git a/src/backend/catalog/pg_exttable.c b/src/backend/catalog/pg_exttable.c
index 8526bb5a9374..ad44df8f1b4e 100644
--- a/src/backend/catalog/pg_exttable.c
+++ b/src/backend/catalog/pg_exttable.c
@@ -173,9 +173,7 @@ InsertExtTableEntry(Oid 	tbloid,
 	pg_exttable_tuple = heap_form_tuple(RelationGetDescr(pg_exttable_rel), values, nulls);
 
 	/* insert a new tuple */
-	simple_heap_insert(pg_exttable_rel, pg_exttable_tuple);
-
-	CatalogUpdateIndexes(pg_exttable_rel, pg_exttable_tuple);
+	CatalogTupleInsert(pg_exttable_rel, pg_exttable_tuple);
 
 	/*
      * Close the pg_exttable relcache entry without unlocking.
diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index 176d8f494af7..1923bf4add08 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -435,8 +435,7 @@ StoreSingleInheritance(Oid relationId, Oid parentOid, int32 seqNumber)
 
 	tuple = heap_form_tuple(RelationGetDescr(inhRelation), values, nulls);
 
-	simple_heap_insert(inhRelation, tuple);
-	CatalogUpdateIndexes(inhRelation, tuple);
+	CatalogTupleInsert(inhRelation, tuple);
 
 	heap_freetuple(tuple);
 
diff --git a/src/backend/catalog/pg_largeobject.c b/src/backend/catalog/pg_largeobject.c
index a54bc1b1faad..74b25904d954 100644
--- a/src/backend/catalog/pg_largeobject.c
+++ b/src/backend/catalog/pg_largeobject.c
@@ -63,11 +63,9 @@ LargeObjectCreate(Oid loid)
 	if (OidIsValid(loid))
 		HeapTupleSetOid(ntup, loid);
 
-	loid_new = simple_heap_insert(pg_lo_meta, ntup);
+	loid_new = CatalogTupleInsert(pg_lo_meta, ntup);
 	Assert(!OidIsValid(loid) || loid == loid_new);
 
-	CatalogUpdateIndexes(pg_lo_meta, ntup);
-
 	heap_freetuple(ntup);
 
 	heap_close(pg_lo_meta, RowExclusiveLock);
diff --git a/src/backend/catalog/pg_namespace.c b/src/backend/catalog/pg_namespace.c
index d241cc87b604..c447d9cf08b1 100644
--- a/src/backend/catalog/pg_namespace.c
+++ b/src/backend/catalog/pg_namespace.c
@@ -76,11 +76,9 @@ NamespaceCreate(const char *nspName, Oid ownerId, bool isTemp)
 
 	tup = heap_form_tuple(tupDesc, values, nulls);
 
-	nspoid = simple_heap_insert(nspdesc, tup);
+	nspoid = CatalogTupleInsert(nspdesc, tup);
 	Assert(OidIsValid(nspoid));
 
-	CatalogUpdateIndexes(nspdesc, tup);
-
 	heap_close(nspdesc, RowExclusiveLock);
 
 	/* Record dependencies */
diff --git a/src/backend/catalog/pg_operator.c b/src/backend/catalog/pg_operator.c
index af40d6cc0d57..e201b357206d 100644
--- a/src/backend/catalog/pg_operator.c
+++ b/src/backend/catalog/pg_operator.c
@@ -265,9 +265,7 @@ OperatorShellMake(const char *operatorName,
 	/*
 	 * insert our "shell" operator tuple
 	 */
-	operatorObjectId = simple_heap_insert(pg_operator_desc, tup);
-
-	CatalogUpdateIndexes(pg_operator_desc, tup);
+	operatorObjectId = CatalogTupleInsert(pg_operator_desc, tup);
 
 	/* Add dependencies for the entry */
 	makeOperatorDependencies(tup, false);
@@ -529,7 +527,7 @@ OperatorCreate(const char *operatorName,
 								nulls,
 								replaces);
 
-		simple_heap_update(pg_operator_desc, &tup->t_self, tup);
+		CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 	}
 	else
 	{
@@ -538,12 +536,9 @@ OperatorCreate(const char *operatorName,
 		tupDesc = pg_operator_desc->rd_att;
 		tup = heap_form_tuple(tupDesc, values, nulls);
 
-		operatorObjectId = simple_heap_insert(pg_operator_desc, tup);
+		operatorObjectId = CatalogTupleInsert(pg_operator_desc, tup);
 	}
 
-	/* Must update the indexes in either case */
-	CatalogUpdateIndexes(pg_operator_desc, tup);
-
 	/* Add dependencies for the entry */
 	makeOperatorDependencies(tup, isUpdate);
 
@@ -705,9 +700,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
 										nulls,
 										replaces);
 
-				simple_heap_update(pg_operator_desc, &tup->t_self, tup);
-
-				CatalogUpdateIndexes(pg_operator_desc, tup);
+				CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 			}
 		}
 
@@ -730,9 +723,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
 								nulls,
 								replaces);
 
-		simple_heap_update(pg_operator_desc, &tup->t_self, tup);
-
-		CatalogUpdateIndexes(pg_operator_desc, tup);
+		CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 
 		values[Anum_pg_operator_oprcom - 1] = (Datum) NULL;
 		replaces[Anum_pg_operator_oprcom - 1] = false;
@@ -754,9 +745,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
 								nulls,
 								replaces);
 
-		simple_heap_update(pg_operator_desc, &tup->t_self, tup);
-
-		CatalogUpdateIndexes(pg_operator_desc, tup);
+		CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 	}
 
 	heap_close(pg_operator_desc, RowExclusiveLock);
diff --git a/src/backend/catalog/pg_proc.c b/src/backend/catalog/pg_proc.c
index f8ed8e408b7e..8c727e9a237b 100644
--- a/src/backend/catalog/pg_proc.c
+++ b/src/backend/catalog/pg_proc.c
@@ -629,7 +629,7 @@ ProcedureCreate(const char *procedureName,
 
 		/* Okay, do it... */
 		tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);
-		simple_heap_update(rel, &tup->t_self, tup);
+		CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 		ReleaseSysCache(oldtup);
 		is_update = true;
@@ -647,12 +647,10 @@ ProcedureCreate(const char *procedureName,
 			nulls[Anum_pg_proc_proacl - 1] = true;
 
 		tup = heap_form_tuple(tupDesc, values, nulls);
-		simple_heap_insert(rel, tup);
+		CatalogTupleInsert(rel, tup);
 		is_update = false;
 	}
 
-	/* Need to update indexes for either the insert or update case */
-	CatalogUpdateIndexes(rel, tup);
 
 	retval = HeapTupleGetOid(tup);
 
diff --git a/src/backend/catalog/pg_proc_callback.c b/src/backend/catalog/pg_proc_callback.c
index ae9d646bb829..91c91fc9b5a9 100644
--- a/src/backend/catalog/pg_proc_callback.c
+++ b/src/backend/catalog/pg_proc_callback.c
@@ -109,8 +109,7 @@ addProcCallback(Oid profnoid, Oid procallback, char promethod)
 	tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 	
 	/* Insert tuple into the relation */
-	simple_heap_insert(rel, tup);
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleInsert(rel, tup);
 
 	heap_close(rel, RowExclusiveLock);
 }
diff --git a/src/backend/catalog/pg_range.c b/src/backend/catalog/pg_range.c
index 75c194a18910..c1fdf7857a60 100644
--- a/src/backend/catalog/pg_range.c
+++ b/src/backend/catalog/pg_range.c
@@ -58,8 +58,7 @@ RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation,
 
 	tup = heap_form_tuple(RelationGetDescr(pg_range), values, nulls);
 
-	simple_heap_insert(pg_range, tup);
-	CatalogUpdateIndexes(pg_range, tup);
+	CatalogTupleInsert(pg_range, tup);
 	heap_freetuple(tup);
 
 	/* record type's dependencies on range-related items */
diff --git a/src/backend/catalog/pg_shdepend.c b/src/backend/catalog/pg_shdepend.c
index 8626c128aeb8..7ae665f1ff10 100644
--- a/src/backend/catalog/pg_shdepend.c
+++ b/src/backend/catalog/pg_shdepend.c
@@ -256,10 +256,7 @@ shdepChangeDep(Relation sdepRel,
 		shForm->refclassid = refclassid;
 		shForm->refobjid = refobjid;
 
-		simple_heap_update(sdepRel, &oldtup->t_self, oldtup);
-
-		/* keep indexes current */
-		CatalogUpdateIndexes(sdepRel, oldtup);
+		CatalogTupleUpdate(sdepRel, &oldtup->t_self, oldtup);
 	}
 	else
 	{
@@ -283,10 +280,7 @@ shdepChangeDep(Relation sdepRel,
 		 * it's certainly a new tuple
 		 */
 		oldtup = heap_form_tuple(RelationGetDescr(sdepRel), values, nulls);
-		simple_heap_insert(sdepRel, oldtup);
-
-		/* keep indexes current */
-		CatalogUpdateIndexes(sdepRel, oldtup);
+		CatalogTupleInsert(sdepRel, oldtup);
 	}
 
 	if (oldtup)
@@ -755,10 +749,7 @@ copyTemplateDependencies(Oid templateDbId, Oid newDbId)
 		HeapTuple	newtup;
 
 		newtup = heap_modify_tuple(tup, sdepDesc, values, nulls, replace);
-		simple_heap_insert(sdepRel, newtup);
-
-		/* Keep indexes current */
-		CatalogIndexInsert(indstate, newtup);
+		CatalogTupleInsert(sdepRel, newtup);
 
 		heap_freetuple(newtup);
 	}
@@ -878,10 +869,7 @@ shdepAddDependency(Relation sdepRel,
 
 	tup = heap_form_tuple(sdepRel->rd_att, values, nulls);
 
-	simple_heap_insert(sdepRel, tup);
-
-	/* keep indexes current */
-	CatalogUpdateIndexes(sdepRel, tup);
+	CatalogTupleInsert(sdepRel, tup);
 
 	/* clean up */
 	heap_freetuple(tup);
diff --git a/src/backend/catalog/pg_type.c b/src/backend/catalog/pg_type.c
index e65f8fd9e674..c04ea9acbb58 100644
--- a/src/backend/catalog/pg_type.c
+++ b/src/backend/catalog/pg_type.c
@@ -67,9 +67,7 @@ add_type_encoding(Oid typid, Datum typoptions)
 	tuple = heap_form_tuple(tupDesc, values, nulls);
 
 	/* Insert tuple into the relation */
-	simple_heap_insert(pg_type_encoding_desc, tuple);
-
-	CatalogUpdateIndexes(pg_type_encoding_desc, tuple);
+	CatalogTupleInsert(pg_type_encoding_desc, tuple);
 
 	heap_close(pg_type_encoding_desc, RowExclusiveLock);
 }
@@ -113,8 +111,7 @@ update_type_encoding(Oid typid, Datum typoptions)
 		newtuple = heap_modify_tuple(tup, RelationGetDescr(pgtypeenc),
 									 values, nulls, replaces);
 
-		simple_heap_update(pgtypeenc, &tup->t_self, newtuple);
-		CatalogUpdateIndexes(pgtypeenc, newtuple);
+		CatalogTupleUpdate(pgtypeenc, &tup->t_self, newtuple);
 	}
 	else
 	{
@@ -214,9 +211,7 @@ TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId)
 	/*
 	 * insert the tuple in the relation and get the tuple's oid.
 	 */
-	typoid = simple_heap_insert(pg_type_desc, tup);
-
-	CatalogUpdateIndexes(pg_type_desc, tup);
+	typoid = CatalogTupleInsert(pg_type_desc, tup);
 
 	/*
 	 * Create dependencies.  We can/must skip this in bootstrap mode.
@@ -509,7 +504,7 @@ TypeCreateWithOptions(Oid newTypeOid,
 								nulls,
 								replaces);
 
-		simple_heap_update(pg_type_desc, &tup->t_self, tup);
+		CatalogTupleUpdate(pg_type_desc, &tup->t_self, tup);
 
 		typeObjectId = HeapTupleGetOid(tup);
 
@@ -526,12 +521,9 @@ TypeCreateWithOptions(Oid newTypeOid,
 			HeapTupleSetOid(tup, newTypeOid);
 		/* else allow system to assign oid */
 
-		typeObjectId = simple_heap_insert(pg_type_desc, tup);
+		typeObjectId = CatalogTupleInsert(pg_type_desc, tup);
 	}
 
-	/* Update indexes */
-	CatalogUpdateIndexes(pg_type_desc, tup);
-
 	/*
 	 * Create dependencies.  We can/must skip this in bootstrap mode.
 	 */
@@ -869,10 +861,7 @@ RenameTypeInternal(Oid typeOid, const char *newTypeName, Oid typeNamespace)
 	/* OK, do the rename --- tuple is a copy, so OK to scribble on it */
 	namestrcpy(&(typ->typname), newTypeName);
 
-	simple_heap_update(pg_type_desc, &tuple->t_self, tuple);
-
-	/* update the system catalog indexes */
-	CatalogUpdateIndexes(pg_type_desc, tuple);
+	CatalogTupleUpdate(pg_type_desc, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(TypeRelationId, typeOid, 0);
 
diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c
index 88ba2dfb3a7f..4f05cc30434d 100644
--- a/src/backend/catalog/toasting.c
+++ b/src/backend/catalog/toasting.c
@@ -426,10 +426,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid,
 	if (!IsBootstrapProcessingMode())
 	{
 		/* normal case, use a transactional update */
-		simple_heap_update(class_rel, &reltup->t_self, reltup);
-
-		/* Keep catalog indexes current */
-		CatalogUpdateIndexes(class_rel, reltup);
+		CatalogTupleUpdate(class_rel, &reltup->t_self, reltup);
 	}
 	else
 	{
diff --git a/src/backend/cdb/cdbcat.c b/src/backend/cdb/cdbcat.c
index 21ffb1453f71..49bc39450d70 100644
--- a/src/backend/cdb/cdbcat.c
+++ b/src/backend/cdb/cdbcat.c
@@ -549,8 +549,7 @@ GpPolicyStore(Oid tbloid, const GpPolicy *policy)
 	gp_policy_tuple = heap_form_tuple(RelationGetDescr(gp_policy_rel), values, nulls);
 
 	/* Insert tuple into the relation */
-	simple_heap_insert(gp_policy_rel, gp_policy_tuple);
-	CatalogUpdateIndexes(gp_policy_rel, gp_policy_tuple);
+	CatalogTupleInsert(gp_policy_rel, gp_policy_tuple);
 
 	/*
 	 * Register the table as dependent on the operator classes used in the
@@ -666,16 +665,14 @@ GpPolicyReplace(Oid tbloid, const GpPolicy *policy)
 												 RelationGetDescr(gp_policy_rel),
 												 values, nulls, repl);
 
-		simple_heap_update(gp_policy_rel, &gp_policy_tuple->t_self, newtuple);
-		CatalogUpdateIndexes(gp_policy_rel, newtuple);
+		CatalogTupleUpdate(gp_policy_rel, &gp_policy_tuple->t_self, newtuple);
 
 		heap_freetuple(newtuple);
 	}
 	else
 	{
 		gp_policy_tuple = heap_form_tuple(gp_policy_rel->rd_att, values, nulls);
-		(void) simple_heap_insert(gp_policy_rel, gp_policy_tuple);
-		CatalogUpdateIndexes(gp_policy_rel, gp_policy_tuple);
+		(void) CatalogTupleInsert(gp_policy_rel, gp_policy_tuple);
 	}
 	systable_endscan(scan);
 
diff --git a/src/backend/cdb/cdbpartition.c b/src/backend/cdb/cdbpartition.c
index fc9fec099304..84b383c08fc6 100644
--- a/src/backend/cdb/cdbpartition.c
+++ b/src/backend/cdb/cdbpartition.c
@@ -1722,8 +1722,7 @@ add_partition(Partition *part)
 	tup = heap_form_tuple(RelationGetDescr(partrel), values, isnull);
 
 	/* Insert tuple into the relation */
-	part->partid = simple_heap_insert(partrel, tup);
-	CatalogUpdateIndexes(partrel, tup);
+	part->partid = CatalogTupleInsert(partrel, tup);
 
 	heap_close(partrel, NoLock);
 }
@@ -1792,8 +1791,7 @@ add_partition_rule(PartitionRule *rule)
 	tup = heap_form_tuple(RelationGetDescr(rulerel), values, isnull);
 
 	/* Insert tuple into the relation */
-	rule->parruleid = simple_heap_insert(rulerel, tup);
-	CatalogUpdateIndexes(rulerel, tup);
+	rule->parruleid = CatalogTupleInsert(rulerel, tup);
 
 	heap_close(rulerel, NoLock);
 }
@@ -2330,8 +2328,7 @@ parruleord_open_gap(Oid partid, int16 level, Oid parent, int16 ruleord,
 
 		closegap ? rule_desc->parruleord-- : rule_desc->parruleord++;
 
-		simple_heap_update(rel, &tuple->t_self, tuple);
-		CatalogUpdateIndexes(rel, tuple);
+		CatalogTupleUpdate(rel, &tuple->t_self, tuple);
 
 		heap_freetuple(tuple);
 	}
@@ -7330,8 +7327,7 @@ exchange_part_rule(Oid oldrelid, Oid newrelid)
 
 		((Form_pg_partition_rule) GETSTRUCT(tuple))->parchildrelid = newrelid;
 
-		simple_heap_update(catalogRelation, &tuple->t_self, tuple);
-		CatalogUpdateIndexes(catalogRelation, tuple);
+		CatalogTupleUpdate(catalogRelation, &tuple->t_self, tuple);
 
 		heap_freetuple(tuple);
 	}
@@ -7381,8 +7377,7 @@ exchange_permissions(Oid oldrelid, Oid newrelid)
 	replace_tuple = heap_modify_tuple(oldtuple,
 									  RelationGetDescr(rel),
 									  values, nulls, replaces);
-	simple_heap_update(rel, &oldtuple->t_self, replace_tuple);
-	CatalogUpdateIndexes(rel, replace_tuple);
+	CatalogTupleUpdate(rel, &oldtuple->t_self, replace_tuple);
 
 	/* XXX: Update the shared dependency ACL info */
 
@@ -7400,8 +7395,7 @@ exchange_permissions(Oid oldrelid, Oid newrelid)
 	replace_tuple = heap_modify_tuple(newtuple,
 									  RelationGetDescr(rel),
 									  values, nulls, replaces);
-	simple_heap_update(rel, &newtuple->t_self, replace_tuple);
-	CatalogUpdateIndexes(rel, replace_tuple);
+	CatalogTupleUpdate(rel, &newtuple->t_self, replace_tuple);
 
 	/* update shared dependency */
 
@@ -8685,8 +8679,7 @@ add_partition_encoding(Oid relid, Oid paroid, AttrNumber attnum, List *encoding)
 	tuple = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
 	/* Insert tuple into the relation */
-	simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c
index 5529ea22b7de..b4b03019f6da 100644
--- a/src/backend/commands/alter.c
+++ b/src/backend/commands/alter.c
@@ -289,8 +289,7 @@ AlterObjectRename_internal(Relation rel, Oid objectId, const char *new_name)
 							   values, nulls, replaces);
 
 	/* Perform actual update */
-	simple_heap_update(rel, &oldtup->t_self, newtup);
-	CatalogUpdateIndexes(rel, newtup);
+	CatalogTupleUpdate(rel, &oldtup->t_self, newtup);
 
 	InvokeObjectPostAlterHook(classId, objectId, 0);
 
@@ -707,8 +706,7 @@ AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
 							   values, nulls, replaces);
 
 	/* Perform actual update */
-	simple_heap_update(rel, &tup->t_self, newtup);
-	CatalogUpdateIndexes(rel, newtup);
+	CatalogTupleUpdate(rel, &tup->t_self, newtup);
 
 	/* Release memory */
 	pfree(values);
@@ -986,8 +984,7 @@ AlterObjectOwner_internal(Relation rel, Oid objectId, Oid new_ownerId)
 								   values, nulls, replaces);
 
 		/* Perform actual update */
-		simple_heap_update(rel, &newtup->t_self, newtup);
-		CatalogUpdateIndexes(rel, newtup);
+		CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
 		/* Update owner dependency reference */
 		if (classId == LargeObjectMetadataRelationId)
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 79abc9881092..08564aae0873 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -2944,18 +2944,15 @@ update_attstats(Oid relid, bool inh, int natts, VacAttrStats **vacattrstats)
 									 nulls,
 									 replaces);
 			ReleaseSysCache(oldtup);
-			simple_heap_update(sd, &stup->t_self, stup);
+			CatalogTupleUpdate(sd, &stup->t_self, stup);
 		}
 		else
 		{
 			/* No, insert new tuple */
 			stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
-			simple_heap_insert(sd, stup);
+			CatalogTupleInsert(sd, stup);
 		}
 
-		/* update indexes too */
-		CatalogUpdateIndexes(sd, stup);
-
 		heap_freetuple(stup);
 	}
 
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 5eab15aa1c1f..215163022c47 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -612,8 +612,7 @@ mark_index_clustered(Relation rel, Oid indexOid, bool is_internal)
 		if (indexForm->indisclustered)
 		{
 			indexForm->indisclustered = false;
-			simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-			CatalogUpdateIndexes(pg_index, indexTuple);
+			CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 		}
 		else if (thisIndexOid == indexOid)
 		{
@@ -621,8 +620,7 @@ mark_index_clustered(Relation rel, Oid indexOid, bool is_internal)
 			if (!IndexIsValid(indexForm))
 				elog(ERROR, "cannot cluster on invalid index %u", indexOid);
 			indexForm->indisclustered = true;
-			simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-			CatalogUpdateIndexes(pg_index, indexTuple);
+			CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 		}
 
 		InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
@@ -1266,12 +1264,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose,
 
 	/* Don't update the stats for pg_class.  See swap_relation_files. */
 	if (OIDOldHeap != RelationRelationId)
-	{
-		simple_heap_update(relRelation, &reltup->t_self, reltup);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relRelation, reltup);
-	}
+		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
 	else
 		CacheInvalidateRelcacheByTuple(reltup);
 
@@ -1807,8 +1800,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 		relform->relfrozenxid = frozenXid;
 		relform->relminmxid = cutoffMulti;
 
-		simple_heap_update(relRelation, &reltup->t_self, reltup);
-		CatalogUpdateIndexes(relRelation, reltup);
+		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
 
 		heap_close(relRelation, RowExclusiveLock);
 	}
diff --git a/src/backend/commands/comment.c b/src/backend/commands/comment.c
index da07392fa85b..a86a0b23562f 100644
--- a/src/backend/commands/comment.c
+++ b/src/backend/commands/comment.c
@@ -225,7 +225,7 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
 		{
 			newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(description), values,
 										 nulls, replaces);
-			simple_heap_update(description, &oldtuple->t_self, newtuple);
+			CatalogTupleUpdate(description, &oldtuple->t_self, newtuple);
 		}
 
 		break;					/* Assume there can be only one match */
@@ -239,15 +239,11 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
 	{
 		newtuple = heap_form_tuple(RelationGetDescr(description),
 								   values, nulls);
-		simple_heap_insert(description, newtuple);
+		CatalogTupleInsert(description, newtuple);
 	}
 
-	/* Update indexes, if necessary */
 	if (newtuple != NULL)
-	{
-		CatalogUpdateIndexes(description, newtuple);
 		heap_freetuple(newtuple);
-	}
 
 	/* Done */
 
@@ -319,7 +315,7 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
 		{
 			newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(shdescription),
 										 values, nulls, replaces);
-			simple_heap_update(shdescription, &oldtuple->t_self, newtuple);
+			CatalogTupleUpdate(shdescription, &oldtuple->t_self, newtuple);
 		}
 
 		break;					/* Assume there can be only one match */
@@ -333,15 +329,11 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
 	{
 		newtuple = heap_form_tuple(RelationGetDescr(shdescription),
 								   values, nulls);
-		simple_heap_insert(shdescription, newtuple);
+		CatalogTupleInsert(shdescription, newtuple);
 	}
 
-	/* Update indexes, if necessary */
 	if (newtuple != NULL)
-	{
-		CatalogUpdateIndexes(shdescription, newtuple);
 		heap_freetuple(newtuple);
-	}
 
 	/* Done */
 
diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index ba40d1ece41f..191df48a3764 100644
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -548,10 +548,7 @@ createdb(const CreatedbStmt *stmt)
 
 	HeapTupleSetOid(tuple, dboid);
 
-	simple_heap_insert(pg_database_rel, tuple);
-
-	/* Update indexes */
-	CatalogUpdateIndexes(pg_database_rel, tuple);
+	CatalogTupleInsert(pg_database_rel, tuple);
 
 	if (shouldDispatch)
 	{
@@ -1119,8 +1116,7 @@ RenameDatabase(const char *oldname, const char *newname)
 	if (!HeapTupleIsValid(newtup))
 		elog(ERROR, "cache lookup failed for database %u", db_id);
 	namestrcpy(&(((Form_pg_database) GETSTRUCT(newtup))->datname), newname);
-	simple_heap_update(rel, &newtup->t_self, newtup);
-	CatalogUpdateIndexes(rel, newtup);
+	CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
 	/* MPP-6929: metadata tracking */
 	if (Gp_role == GP_ROLE_DISPATCH)
@@ -1389,10 +1385,7 @@ movedb(const char *dbname, const char *tblspcname)
 		newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(pgdbrel),
 									 new_record,
 									 new_record_nulls, new_record_repl);
-		simple_heap_update(pgdbrel, &oldtuple->t_self, newtuple);
-
-		/* Update indexes */
-		CatalogUpdateIndexes(pgdbrel, newtuple);
+		CatalogTupleUpdate(pgdbrel, &oldtuple->t_self, newtuple);
 
 		InvokeObjectPostAlterHook(DatabaseRelationId,
 								  HeapTupleGetOid(newtuple), 0);
@@ -1613,10 +1606,7 @@ AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel)
 
 	newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), new_record,
 								 new_record_nulls, new_record_repl);
-	simple_heap_update(rel, &tuple->t_self, newtuple);
-
-	/* Update indexes */
-	CatalogUpdateIndexes(rel, newtuple);
+	CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(DatabaseRelationId,
 							  HeapTupleGetOid(newtuple), 0);
@@ -1773,8 +1763,7 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
 		}
 
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
-		simple_heap_update(rel, &newtuple->t_self, newtuple);
-		CatalogUpdateIndexes(rel, newtuple);
+		CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
 		heap_freetuple(newtuple);
 
diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index f96c5123d3fd..1e4caf2fd041 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -333,8 +333,7 @@ insert_event_trigger_tuple(char *trigname, char *eventname, Oid evtOwner,
 
 	/* Insert heap tuple. */
 	tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
-	trigoid = simple_heap_insert(tgrel, tuple);
-	CatalogUpdateIndexes(tgrel, tuple);
+	trigoid = CatalogTupleInsert(tgrel, tuple);
 	heap_freetuple(tuple);
 
 	/* Depend on owner. */
@@ -452,8 +451,7 @@ AlterEventTrigger(AlterEventTrigStmt *stmt)
 	evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);
 	evtForm->evtenabled = tgenabled;
 
-	simple_heap_update(tgrel, &tup->t_self, tup);
-	CatalogUpdateIndexes(tgrel, tup);
+	CatalogTupleUpdate(tgrel, &tup->t_self, tup);
 
 	InvokeObjectPostAlterHook(EventTriggerRelationId,
 							  trigoid, 0);
@@ -546,8 +544,7 @@ AlterEventTriggerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
 			 errhint("The owner of an event trigger must be a superuser.")));
 
 	form->evtowner = newOwnerId;
-	simple_heap_update(rel, &tup->t_self, tup);
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 	/* Update owner dependency reference */
 	changeDependencyOnOwner(EventTriggerRelationId,
diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c
index 266a64e3d92d..f284ef65b78b 100644
--- a/src/backend/commands/extension.c
+++ b/src/backend/commands/extension.c
@@ -1655,8 +1655,7 @@ InsertExtensionTuple(const char *extName, Oid extOwner,
 
 	tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
-	extensionOid = simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	extensionOid = CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 	heap_close(rel, RowExclusiveLock);
@@ -2336,8 +2335,7 @@ pg_extension_config_dump(PG_FUNCTION_ARGS)
 	extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
 							   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(extRel, &extTup->t_self, extTup);
-	CatalogUpdateIndexes(extRel, extTup);
+	CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
 	systable_endscan(extScan);
 
@@ -2514,8 +2512,7 @@ extension_config_remove(Oid extensionoid, Oid tableoid)
 	extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
 							   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(extRel, &extTup->t_self, extTup);
-	CatalogUpdateIndexes(extRel, extTup);
+	CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
 	systable_endscan(extScan);
 
@@ -2690,8 +2687,7 @@ AlterExtensionNamespace(List *names, const char *newschema)
 	/* Now adjust pg_extension.extnamespace */
 	extForm->extnamespace = nspOid;
 
-	simple_heap_update(extRel, &extTup->t_self, extTup);
-	CatalogUpdateIndexes(extRel, extTup);
+	CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
 	heap_close(extRel, RowExclusiveLock);
 
@@ -2954,8 +2950,7 @@ ApplyExtensionUpdates(Oid extensionOid,
 		extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
 								   values, nulls, repl);
 
-		simple_heap_update(extRel, &extTup->t_self, extTup);
-		CatalogUpdateIndexes(extRel, extTup);
+		CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
 		systable_endscan(extScan);
 
diff --git a/src/backend/commands/foreigncmds.c b/src/backend/commands/foreigncmds.c
index bdba40314bc8..fc9fa0388a98 100644
--- a/src/backend/commands/foreigncmds.c
+++ b/src/backend/commands/foreigncmds.c
@@ -275,8 +275,7 @@ AlterForeignDataWrapperOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerI
 		tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,
 								repl_repl);
 
-		simple_heap_update(rel, &tup->t_self, tup);
-		CatalogUpdateIndexes(rel, tup);
+		CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 		/* Update owner dependency reference */
 		changeDependencyOnOwner(ForeignDataWrapperRelationId,
@@ -413,8 +412,7 @@ AlterForeignServerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
 		tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,
 								repl_repl);
 
-		simple_heap_update(rel, &tup->t_self, tup);
-		CatalogUpdateIndexes(rel, tup);
+		CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 		/* Update owner dependency reference */
 		changeDependencyOnOwner(ForeignServerRelationId, HeapTupleGetOid(tup),
@@ -641,8 +639,7 @@ CreateForeignDataWrapper(CreateFdwStmt *stmt)
 
 	tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
-	fdwId = simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	fdwId = CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
@@ -805,8 +802,7 @@ AlterForeignDataWrapper(AlterFdwStmt *stmt)
 	tp = heap_modify_tuple(tp, RelationGetDescr(rel),
 						   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(rel, &tp->t_self, tp);
-	CatalogUpdateIndexes(rel, tp);
+	CatalogTupleUpdate(rel, &tp->t_self, tp);
 
 	heap_freetuple(tp);
 
@@ -969,9 +965,7 @@ CreateForeignServer(CreateForeignServerStmt *stmt)
 
 	tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
-	srvId = simple_heap_insert(rel, tuple);
-
-	CatalogUpdateIndexes(rel, tuple);
+	srvId = CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
@@ -1091,8 +1085,7 @@ AlterForeignServer(AlterForeignServerStmt *stmt)
 	tp = heap_modify_tuple(tp, RelationGetDescr(rel),
 						   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(rel, &tp->t_self, tp);
-	CatalogUpdateIndexes(rel, tp);
+	CatalogTupleUpdate(rel, &tp->t_self, tp);
 
 	InvokeObjectPostAlterHook(ForeignServerRelationId, srvId, 0);
 
@@ -1227,9 +1220,7 @@ CreateUserMapping(CreateUserMappingStmt *stmt)
 
 	tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
-	umId = simple_heap_insert(rel, tuple);
-
-	CatalogUpdateIndexes(rel, tuple);
+	umId = CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
@@ -1350,8 +1341,7 @@ AlterUserMapping(AlterUserMappingStmt *stmt)
 	tp = heap_modify_tuple(tp, RelationGetDescr(rel),
 						   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(rel, &tp->t_self, tp);
-	CatalogUpdateIndexes(rel, tp);
+	CatalogTupleUpdate(rel, &tp->t_self, tp);
 
 	heap_freetuple(tp);
 
@@ -1533,8 +1523,7 @@ CreateForeignTable(CreateForeignTableStmt *stmt, Oid relid)
 
 	tuple = heap_form_tuple(ftrel->rd_att, values, nulls);
 
-	simple_heap_insert(ftrel, tuple);
-	CatalogUpdateIndexes(ftrel, tuple);
+	CatalogTupleInsert(ftrel, tuple);
 
 	heap_freetuple(tuple);
 
diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
index 8c59f1122076..ab2de0bd09d2 100644
--- a/src/backend/commands/functioncmds.c
+++ b/src/backend/commands/functioncmds.c
@@ -1638,8 +1638,7 @@ AlterFunction(AlterFunctionStmt *stmt)
 							   procForm->proretset);
 
 	/* Do the update */
-	simple_heap_update(rel, &tup->t_self, tup);
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 	InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);
 
@@ -1689,9 +1688,7 @@ SetFunctionReturnType(Oid funcOid, Oid newRetType)
 	procForm->prorettype = newRetType;
 
 	/* update the catalog and its indexes */
-	simple_heap_update(pg_proc_rel, &tup->t_self, tup);
-
-	CatalogUpdateIndexes(pg_proc_rel, tup);
+	CatalogTupleUpdate(pg_proc_rel, &tup->t_self, tup);
 
 	heap_close(pg_proc_rel, RowExclusiveLock);
 
@@ -1740,9 +1737,7 @@ SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType)
 	procForm->proargtypes.values[argIndex] = newArgType;
 
 	/* update the catalog and its indexes */
-	simple_heap_update(pg_proc_rel, &tup->t_self, tup);
-
-	CatalogUpdateIndexes(pg_proc_rel, tup);
+	CatalogTupleUpdate(pg_proc_rel, &tup->t_self, tup);
 
 	heap_close(pg_proc_rel, RowExclusiveLock);
 
@@ -2040,9 +2035,7 @@ CreateCast(CreateCastStmt *stmt)
 
 	tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
 
-	castid = simple_heap_insert(relation, tuple);
-
-	CatalogUpdateIndexes(relation, tuple);
+	castid = CatalogTupleInsert(relation, tuple);
 
 	/* make dependency entries */
 	myself.classId = CastRelationId;
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index e67767612f5f..ec65e61eccb4 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -170,8 +170,7 @@ cdb_sync_indcheckxmin_with_segments(Oid indexRelationId)
 		if (!indexForm->indcheckxmin)
 		{
 			indexForm->indcheckxmin = true;
-			simple_heap_update(pg_index, &indexTuple->t_self, indexTuple);
-			CatalogUpdateIndexes(pg_index, indexTuple);
+			CatalogTupleUpdate(pg_index, &indexTuple->t_self, indexTuple);
 		}
 
 		heap_freetuple(indexTuple);
@@ -2751,8 +2750,7 @@ IndexSetParentIndex(Relation partitionIdx, Oid parentOid)
 			tuple = heap_form_tuple(RelationGetDescr(pg_inherits),
 									values, isnull);
 
-			simple_heap_insert(pg_inherits, tuple);
-			CatalogUpdateIndexes(pg_inherits, tuple);
+			CatalogTupleInsert(pg_inherits, tuple);
 
 			fix_dependencies = true;
 		}
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index cd349db4dce0..619dcaa7fd7a 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -111,9 +111,7 @@ SetMatViewPopulatedState(Relation relation, bool newstate)
 
 	((Form_pg_class) GETSTRUCT(tuple))->relispopulated = newstate;
 
-	simple_heap_update(pgrel, &tuple->t_self, tuple);
-
-	CatalogUpdateIndexes(pgrel, tuple);
+	CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
 
 	heap_freetuple(tuple);
 	heap_close(pgrel, RowExclusiveLock);
diff --git a/src/backend/commands/opclasscmds.c b/src/backend/commands/opclasscmds.c
index 5a7f007b2138..4ec226f18caf 100644
--- a/src/backend/commands/opclasscmds.c
+++ b/src/backend/commands/opclasscmds.c
@@ -291,9 +291,7 @@ CreateOpFamily(char *amname, char *opfname, Oid namespaceoid, Oid amoid)
 
 	tup = heap_form_tuple(rel->rd_att, values, nulls);
 
-	opfamilyoid = simple_heap_insert(rel, tup);
-
-	CatalogUpdateIndexes(rel, tup);
+	opfamilyoid = CatalogTupleInsert(rel, tup);
 
 	heap_freetuple(tup);
 
@@ -661,9 +659,7 @@ DefineOpClass(CreateOpClassStmt *stmt)
 
 	tup = heap_form_tuple(rel->rd_att, values, nulls);
 
-	opclassoid = simple_heap_insert(rel, tup);
-
-	CatalogUpdateIndexes(rel, tup);
+	opclassoid = CatalogTupleInsert(rel, tup);
 
 	heap_freetuple(tup);
 
@@ -1368,9 +1364,7 @@ storeOperators(List *opfamilyname, Oid amoid,
 
 		tup = heap_form_tuple(rel->rd_att, values, nulls);
 
-		entryoid = simple_heap_insert(rel, tup);
-
-		CatalogUpdateIndexes(rel, tup);
+		entryoid = CatalogTupleInsert(rel, tup);
 
 		heap_freetuple(tup);
 
@@ -1479,9 +1473,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
 
 		tup = heap_form_tuple(rel->rd_att, values, nulls);
 
-		entryoid = simple_heap_insert(rel, tup);
-
-		CatalogUpdateIndexes(rel, tup);
+		entryoid = CatalogTupleInsert(rel, tup);
 
 		heap_freetuple(tup);
 
diff --git a/src/backend/commands/proclang.c b/src/backend/commands/proclang.c
index 219c9bcd5df5..2add1fd829a5 100644
--- a/src/backend/commands/proclang.c
+++ b/src/backend/commands/proclang.c
@@ -404,7 +404,7 @@ create_proc_lang(const char *languageName, bool replace,
 
 		/* Okay, do it... */
 		tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);
-		simple_heap_update(rel, &tup->t_self, tup);
+		CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 		ReleaseSysCache(oldtup);
 		is_update = true;
@@ -413,13 +413,10 @@ create_proc_lang(const char *languageName, bool replace,
 	{
 		/* Creating a new language */
 		tup = heap_form_tuple(tupDesc, values, nulls);
-		simple_heap_insert(rel, tup);
+		CatalogTupleInsert(rel, tup);
 		is_update = false;
 	}
 
-	/* Need to update indexes for either the insert or update case */
-	CatalogUpdateIndexes(rel, tup);
-
 	/*
 	 * Create dependencies for the new language.  If we are updating an
 	 * existing language, first delete any existing pg_depend entries.
diff --git a/src/backend/commands/queue.c b/src/backend/commands/queue.c
index 15e25b31e9ca..4550447a70c9 100644
--- a/src/backend/commands/queue.c
+++ b/src/backend/commands/queue.c
@@ -258,15 +258,13 @@ AddUpdResqueueCapabilityEntryInternal(
 									  RelationGetDescr(resqueuecap_rel),
 									  values, isnull, new_record_repl);
 
-		simple_heap_update(resqueuecap_rel, &old_tuple->t_self, new_tuple);
-		CatalogUpdateIndexes(resqueuecap_rel, new_tuple);
+		CatalogTupleUpdate(resqueuecap_rel, &old_tuple->t_self, new_tuple);
 	}
 	else
 	{
 		new_tuple = heap_form_tuple(RelationGetDescr(resqueuecap_rel), values, isnull);
 
-		simple_heap_insert(resqueuecap_rel, new_tuple);
-		CatalogUpdateIndexes(resqueuecap_rel, new_tuple);
+		CatalogTupleInsert(resqueuecap_rel, new_tuple);
 	}
 
 	if (HeapTupleIsValid(old_tuple))
@@ -919,8 +917,7 @@ CreateQueue(CreateQueueStmt *stmt)
 	/*
 	 * Insert new record in the pg_resqueue table
 	 */
-	queueid = simple_heap_insert(pg_resqueue_rel, tuple);
-	CatalogUpdateIndexes(pg_resqueue_rel, tuple);
+	queueid = CatalogTupleInsert(pg_resqueue_rel, tuple);
 
 	/* process the remainder of the WITH (...) list items */
 	if (bWith)
@@ -1322,8 +1319,7 @@ AlterQueue(AlterQueueStmt *stmt)
 	new_tuple = heap_modify_tuple(tuple, pg_resqueue_dsc, new_record,
 									new_record_nulls, new_record_repl);
 
-	simple_heap_update(pg_resqueue_rel, &tuple->t_self, new_tuple);
-	CatalogUpdateIndexes(pg_resqueue_rel, new_tuple);
+	CatalogTupleUpdate(pg_resqueue_rel, &tuple->t_self, new_tuple);
 
 	systable_endscan(sscan);
 
diff --git a/src/backend/commands/resgroupcmds.c b/src/backend/commands/resgroupcmds.c
index 38df14ef8fe2..11f3f7b4ddba 100644
--- a/src/backend/commands/resgroupcmds.c
+++ b/src/backend/commands/resgroupcmds.c
@@ -190,8 +190,7 @@ CreateResourceGroup(CreateResourceGroupStmt *stmt)
 	/*
 	 * Insert new record in the pg_resgroup table
 	 */
-	groupid = simple_heap_insert(pg_resgroup_rel, tuple);
-	CatalogUpdateIndexes(pg_resgroup_rel, tuple);
+	groupid = CatalogTupleInsert(pg_resgroup_rel, tuple);
 
 	/* process the WITH (...) list items */
 	validateCapabilities(pg_resgroupcapability_rel, groupid, &caps, true);
@@ -1269,8 +1268,7 @@ updateResgroupCapabilityEntry(Relation rel,
 	newTuple = heap_modify_tuple(oldTuple, RelationGetDescr(rel),
 								 values, isnull, repl);
 
-	simple_heap_update(rel, &oldTuple->t_self, newTuple);
-	CatalogUpdateIndexes(rel, newTuple);
+	CatalogTupleUpdate(rel, &oldTuple->t_self, newTuple);
 
 	systable_endscan(sscan);
 }
@@ -1469,8 +1467,7 @@ insertResgroupCapabilityEntry(Relation rel,
 	new_record[Anum_pg_resgroupcapability_value - 1] = CStringGetTextDatum(value);
 
 	tuple = heap_form_tuple(tupleDesc, new_record, new_record_nulls);
-	simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	CatalogTupleInsert(rel, tuple);
 }
 
 /*
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index de0e3364d3f5..b890adea6f87 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -352,8 +352,7 @@ RenameSchema(const char *oldname, const char *newname)
 
 	/* rename */
 	namestrcpy(&(((Form_pg_namespace) GETSTRUCT(tup))->nspname), newname);
-	simple_heap_update(rel, &tup->t_self, tup);
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 	/* MPP-6929: metadata tracking */
 	if (Gp_role == GP_ROLE_DISPATCH)
@@ -500,8 +499,7 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
 
 		newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
 
-		simple_heap_update(rel, &newtuple->t_self, newtuple);
-		CatalogUpdateIndexes(rel, newtuple);
+		CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
 		/* MPP-6929: metadata tracking */
 		if (Gp_role == GP_ROLE_DISPATCH)
diff --git a/src/backend/commands/seclabel.c b/src/backend/commands/seclabel.c
index cff7bcbd9b01..0805b57ecc4f 100644
--- a/src/backend/commands/seclabel.c
+++ b/src/backend/commands/seclabel.c
@@ -296,7 +296,7 @@ SetSharedSecurityLabel(const ObjectAddress *object,
 			replaces[Anum_pg_shseclabel_label - 1] = true;
 			newtup = heap_modify_tuple(oldtup, RelationGetDescr(pg_shseclabel),
 									   values, nulls, replaces);
-			simple_heap_update(pg_shseclabel, &oldtup->t_self, newtup);
+			CatalogTupleUpdate(pg_shseclabel, &oldtup->t_self, newtup);
 		}
 	}
 	systable_endscan(scan);
@@ -306,15 +306,11 @@ SetSharedSecurityLabel(const ObjectAddress *object,
 	{
 		newtup = heap_form_tuple(RelationGetDescr(pg_shseclabel),
 								 values, nulls);
-		simple_heap_insert(pg_shseclabel, newtup);
+		CatalogTupleInsert(pg_shseclabel, newtup);
 	}
 
-	/* Update indexes, if necessary */
 	if (newtup != NULL)
-	{
-		CatalogUpdateIndexes(pg_shseclabel, newtup);
 		heap_freetuple(newtup);
-	}
 
 	heap_close(pg_shseclabel, RowExclusiveLock);
 }
@@ -387,7 +383,7 @@ SetSecurityLabel(const ObjectAddress *object,
 			replaces[Anum_pg_seclabel_label - 1] = true;
 			newtup = heap_modify_tuple(oldtup, RelationGetDescr(pg_seclabel),
 									   values, nulls, replaces);
-			simple_heap_update(pg_seclabel, &oldtup->t_self, newtup);
+			CatalogTupleUpdate(pg_seclabel, &oldtup->t_self, newtup);
 		}
 	}
 	systable_endscan(scan);
@@ -397,15 +393,12 @@ SetSecurityLabel(const ObjectAddress *object,
 	{
 		newtup = heap_form_tuple(RelationGetDescr(pg_seclabel),
 								 values, nulls);
-		simple_heap_insert(pg_seclabel, newtup);
+		CatalogTupleInsert(pg_seclabel, newtup);
 	}
 
 	/* Update indexes, if necessary */
 	if (newtup != NULL)
-	{
-		CatalogUpdateIndexes(pg_seclabel, newtup);
 		heap_freetuple(newtup);
-	}
 
 	heap_close(pg_seclabel, RowExclusiveLock);
 }
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 5860c029ebb7..5f4172c4cbe8 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2738,9 +2738,7 @@ StoreCatalogInheritance1(Oid relationId, Oid parentOid,
 
 	tuple = heap_form_tuple(desc, values, nulls);
 
-	simple_heap_insert(inhRelation, tuple);
-
-	CatalogUpdateIndexes(inhRelation, tuple);
+	CatalogTupleInsert(inhRelation, tuple);
 
 	heap_freetuple(tuple);
 
@@ -2829,10 +2827,7 @@ SetRelationHasSubclass(Oid relationId, bool relhassubclass)
 	if (classtuple->relhassubclass != relhassubclass)
 	{
 		classtuple->relhassubclass = relhassubclass;
-		simple_heap_update(relationRelation, &tuple->t_self, tuple);
-
-		/* keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relationRelation, tuple);
+		CatalogTupleUpdate(relationRelation, &tuple->t_self, tuple);
 	}
 	else
 	{
@@ -3020,10 +3015,7 @@ renameatt_internal(Oid myrelid,
 	/* apply the update */
 	namestrcpy(&(attform->attname), newattname);
 
-	simple_heap_update(attrelation, &atttup->t_self, atttup);
-
-	/* keep system catalog indexes current */
-	CatalogUpdateIndexes(attrelation, atttup);
+	CatalogTupleUpdate(attrelation, &atttup->t_self, atttup);
 
 	InvokeObjectPostAlterHook(RelationRelationId, myrelid, attnum);
 
@@ -3476,10 +3468,7 @@ RenameRelationInternal(Oid myrelid, const char *newrelname, bool is_internal)
 	 */
 	namestrcpy(&(relform->relname), newrelname);
 
-	simple_heap_update(relrelation, &reltup->t_self, reltup);
-
-	/* keep the system catalog indexes current */
-	CatalogUpdateIndexes(relrelation, reltup);
+	CatalogTupleUpdate(relrelation, &reltup->t_self, reltup);
 
 	InvokeObjectPostAlterHookArg(RelationRelationId, myrelid, 0,
 								 InvalidOid, is_internal);
@@ -7592,8 +7581,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 
 			/* Bump the existing child att's inhcount */
 			childatt->attinhcount++;
-			simple_heap_update(attrdesc, &tuple->t_self, tuple);
-			CatalogUpdateIndexes(attrdesc, tuple);
+			CatalogTupleUpdate(attrdesc, &tuple->t_self, tuple);
 
 			heap_freetuple(tuple);
 
@@ -7680,10 +7668,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	else
 		((Form_pg_class) GETSTRUCT(reltup))->relnatts = newattnum;
 
-	simple_heap_update(pgclass, &reltup->t_self, reltup);
-
-	/* keep catalog indexes current */
-	CatalogUpdateIndexes(pgclass, reltup);
+	CatalogTupleUpdate(pgclass, &reltup->t_self, reltup);
 
 	heap_freetuple(reltup);
 
@@ -8157,10 +8142,7 @@ ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode)
 	{
 		((Form_pg_attribute) GETSTRUCT(tuple))->attnotnull = FALSE;
 
-		simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-		/* keep the system catalog indexes current */
-		CatalogUpdateIndexes(attr_rel, tuple);
+		CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 	}
 
 	InvokeObjectPostAlterHook(RelationRelationId,
@@ -8219,10 +8201,7 @@ ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
 	{
 		((Form_pg_attribute) GETSTRUCT(tuple))->attnotnull = TRUE;
 
-		simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-		/* keep the system catalog indexes current */
-		CatalogUpdateIndexes(attr_rel, tuple);
+		CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
 		/* Tell Phase 3 it needs to test the constraint */
 		tab->new_notnull = true;
@@ -8475,10 +8454,7 @@ ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE
 
 	attrtuple->attstattarget = newtarget;
 
-	simple_heap_update(attrelation, &tuple->t_self, tuple);
-
-	/* keep system catalog indexes current */
-	CatalogUpdateIndexes(attrelation, tuple);
+	CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel),
@@ -8551,8 +8527,7 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options,
 								 repl_val, repl_null, repl_repl);
 
 	/* Update system catalog. */
-	simple_heap_update(attrelation, &newtuple->t_self, newtuple);
-	CatalogUpdateIndexes(attrelation, newtuple);
+	CatalogTupleUpdate(attrelation, &newtuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel),
@@ -8625,10 +8600,7 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc
 				 errmsg("column data type %s can only have storage PLAIN",
 						format_type_be(attrtuple->atttypid))));
 
-	simple_heap_update(attrelation, &tuple->t_self, tuple);
-
-	/* keep system catalog indexes current */
-	CatalogUpdateIndexes(attrelation, tuple);
+	CatalogTupleUpdate(attrelation, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel),
@@ -8803,10 +8775,7 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 					/* Child column must survive my deletion */
 					childatt->attinhcount--;
 
-					simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-					/* keep the system catalog indexes current */
-					CatalogUpdateIndexes(attr_rel, tuple);
+					CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
 					/* Make update visible */
 					CommandCounterIncrement();
@@ -8822,10 +8791,7 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 				childatt->attinhcount--;
 				childatt->attislocal = true;
 
-				simple_heap_update(attr_rel, &tuple->t_self, tuple);
-
-				/* keep the system catalog indexes current */
-				CatalogUpdateIndexes(attr_rel, tuple);
+				CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
 				/* Make update visible */
 				CommandCounterIncrement();
@@ -8871,10 +8837,7 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 		tuple_class = (Form_pg_class) GETSTRUCT(tuple);
 
 		tuple_class->relhasoids = false;
-		simple_heap_update(class_rel, &tuple->t_self, tuple);
-
-		/* Keep the catalog indexes up to date */
-		CatalogUpdateIndexes(class_rel, tuple);
+		CatalogTupleUpdate(class_rel, &tuple->t_self, tuple);
 
 		heap_close(class_rel, RowExclusiveLock);
 
@@ -9744,8 +9707,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 		copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
 		copy_con->condeferrable = cmdcon->deferrable;
 		copy_con->condeferred = cmdcon->initdeferred;
-		simple_heap_update(conrel, &copyTuple->t_self, copyTuple);
-		CatalogUpdateIndexes(conrel, copyTuple);
+		CatalogTupleUpdate(conrel, &copyTuple->t_self, copyTuple);
 
 		InvokeObjectPostAlterHook(ConstraintRelationId,
 								  HeapTupleGetOid(contuple), 0);
@@ -9798,8 +9760,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 
 			copy_tg->tgdeferrable = cmdcon->deferrable;
 			copy_tg->tginitdeferred = cmdcon->initdeferred;
-			simple_heap_update(tgrel, &copyTuple->t_self, copyTuple);
-			CatalogUpdateIndexes(tgrel, copyTuple);
+			CatalogTupleUpdate(tgrel, &copyTuple->t_self, copyTuple);
 
 			InvokeObjectPostAlterHook(TriggerRelationId,
 									  HeapTupleGetOid(tgtuple), 0);
@@ -9975,8 +9936,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 		copyTuple = heap_copytuple(tuple);
 		copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
 		copy_con->convalidated = true;
-		simple_heap_update(conrel, &copyTuple->t_self, copyTuple);
-		CatalogUpdateIndexes(conrel, copyTuple);
+		CatalogTupleUpdate(conrel, &copyTuple->t_self, copyTuple);
 
 		InvokeObjectPostAlterHook(ConstraintRelationId,
 								  HeapTupleGetOid(tuple), 0);
@@ -10886,8 +10846,7 @@ ATExecDropConstraint(Relation rel, const char *constrName,
 			{
 				/* Child constraint must survive my deletion */
 				con->coninhcount--;
-				simple_heap_update(conrel, &copy_tuple->t_self, copy_tuple);
-				CatalogUpdateIndexes(conrel, copy_tuple);
+				CatalogTupleUpdate(conrel, &copy_tuple->t_self, copy_tuple);
 
 				/* Make update visible */
 				CommandCounterIncrement();
@@ -10903,8 +10862,7 @@ ATExecDropConstraint(Relation rel, const char *constrName,
 			con->coninhcount--;
 			con->conislocal = true;
 
-			simple_heap_update(conrel, &copy_tuple->t_self, copy_tuple);
-			CatalogUpdateIndexes(conrel, copy_tuple);
+			CatalogTupleUpdate(conrel, &copy_tuple->t_self, copy_tuple);
 
 			/* Make update visible */
 			CommandCounterIncrement();
@@ -11635,10 +11593,7 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 
 	ReleaseSysCache(typeTuple);
 
-	simple_heap_update(attrelation, &heapTup->t_self, heapTup);
-
-	/* keep system catalog indexes current */
-	CatalogUpdateIndexes(attrelation, heapTup);
+	CatalogTupleUpdate(attrelation, &heapTup->t_self, heapTup);
 
 	heap_close(attrelation, RowExclusiveLock);
 
@@ -11890,8 +11845,7 @@ ATExecAlterColumnGenericOptions(Relation rel,
 	newtuple = heap_modify_tuple(tuple, RelationGetDescr(attrel),
 								 repl_val, repl_null, repl_repl);
 
-	simple_heap_update(attrel, &newtuple->t_self, newtuple);
-	CatalogUpdateIndexes(attrel, newtuple);
+	CatalogTupleUpdate(attrel, &newtuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel),
@@ -12385,8 +12339,7 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lock
 
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
 
-		simple_heap_update(class_rel, &newtuple->t_self, newtuple);
-		CatalogUpdateIndexes(class_rel, newtuple);
+		CatalogTupleUpdate(class_rel, &newtuple->t_self, newtuple);
 
 		heap_freetuple(newtuple);
 
@@ -12547,8 +12500,7 @@ change_owner_fix_column_acls(Oid relationOid, Oid oldOwnerId, Oid newOwnerId)
 									 RelationGetDescr(attRelation),
 									 repl_val, repl_null, repl_repl);
 
-		simple_heap_update(attRelation, &newtuple->t_self, newtuple);
-		CatalogUpdateIndexes(attRelation, newtuple);
+		CatalogTupleUpdate(attRelation, &newtuple->t_self, newtuple);
 
 		heap_freetuple(newtuple);
 	}
@@ -12972,9 +12924,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
 	newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
 								 repl_val, repl_null, repl_repl);
 
-	simple_heap_update(pgclass, &newtuple->t_self, newtuple);
-
-	CatalogUpdateIndexes(pgclass, newtuple);
+	CatalogTupleUpdate(pgclass, &newtuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
@@ -13031,9 +12981,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
 		newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
 									 repl_val, repl_null, repl_repl);
 
-		simple_heap_update(pgclass, &newtuple->t_self, newtuple);
-
-		CatalogUpdateIndexes(pgclass, newtuple);
+		CatalogTupleUpdate(pgclass, &newtuple->t_self, newtuple);
 
 		InvokeObjectPostAlterHookArg(RelationRelationId,
 									 RelationGetRelid(toastrel), 0,
@@ -13235,8 +13183,7 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 	/* update the pg_class row */
 	rd_rel->reltablespace = (newTableSpace == MyDatabaseTableSpace) ? InvalidOid : newTableSpace;
 	rd_rel->relfilenode = newrelfilenode;
-	simple_heap_update(pg_class, &tuple->t_self, tuple);
-	CatalogUpdateIndexes(pg_class, tuple);
+	CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0);
 
@@ -14005,8 +13952,7 @@ MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, List *inhAt
 				}
 			}
 
-			simple_heap_update(attrrel, &tuple->t_self, tuple);
-			CatalogUpdateIndexes(attrrel, tuple);
+			CatalogTupleUpdate(attrrel, &tuple->t_self, tuple);
 			heap_freetuple(tuple);
 		}
 		else
@@ -14038,8 +13984,7 @@ MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, List *inhAt
 
 			/* See comments above; these changes should be the same */
 			childatt->attinhcount++;
-			simple_heap_update(attrrel, &tuple->t_self, tuple);
-			CatalogUpdateIndexes(attrrel, tuple);
+			CatalogTupleUpdate(attrrel, &tuple->t_self, tuple);
 			heap_freetuple(tuple);
 		}
 		else
@@ -14159,8 +14104,7 @@ MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel)
 			child_copy = heap_copytuple(child_tuple);
 			child_con = (Form_pg_constraint) GETSTRUCT(child_copy);
 			child_con->coninhcount++;
-			simple_heap_update(catalog_relation, &child_copy->t_self, child_copy);
-			CatalogUpdateIndexes(catalog_relation, child_copy);
+			CatalogTupleUpdate(catalog_relation, &child_copy->t_self, child_copy);
 			heap_freetuple(child_copy);
 
 			found = true;
@@ -14297,8 +14241,7 @@ RemoveInheritance(Relation child_rel, Relation parent_rel, bool is_partition)
 			if (copy_att->attinhcount == 0)
 				copy_att->attislocal = true;
 
-			simple_heap_update(catalogRelation, &copyTuple->t_self, copyTuple);
-			CatalogUpdateIndexes(catalogRelation, copyTuple);
+			CatalogTupleUpdate(catalogRelation, &copyTuple->t_self, copyTuple);
 			heap_freetuple(copyTuple);
 		}
 	}
@@ -14372,8 +14315,7 @@ RemoveInheritance(Relation child_rel, Relation parent_rel, bool is_partition)
 			if (copy_con->coninhcount == 0)
 				copy_con->conislocal = true;
 
-			simple_heap_update(catalogRelation, &copyTuple->t_self, copyTuple);
-			CatalogUpdateIndexes(catalogRelation, copyTuple);
+			CatalogTupleUpdate(catalogRelation, &copyTuple->t_self, copyTuple);
 			heap_freetuple(copyTuple);
 		}
 	}
@@ -14522,8 +14464,7 @@ change_dropped_col_datatypes(Relation rel)
 			att->attstorage = 'p';
 			att->attalign = 'i';
 
-			simple_heap_update(catalogRelation, &tuple->t_self, copyTuple);
-			CatalogUpdateIndexes(catalogRelation, copyTuple);
+			CatalogTupleUpdate(catalogRelation, &tuple->t_self, copyTuple);
 		}
 	}
 	systable_endscan(scan);
@@ -17256,8 +17197,7 @@ ATPExecPartRename(Relation rel,
 		pgrule = (Form_pg_partition_rule)GETSTRUCT(tuple);
 		namestrcpy(&(pgrule->parname), newpartname);
 
-		simple_heap_update(part_rel, &tuple->t_self, tuple);
-		CatalogUpdateIndexes(part_rel, tuple);
+		CatalogTupleUpdate(part_rel, &tuple->t_self, tuple);
 
 		heap_freetuple(tuple);
 		heap_close(part_rel, NoLock);
@@ -18958,8 +18898,7 @@ ATExecAddOf(Relation rel, const TypeName *ofTypename, LOCKMODE lockmode)
 	if (!HeapTupleIsValid(classtuple))
 		elog(ERROR, "cache lookup failed for relation %u", relid);
 	((Form_pg_class) GETSTRUCT(classtuple))->reloftype = typeid;
-	simple_heap_update(relationRelation, &classtuple->t_self, classtuple);
-	CatalogUpdateIndexes(relationRelation, classtuple);
+	CatalogTupleUpdate(relationRelation, &classtuple->t_self, classtuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
 
@@ -19001,8 +18940,7 @@ ATExecDropOf(Relation rel, LOCKMODE lockmode)
 	if (!HeapTupleIsValid(tuple))
 		elog(ERROR, "cache lookup failed for relation %u", relid);
 	((Form_pg_class) GETSTRUCT(tuple))->reloftype = InvalidOid;
-	simple_heap_update(relationRelation, &tuple->t_self, tuple);
-	CatalogUpdateIndexes(relationRelation, tuple);
+	CatalogTupleUpdate(relationRelation, &tuple->t_self, tuple);
 
 	InvokeObjectPostAlterHook(RelationRelationId, relid, 0);
 
@@ -19042,8 +18980,7 @@ relation_mark_replica_identity(Relation rel, char ri_type, Oid indexOid,
 	if (pg_class_form->relreplident != ri_type)
 	{
 		pg_class_form->relreplident = ri_type;
-		simple_heap_update(pg_class, &pg_class_tuple->t_self, pg_class_tuple);
-		CatalogUpdateIndexes(pg_class, pg_class_tuple);
+		CatalogTupleUpdate(pg_class, &pg_class_tuple->t_self, pg_class_tuple);
 	}
 	heap_close(pg_class, RowExclusiveLock);
 	heap_freetuple(pg_class_tuple);
@@ -19102,8 +19039,7 @@ relation_mark_replica_identity(Relation rel, char ri_type, Oid indexOid,
 
 		if (dirty)
 		{
-			simple_heap_update(pg_index, &pg_index_tuple->t_self, pg_index_tuple);
-			CatalogUpdateIndexes(pg_index, pg_index_tuple);
+			CatalogTupleUpdate(pg_index, &pg_index_tuple->t_self, pg_index_tuple);
 			InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
 										 InvalidOid, is_internal);
 		}
@@ -19293,8 +19229,7 @@ ATExecGenericOptions(Relation rel, List *options)
 	tuple = heap_modify_tuple(tuple, RelationGetDescr(ftrel),
 							  repl_val, repl_null, repl_repl);
 
-	simple_heap_update(ftrel, &tuple->t_self, tuple);
-	CatalogUpdateIndexes(ftrel, tuple);
+	CatalogTupleUpdate(ftrel, &tuple->t_self, tuple);
 
 	/*
 	 * Invalidate relcache so that all sessions will refresh any cached plans
@@ -19610,8 +19545,7 @@ AlterRelationNamespaceInternal(Relation classRel, Oid relOid,
 		/* classTup is a copy, so OK to scribble on */
 		classForm->relnamespace = newNspOid;
 
-		simple_heap_update(classRel, &classTup->t_self, classTup);
-		CatalogUpdateIndexes(classRel, classTup);
+		CatalogTupleUpdate(classRel, &classTup->t_self, classTup);
 
 		/* Update dependency on schema if caller said so */
 		if (hasDependEntry &&
diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c
index 37b34e6f8f76..053d4cdbd7d3 100644
--- a/src/backend/commands/tablespace.c
+++ b/src/backend/commands/tablespace.c
@@ -381,9 +381,7 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
 
 	tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
-	tablespaceoid = simple_heap_insert(rel, tuple);
-
-	CatalogUpdateIndexes(rel, tuple);
+	tablespaceoid = CatalogTupleInsert(rel, tuple);
 
 	heap_freetuple(tuple);
 
@@ -1282,8 +1280,7 @@ RenameTableSpace(const char *oldname, const char *newname)
 	/* OK, update the entry */
 	namestrcpy(&(newform->spcname), newname);
 
-	simple_heap_update(rel, &newtuple->t_self, newtuple);
-	CatalogUpdateIndexes(rel, newtuple);
+	CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
 	/* MPP-6929: metadata tracking */
 	if (Gp_role == GP_ROLE_DISPATCH)
@@ -1361,8 +1358,7 @@ AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
 								 repl_null, repl_repl);
 
 	/* Update system catalog. */
-	simple_heap_update(rel, &newtuple->t_self, newtuple);
-	CatalogUpdateIndexes(rel, newtuple);
+	CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(TableSpaceRelationId, HeapTupleGetOid(tup), 0);
 
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 8622607f51aa..1b360fd8732f 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -715,9 +715,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
 	/*
 	 * Insert tuple into pg_trigger.
 	 */
-	simple_heap_insert(tgrel, tuple);
-
-	CatalogUpdateIndexes(tgrel, tuple);
+	CatalogTupleInsert(tgrel, tuple);
 
 	heap_freetuple(tuple);
 	heap_close(tgrel, RowExclusiveLock);
@@ -740,9 +738,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
 
 	((Form_pg_class) GETSTRUCT(tuple))->relhastriggers = true;
 
-	simple_heap_update(pgrel, &tuple->t_self, tuple);
-
-	CatalogUpdateIndexes(pgrel, tuple);
+	CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
 
 	heap_freetuple(tuple);
 	heap_close(pgrel, RowExclusiveLock);
@@ -1371,10 +1367,7 @@ renametrig(RenameStmt *stmt)
 		namestrcpy(&((Form_pg_trigger) GETSTRUCT(tuple))->tgname,
 				   stmt->newname);
 
-		simple_heap_update(tgrel, &tuple->t_self, tuple);
-
-		/* keep system catalog indexes current */
-		CatalogUpdateIndexes(tgrel, tuple);
+		CatalogTupleUpdate(tgrel, &tuple->t_self, tuple);
 
 		InvokeObjectPostAlterHook(TriggerRelationId,
 								  HeapTupleGetOid(tuple), 0);
@@ -1485,10 +1478,7 @@ EnableDisableTrigger(Relation rel, const char *tgname,
 
 			newtrig->tgenabled = fires_when;
 
-			simple_heap_update(tgrel, &newtup->t_self, newtup);
-
-			/* Keep catalog indexes current */
-			CatalogUpdateIndexes(tgrel, newtup);
+			CatalogTupleUpdate(tgrel, &newtup->t_self, newtup);
 
 			heap_freetuple(newtup);
 
diff --git a/src/backend/commands/tsearchcmds.c b/src/backend/commands/tsearchcmds.c
index 02883a9aef0e..6005f6e1377b 100644
--- a/src/backend/commands/tsearchcmds.c
+++ b/src/backend/commands/tsearchcmds.c
@@ -268,9 +268,7 @@ DefineTSParser(List *names, List *parameters)
 
 	tup = heap_form_tuple(prsRel->rd_att, values, nulls);
 
-	prsOid = simple_heap_insert(prsRel, tup);
-
-	CatalogUpdateIndexes(prsRel, tup);
+	prsOid = CatalogTupleInsert(prsRel, tup);
 
 	makeParserDependencies(tup);
 
@@ -492,9 +490,7 @@ DefineTSDictionary(List *names, List *parameters)
 
 	tup = heap_form_tuple(dictRel->rd_att, values, nulls);
 
-	dictOid = simple_heap_insert(dictRel, tup);
-
-	CatalogUpdateIndexes(dictRel, tup);
+	dictOid = CatalogTupleInsert(dictRel, tup);
 
 	makeDictionaryDependencies(tup);
 
@@ -645,9 +641,7 @@ AlterTSDictionary(AlterTSDictionaryStmt *stmt)
 	newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
 							   repl_val, repl_null, repl_repl);
 
-	simple_heap_update(rel, &newtup->t_self, newtup);
-
-	CatalogUpdateIndexes(rel, newtup);
+	CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
 	InvokeObjectPostAlterHook(TSDictionaryRelationId, dictId, 0);
 
@@ -834,9 +828,7 @@ DefineTSTemplate(List *names, List *parameters)
 
 	tup = heap_form_tuple(tmplRel->rd_att, values, nulls);
 
-	tmplOid = simple_heap_insert(tmplRel, tup);
-
-	CatalogUpdateIndexes(tmplRel, tup);
+	tmplOid = CatalogTupleInsert(tmplRel, tup);
 
 	makeTSTemplateDependencies(tup);
 
@@ -1099,9 +1091,7 @@ DefineTSConfiguration(List *names, List *parameters)
 
 	tup = heap_form_tuple(cfgRel->rd_att, values, nulls);
 
-	cfgOid = simple_heap_insert(cfgRel, tup);
-
-	CatalogUpdateIndexes(cfgRel, tup);
+	cfgOid = CatalogTupleInsert(cfgRel, tup);
 
 	if (OidIsValid(sourceOid))
 	{
@@ -1139,9 +1129,7 @@ DefineTSConfiguration(List *names, List *parameters)
 
 			newmaptup = heap_form_tuple(mapRel->rd_att, mapvalues, mapnulls);
 
-			simple_heap_insert(mapRel, newmaptup);
-
-			CatalogUpdateIndexes(mapRel, newmaptup);
+			CatalogTupleInsert(mapRel, newmaptup);
 
 			heap_freetuple(newmaptup);
 		}
@@ -1463,9 +1451,7 @@ MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
 				newtup = heap_modify_tuple(maptup,
 										   RelationGetDescr(relMap),
 										   repl_val, repl_null, repl_repl);
-				simple_heap_update(relMap, &newtup->t_self, newtup);
-
-				CatalogUpdateIndexes(relMap, newtup);
+				CatalogTupleUpdate(relMap, &newtup->t_self, newtup);
 			}
 		}
 
@@ -1490,8 +1476,7 @@ MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
 				values[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictIds[j]);
 
 				tup = heap_form_tuple(relMap->rd_att, values, nulls);
-				simple_heap_insert(relMap, tup);
-				CatalogUpdateIndexes(relMap, tup);
+				CatalogTupleInsert(relMap, tup);
 
 				heap_freetuple(tup);
 			}
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 7ce86c2c2843..7dd718b292bb 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -2335,9 +2335,7 @@ AlterDomainDefault(List *names, Node *defaultRaw)
 								 new_record, new_record_nulls,
 								 new_record_repl);
 
-	simple_heap_update(rel, &tup->t_self, newtuple);
-
-	CatalogUpdateIndexes(rel, newtuple);
+	CatalogTupleUpdate(rel, &tup->t_self, newtuple);
 
 	/* Must extract ACL for use of GenerateTypeDependencies */
 	aclDatum = heap_getattr(newtuple, Anum_pg_type_typacl,
@@ -2467,9 +2465,7 @@ AlterDomainNotNull(List *names, bool notNull)
 	 */
 	typTup->typnotnull = notNull;
 
-	simple_heap_update(typrel, &tup->t_self, tup);
-
-	CatalogUpdateIndexes(typrel, tup);
+	CatalogTupleUpdate(typrel, &tup->t_self, tup);
 
 	InvokeObjectPostAlterHook(TypeRelationId, domainoid, 0);
 
@@ -2758,8 +2754,7 @@ AlterDomainValidateConstraint(List *names, char *constrName)
 	copyTuple = heap_copytuple(tuple);
 	copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
 	copy_con->convalidated = true;
-	simple_heap_update(conrel, &copyTuple->t_self, copyTuple);
-	CatalogUpdateIndexes(conrel, copyTuple);
+	CatalogTupleUpdate(conrel, &copyTuple->t_self, copyTuple);
 
 	InvokeObjectPostAlterHook(ConstraintRelationId,
 							  HeapTupleGetOid(copyTuple), 0);
@@ -3594,9 +3589,7 @@ AlterTypeOwnerInternal(Oid typeOid, Oid newOwnerId)
 	tup = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null,
 							repl_repl);
 
-	simple_heap_update(rel, &tup->t_self, tup);
-
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 	/* If it has an array type, update that too */
 	if (OidIsValid(typTup->typarray))
@@ -3742,8 +3735,7 @@ AlterTypeNamespaceInternal(Oid typeOid, Oid nspOid,
 	/* tup is a copy, so we can scribble directly on it */
 	typform->typnamespace = nspOid;
 
-	simple_heap_update(rel, &tup->t_self, tup);
-	CatalogUpdateIndexes(rel, tup);
+	CatalogTupleUpdate(rel, &tup->t_self, tup);
 
 	/*
 	 * Composite types have pg_class entries.
@@ -3821,8 +3813,7 @@ AlterTypeArray(Oid typeOid, Oid arrayOid)
 
 	typform->typarray = arrayOid;
 
-	simple_heap_update(typrel, &typtup->t_self, typtup);
-	CatalogUpdateIndexes(typrel, typtup);
+	CatalogTupleUpdate(typrel, &typtup->t_self, typtup);
 
 	InvokeObjectPostAlterHook(TypeRelationId, typeOid, 0);
 	heap_freetuple(typtup);
diff --git a/src/backend/commands/user.c b/src/backend/commands/user.c
index 41b335bd065e..e646762d3191 100644
--- a/src/backend/commands/user.c
+++ b/src/backend/commands/user.c
@@ -599,8 +599,7 @@ CreateRole(CreateRoleStmt *stmt)
 	/*
 	 * Insert new record in the pg_authid table
 	 */
-	roleid = simple_heap_insert(pg_authid_rel, tuple);
-	CatalogUpdateIndexes(pg_authid_rel, tuple);
+	roleid = CatalogTupleInsert(pg_authid_rel, tuple);
 
 	/*
 	 * Advance command counter so we can see new record; else tests in
@@ -1277,10 +1276,7 @@ AlterRole(AlterRoleStmt *stmt)
 
 	new_tuple = heap_modify_tuple(tuple, pg_authid_dsc, new_record,
 								  new_record_nulls, new_record_repl);
-	simple_heap_update(pg_authid_rel, &tuple->t_self, new_tuple);
-
-	/* Update indexes */
-	CatalogUpdateIndexes(pg_authid_rel, new_tuple);
+	CatalogTupleUpdate(pg_authid_rel, &tuple->t_self, new_tuple);
 
 	InvokeObjectPostAlterHook(AuthIdRelationId, roleid, 0);
 
@@ -1751,9 +1747,7 @@ RenameRole(const char *oldname, const char *newname)
 	}
 
 	newtuple = heap_modify_tuple(oldtuple, dsc, repl_val, repl_null, repl_repl);
-	simple_heap_update(rel, &oldtuple->t_self, newtuple);
-
-	CatalogUpdateIndexes(rel, newtuple);
+	CatalogTupleUpdate(rel, &oldtuple->t_self, newtuple);
 
 	InvokeObjectPostAlterHook(AuthIdRelationId, roleid, 0);
 
@@ -2081,16 +2075,14 @@ AddRoleMems(const char *rolename, Oid roleid,
 			tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
 									  new_record,
 									  new_record_nulls, new_record_repl);
-			simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);
-			CatalogUpdateIndexes(pg_authmem_rel, tuple);
+			CatalogTupleUpdate(pg_authmem_rel, &tuple->t_self, tuple);
 			ReleaseSysCache(authmem_tuple);
 		}
 		else
 		{
 			tuple = heap_form_tuple(pg_authmem_dsc,
 									new_record, new_record_nulls);
-			simple_heap_insert(pg_authmem_rel, tuple);
-			CatalogUpdateIndexes(pg_authmem_rel, tuple);
+			CatalogTupleInsert(pg_authmem_rel, tuple);
 		}
 
 		/* CCI after each change, in case there are duplicates in list */
@@ -2489,8 +2481,7 @@ DelRoleMems(const char *rolename, Oid roleid,
 			tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
 									  new_record,
 									  new_record_nulls, new_record_repl);
-			simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);
-			CatalogUpdateIndexes(pg_authmem_rel, tuple);
+			CatalogTupleUpdate(pg_authmem_rel, &tuple->t_self, tuple);
 		}
 
 		ReleaseSysCache(authmem_tuple);
@@ -2614,8 +2605,7 @@ AddRoleDenials(const char *rolename, Oid roleid, List *addintervals)
 		tuple = heap_form_tuple(pg_auth_time_dsc, new_record, new_record_nulls);
 
 		/* Insert tuple into the relation */
-		simple_heap_insert(pg_auth_time_rel, tuple);
-		CatalogUpdateIndexes(pg_auth_time_rel, tuple);
+		CatalogTupleInsert(pg_auth_time_rel, tuple);
 	}
 
 	CommandCounterIncrement();
diff --git a/src/backend/fts/fts.c b/src/backend/fts/fts.c
index 370d1989b64f..2815d3c3f13f 100644
--- a/src/backend/fts/fts.c
+++ b/src/backend/fts/fts.c
@@ -225,8 +225,7 @@ probeWalRepUpdateConfig(int16 dbid, int16 segindex, char role,
 		histvals[Anum_gp_configuration_history_desc-1] =
 				CStringGetTextDatum(desc);
 		histtuple = heap_form_tuple(RelationGetDescr(histrel), histvals, histnulls);
-		simple_heap_insert(histrel, histtuple);
-		CatalogUpdateIndexes(histrel, histtuple);
+		CatalogTupleInsert(histrel, histtuple);
 
 		SIMPLE_FAULT_INJECTOR("fts_update_config");
 
@@ -282,8 +281,7 @@ probeWalRepUpdateConfig(int16 dbid, int16 segindex, char role,
 
 		newtuple = heap_modify_tuple(configtuple, RelationGetDescr(configrel),
 									 configvals, confignulls, repls);
-		simple_heap_update(configrel, &configtuple->t_self, newtuple);
-		CatalogUpdateIndexes(configrel, newtuple);
+		CatalogTupleUpdate(configrel, &configtuple->t_self, newtuple);
 
 		systable_endscan(sscan);
 		pfree(newtuple);
diff --git a/src/backend/rewrite/rewriteDefine.c b/src/backend/rewrite/rewriteDefine.c
index 007828902f11..7a55ac0cad91 100644
--- a/src/backend/rewrite/rewriteDefine.c
+++ b/src/backend/rewrite/rewriteDefine.c
@@ -128,7 +128,7 @@ InsertRule(char *rulname,
 		tup = heap_modify_tuple(oldtup, RelationGetDescr(pg_rewrite_desc),
 								values, nulls, replaces);
 
-		simple_heap_update(pg_rewrite_desc, &tup->t_self, tup);
+		CatalogTupleUpdate(pg_rewrite_desc, &tup->t_self, tup);
 
 		ReleaseSysCache(oldtup);
 
@@ -139,11 +139,9 @@ InsertRule(char *rulname,
 	{
 		tup = heap_form_tuple(pg_rewrite_desc->rd_att, values, nulls);
 
-		rewriteObjectId = simple_heap_insert(pg_rewrite_desc, tup);
+		rewriteObjectId = CatalogTupleInsert(pg_rewrite_desc, tup);
 	}
 
-	/* Need to update indexes in either case */
-	CatalogUpdateIndexes(pg_rewrite_desc, tup);
 
 	heap_freetuple(tup);
 
@@ -637,8 +635,7 @@ DefineQueryRewrite(char *rulename,
 		classForm->relminmxid = InvalidMultiXactId;
 		classForm->relreplident = REPLICA_IDENTITY_NOTHING;
 
-		simple_heap_update(relationRelation, &classTup->t_self, classTup);
-		CatalogUpdateIndexes(relationRelation, classTup);
+		CatalogTupleUpdate(relationRelation, &classTup->t_self, classTup);
 
 		heap_freetuple(classTup);
 		heap_close(relationRelation, RowExclusiveLock);
@@ -888,10 +885,7 @@ EnableDisableRule(Relation rel, const char *rulename,
 	{
 		((Form_pg_rewrite) GETSTRUCT(ruletup))->ev_enabled =
 			CharGetDatum(fires_when);
-		simple_heap_update(pg_rewrite_desc, &ruletup->t_self, ruletup);
-
-		/* keep system catalog indexes current */
-		CatalogUpdateIndexes(pg_rewrite_desc, ruletup);
+		CatalogTupleUpdate(pg_rewrite_desc, &ruletup->t_self, ruletup);
 
 		changed = true;
 	}
@@ -1006,10 +1000,7 @@ RenameRewriteRule(RangeVar *relation, const char *oldName,
 	/* OK, do the update */
 	namestrcpy(&(ruleform->rulename), newName);
 
-	simple_heap_update(pg_rewrite_desc, &ruletup->t_self, ruletup);
-
-	/* keep system catalog indexes current */
-	CatalogUpdateIndexes(pg_rewrite_desc, ruletup);
+	CatalogTupleUpdate(pg_rewrite_desc, &ruletup->t_self, ruletup);
 
 	heap_freetuple(ruletup);
 	heap_close(pg_rewrite_desc, RowExclusiveLock);
diff --git a/src/backend/rewrite/rewriteSupport.c b/src/backend/rewrite/rewriteSupport.c
index eb54d5ce6db2..18152a6119d3 100644
--- a/src/backend/rewrite/rewriteSupport.c
+++ b/src/backend/rewrite/rewriteSupport.c
@@ -72,10 +72,7 @@ SetRelationRuleStatus(Oid relationId, bool relHasRules)
 		/* Do the update */
 		classForm->relhasrules = relHasRules;
 
-		simple_heap_update(relationRelation, &tuple->t_self, tuple);
-
-		/* Keep the catalog indexes up to date */
-		CatalogUpdateIndexes(relationRelation, tuple);
+		CatalogTupleUpdate(relationRelation, &tuple->t_self, tuple);
 	}
 	else
 	{
diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c
index 091814230113..3fb40ffbd9c4 100644
--- a/src/backend/storage/large_object/inv_api.c
+++ b/src/backend/storage/large_object/inv_api.c
@@ -676,8 +676,7 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
 			replace[Anum_pg_largeobject_data - 1] = true;
 			newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
 									   values, nulls, replace);
-			simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
-			CatalogIndexInsert(indstate, newtup);
+			CatalogTupleUpdate(lo_heap_r, &newtup->t_self, newtup);
 			heap_freetuple(newtup);
 
 			/*
@@ -719,8 +718,7 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
 			values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
 			values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
 			newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
-			simple_heap_insert(lo_heap_r, newtup);
-			CatalogIndexInsert(indstate, newtup);
+			CatalogTupleInsert(lo_heap_r, newtup);
 			heap_freetuple(newtup);
 		}
 		pageno++;
@@ -846,8 +844,7 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 		replace[Anum_pg_largeobject_data - 1] = true;
 		newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
 								   values, nulls, replace);
-		simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
-		CatalogIndexInsert(indstate, newtup);
+		CatalogTupleUpdate(lo_heap_r, &newtup->t_self, newtup);
 		heap_freetuple(newtup);
 	}
 	else
@@ -884,8 +881,7 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 		values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
 		values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
 		newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
-		simple_heap_insert(lo_heap_r, newtup);
-		CatalogIndexInsert(indstate, newtup);
+		CatalogTupleInsert(lo_heap_r, newtup);
 		heap_freetuple(newtup);
 	}
 
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index a7eabc7b9e9c..f5b1e08704f5 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -3301,8 +3301,7 @@ RelationSetNewRelfilenode(Relation relation, TransactionId freezeXid,
 		}
 		classform->relminmxid = minmulti;
 
-		simple_heap_update(pg_class, &tuple->t_self, tuple);
-		CatalogUpdateIndexes(pg_class, tuple);
+		CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
 	}
 
 	heap_freetuple(tuple);
diff --git a/src/backend/utils/cache/syscache.c b/src/backend/utils/cache/syscache.c
index e478581b51a2..154f21950793 100644
--- a/src/backend/utils/cache/syscache.c
+++ b/src/backend/utils/cache/syscache.c
@@ -100,9 +100,9 @@
 	(Adding an index requires a catversion.h update, while simply
 	adding/deleting caches only requires a recompile.)
 
-	Finally, any place your relation gets heap_insert() or
-	heap_update() calls, make sure there is a CatalogUpdateIndexes() or
-	similar call.  The heap_* calls do not update indexes.
+	Finally, any place your relation gets heap_insert() or heap_update()
+	calls, make sure there is a CatalogTupleInsert() or CatalogTupleUpdate()
+	or similar call.  The heap_* calls do not update indexes.
 
 	bjm 1999/11/22
 
diff --git a/src/backend/utils/gp/segadmin.c b/src/backend/utils/gp/segadmin.c
index 4cd7c4aaad7d..a6dc5927e1b4 100644
--- a/src/backend/utils/gp/segadmin.c
+++ b/src/backend/utils/gp/segadmin.c
@@ -271,8 +271,7 @@ add_segment_config(GpSegConfigEntry *i)
 	tuple = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
 	/* insert a new tuple */
-	simple_heap_insert(rel, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	CatalogTupleInsert(rel, tuple);
 
 	heap_close(rel, NoLock);
 }
@@ -750,8 +749,7 @@ segment_config_activate_standby(int16 standby_dbid, int16 master_dbid)
 	((Form_gp_segment_configuration) GETSTRUCT(tuple))->role = GP_SEGMENT_CONFIGURATION_ROLE_PRIMARY;
 	((Form_gp_segment_configuration) GETSTRUCT(tuple))->preferred_role = GP_SEGMENT_CONFIGURATION_ROLE_PRIMARY;
 
-	simple_heap_update(rel, &tuple->t_self, tuple);
-	CatalogUpdateIndexes(rel, tuple);
+	CatalogTupleUpdate(rel, &tuple->t_self, tuple);
 
 	systable_endscan(sscan);
 
diff --git a/src/include/catalog/indexing.h b/src/include/catalog/indexing.h
index 14ce00d90081..0635a15669cb 100644
--- a/src/include/catalog/indexing.h
+++ b/src/include/catalog/indexing.h
@@ -34,8 +34,11 @@ extern CatalogIndexState CatalogOpenIndexes(Relation heapRel);
 extern void CatalogCloseIndexes(CatalogIndexState indstate);
 extern void CatalogIndexInsert(CatalogIndexState indstate,
 				   HeapTuple heapTuple);
-extern void CatalogUpdateIndexes(Relation heapRel, HeapTuple heapTuple);
+extern Oid CatalogTupleInsert(Relation heapRel, HeapTuple tup);
+extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid,
+				   HeapTuple tup);
 
+extern void CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup);
 
 /*
  * These macros are just to keep the C compiler from spitting up on the

From 15bc16200ef413f245b05fdcc849ad6fbfb3a387 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 1 Feb 2017 16:13:30 -0500
Subject: [PATCH 07/22] Provide CatalogTupleDelete() as a wrapper around
 simple_heap_delete().

This extends the work done in commit 2f5c9d9c9 to provide a more nearly
complete abstraction layer hiding the details of index updating for catalog
changes.  That commit only invented abstractions for catalog inserts and
updates, leaving nearby code for catalog deletes still calling the
heap-level routines directly.  That seems rather ugly from here, and it
does little to help if we ever want to shift to a storage system in which
indexing work is needed at delete time.

Hence, create a wrapper function CatalogTupleDelete(), and replace calls
of simple_heap_delete() on catalog tuples with it.  There are now very
few direct calls of [simple_]heap_delete remaining in the tree.

This is backport of ab02896
This patch replaces simple_heap_delete to CatalogTupleDelete

Discussion: https://postgr.es/m/462.1485902736@sss.pgh.pa.us
---
 .../appendonly/appendonly_visimap_store.c     |  2 +-
 .../appendonly/appendonlyblockdirectory.c     |  2 +-
 src/backend/catalog/aclchk.c                  |  2 +-
 src/backend/catalog/dependency.c              |  2 +-
 src/backend/catalog/gp_fastsequence.c         |  2 +-
 src/backend/catalog/heap.c                    | 24 +++++++++----------
 src/backend/catalog/index.c                   |  2 +-
 src/backend/catalog/indexing.c                | 16 +++++++++++++
 src/backend/catalog/pg_collation.c            |  2 +-
 src/backend/catalog/pg_constraint.c           |  2 +-
 src/backend/catalog/pg_conversion.c           |  2 +-
 src/backend/catalog/pg_db_role_setting.c      |  6 ++---
 src/backend/catalog/pg_depend.c               |  6 ++---
 src/backend/catalog/pg_enum.c                 |  2 +-
 src/backend/catalog/pg_exttable.c             |  2 +-
 src/backend/catalog/pg_inherits.c             |  2 +-
 src/backend/catalog/pg_largeobject.c          |  4 ++--
 src/backend/catalog/pg_range.c                |  2 +-
 src/backend/catalog/pg_shdepend.c             |  6 ++---
 src/backend/cdb/cdbcat.c                      |  2 +-
 src/backend/cdb/cdbpartition.c                |  6 ++---
 src/backend/commands/comment.c                |  8 +++----
 src/backend/commands/dbcommands.c             |  2 +-
 src/backend/commands/event_trigger.c          |  2 +-
 src/backend/commands/extension.c              |  2 +-
 src/backend/commands/extprotocolcmds.c        |  2 +-
 src/backend/commands/foreigncmds.c            |  6 ++---
 src/backend/commands/functioncmds.c           |  6 ++---
 src/backend/commands/indexcmds.c              |  2 +-
 src/backend/commands/opclasscmds.c            |  8 +++----
 src/backend/commands/operatorcmds.c           |  2 +-
 src/backend/commands/proclang.c               |  2 +-
 src/backend/commands/schemacmds.c             |  2 +-
 src/backend/commands/seclabel.c               |  8 +++----
 src/backend/commands/tablecmds.c              |  4 ++--
 src/backend/commands/tablespace.c             |  2 +-
 src/backend/commands/trigger.c                |  2 +-
 src/backend/commands/tsearchcmds.c            | 14 +++++------
 src/backend/commands/typecmds.c               |  2 +-
 src/backend/commands/user.c                   | 12 +++++-----
 src/backend/rewrite/rewriteRemove.c           |  2 +-
 src/backend/storage/large_object/inv_api.c    |  4 ++--
 src/backend/utils/gp/segadmin.c               |  4 ++--
 src/include/catalog/indexing.h                |  1 +
 44 files changed, 106 insertions(+), 89 deletions(-)

diff --git a/src/backend/access/appendonly/appendonly_visimap_store.c b/src/backend/access/appendonly/appendonly_visimap_store.c
index e2027f653d03..02b6dc4f7cc3 100644
--- a/src/backend/access/appendonly/appendonly_visimap_store.c
+++ b/src/backend/access/appendonly/appendonly_visimap_store.c
@@ -331,7 +331,7 @@ AppendOnlyVisimapStore_DeleteSegmentFile(
 										  NULL,
 										  &tid))
 	{
-		simple_heap_delete(visiMapStore->visimapRelation,
+		CatalogTupleDelete(visiMapStore->visimapRelation,
 						   &tid);
 	}
 	AppendOnlyVisimapStore_EndScan(visiMapStore, indexScan);
diff --git a/src/backend/access/appendonly/appendonlyblockdirectory.c b/src/backend/access/appendonly/appendonlyblockdirectory.c
index 48f7961424ac..aa435f32c096 100644
--- a/src/backend/access/appendonly/appendonlyblockdirectory.c
+++ b/src/backend/access/appendonly/appendonlyblockdirectory.c
@@ -828,7 +828,7 @@ AppendOnlyBlockDirectory_DeleteSegmentFile(Relation aoRel,
 
 	while ((tuple = index_getnext(indexScan, ForwardScanDirection)) != NULL)
 	{
-		simple_heap_delete(blkdirRel,
+		CatalogTupleDelete(blkdirRel,
 						   &tuple->t_self);
 	}
 	index_endscan(indexScan);
diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c
index f322630269cd..6a3c8b20a4a1 100644
--- a/src/backend/catalog/aclchk.c
+++ b/src/backend/catalog/aclchk.c
@@ -1624,7 +1624,7 @@ RemoveDefaultACLById(Oid defaclOid)
 	if (!HeapTupleIsValid(tuple))
 		elog(ERROR, "could not find tuple for default ACL %u", defaclOid);
 
-	simple_heap_delete(rel, &tuple->t_self);
+	CatalogTupleDelete(rel, &tuple->t_self);
 
 	systable_endscan(scan);
 	heap_close(rel, RowExclusiveLock);
diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index bccfd7782989..397676e7e075 100644
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -1142,7 +1142,7 @@ deleteOneObject(const ObjectAddress *object, Relation *depRel, int flags)
 
 	while (HeapTupleIsValid(tup = systable_getnext(scan)))
 	{
-		simple_heap_delete(*depRel, &tup->t_self);
+		CatalogTupleDelete(*depRel, &tup->t_self);
 	}
 
 	systable_endscan(scan);
diff --git a/src/backend/catalog/gp_fastsequence.c b/src/backend/catalog/gp_fastsequence.c
index c029b35e6ee2..b6ef1954ffa8 100644
--- a/src/backend/catalog/gp_fastsequence.c
+++ b/src/backend/catalog/gp_fastsequence.c
@@ -326,7 +326,7 @@ RemoveFastSequenceEntry(Oid objid)
 
 	while ((tuple = systable_getnext(sscan)) != NULL)
 	{
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 	}
 
 	systable_endscan(sscan);
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 5b115d0d07af..d107f517f399 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -922,7 +922,7 @@ void MetaTrackDropObject(Oid		classid,
 	}
 
 	while (HeapTupleIsValid(tuple = systable_getnext(desc)))
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 
 	systable_endscan(desc);
 	heap_close(rel, RowExclusiveLock);
@@ -1931,7 +1931,7 @@ RelationRemoveInheritance(Oid relid)
 							  NULL, 1, &key);
 
 	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
-		simple_heap_delete(catalogRelation, &tuple->t_self);
+		CatalogTupleDelete(catalogRelation, &tuple->t_self);
 
 	systable_endscan(scan);
 	heap_close(catalogRelation, RowExclusiveLock);
@@ -1978,11 +1978,11 @@ RemovePartitioning(Oid relid)
 		rule_scan = systable_beginscan(pgrule, PartitionRuleParoidParparentruleParruleordIndexId, true,
 									   NULL, 1, &rule_key);
 		while (HeapTupleIsValid(rule_tuple = systable_getnext(rule_scan)))
-			simple_heap_delete(pgrule, &rule_tuple->t_self);
+			CatalogTupleDelete(pgrule, &rule_tuple->t_self);
 		systable_endscan(rule_scan);
 
 		/* remove ourself */
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 	}
 	systable_endscan(scan);
 	heap_close(rel, NoLock);
@@ -1997,7 +1997,7 @@ RemovePartitioning(Oid relid)
 	scan = systable_beginscan(pgrule, PartitionRuleParchildrelidIndexId, true,
 							  NULL, 1, &key);
 	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
-		simple_heap_delete(pgrule, &tuple->t_self);
+		CatalogTupleDelete(pgrule, &tuple->t_self);
 	systable_endscan(scan);
 	heap_close(pgrule, NoLock);
 
@@ -2026,7 +2026,7 @@ DeleteRelationTuple(Oid relid)
 		elog(ERROR, "cache lookup failed for relation %u", relid);
 
 	/* delete the relation tuple from pg_class, and finish up */
-	simple_heap_delete(pg_class_desc, &tup->t_self);
+	CatalogTupleDelete(pg_class_desc, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -2063,7 +2063,7 @@ DeleteAttributeTuples(Oid relid)
 
 	/* Delete all the matching tuples */
 	while ((atttup = systable_getnext(scan)) != NULL)
-		simple_heap_delete(attrel, &atttup->t_self);
+		CatalogTupleDelete(attrel, &atttup->t_self);
 
 	/* Clean up after the scan */
 	systable_endscan(scan);
@@ -2104,7 +2104,7 @@ DeleteSystemAttributeTuples(Oid relid)
 
 	/* Delete all the matching tuples */
 	while ((atttup = systable_getnext(scan)) != NULL)
-		simple_heap_delete(attrel, &atttup->t_self);
+		CatalogTupleDelete(attrel, &atttup->t_self);
 
 	/* Clean up after the scan */
 	systable_endscan(scan);
@@ -2151,7 +2151,7 @@ RemoveAttributeById(Oid relid, AttrNumber attnum)
 	{
 		/* System attribute (probably OID) ... just delete the row */
 
-		simple_heap_delete(attr_rel, &tuple->t_self);
+		CatalogTupleDelete(attr_rel, &tuple->t_self);
 	}
 	else
 	{
@@ -2331,7 +2331,7 @@ RemoveAttrDefaultById(Oid attrdefId)
 	myrel = relation_open(myrelid, AccessExclusiveLock);
 
 	/* Now we can delete the pg_attrdef row */
-	simple_heap_delete(attrdef_rel, &tuple->t_self);
+	CatalogTupleDelete(attrdef_rel, &tuple->t_self);
 
 	systable_endscan(scan);
 	heap_close(attrdef_rel, RowExclusiveLock);
@@ -2416,7 +2416,7 @@ heap_drop_with_catalog(Oid relid)
 		if (!HeapTupleIsValid(tuple))
 			elog(ERROR, "cache lookup failed for foreign table %u", relid);
 
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 
 		ReleaseSysCache(tuple);
 		heap_close(rel, RowExclusiveLock);
@@ -3359,7 +3359,7 @@ RemoveStatistics(Oid relid, AttrNumber attnum)
 
 	/* we must loop even when attnum != 0, in case of inherited stats */
 	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
-		simple_heap_delete(pgstatistic, &tuple->t_self);
+		CatalogTupleDelete(pgstatistic, &tuple->t_self);
 
 	systable_endscan(scan);
 
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 923b0c4362a4..1abe2a533672 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1740,7 +1740,7 @@ index_drop(Oid indexId, bool concurrent)
 
 	hasexprs = !heap_attisnull(tuple, Anum_pg_index_indexprs);
 
-	simple_heap_delete(indexRelation, &tuple->t_self);
+	CatalogTupleDelete(indexRelation, &tuple->t_self);
 
 	ReleaseSysCache(tuple);
 	heap_close(indexRelation, RowExclusiveLock);
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index ee09fc6d62be..dc992e4e1fc9 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -210,6 +210,22 @@ CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
 	CatalogCloseIndexes(indstate);
 }
 
+/*
+ * CatalogTupleDelete - do heap and indexing work for deleting a catalog tuple
+ *
+ * Delete the tuple identified by tid in the specified catalog.
+ *
+ * With Postgres heaps, there is no index work to do at deletion time;
+ * cleanup will be done later by VACUUM.  However, callers of this function
+ * shouldn't have to know that; we'd like a uniform abstraction for all
+ * catalog tuple changes.  Hence, provide this currently-trivial wrapper.
+ */
+void
+CatalogTupleDelete(Relation heapRel, ItemPointer tid)
+{
+	simple_heap_delete(heapRel, tid);
+}
+
 /*
  * Greenplum: this interface is used to insert tuples into gp_fastsequence
  * and aoseg relations during an appendoptimized (row as well as column)
diff --git a/src/backend/catalog/pg_collation.c b/src/backend/catalog/pg_collation.c
index 0c03fe6c5bf3..ceddd90fe21c 100644
--- a/src/backend/catalog/pg_collation.c
+++ b/src/backend/catalog/pg_collation.c
@@ -238,7 +238,7 @@ RemoveCollationById(Oid collationOid)
 	tuple = systable_getnext(scandesc);
 
 	if (HeapTupleIsValid(tuple))
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 	else
 		elog(ERROR, "could not find tuple for collation %u", collationOid);
 
diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c
index 9dbfb74a777a..45020d692432 100644
--- a/src/backend/catalog/pg_constraint.c
+++ b/src/backend/catalog/pg_constraint.c
@@ -603,7 +603,7 @@ RemoveConstraintById(Oid conId)
 		elog(ERROR, "constraint %u is not of a known type", conId);
 
 	/* Fry the constraint itself */
-	simple_heap_delete(conDesc, &tup->t_self);
+	CatalogTupleDelete(conDesc, &tup->t_self);
 
 	/* Clean up */
 	ReleaseSysCache(tup);
diff --git a/src/backend/catalog/pg_conversion.c b/src/backend/catalog/pg_conversion.c
index 93f826614c68..43cce31b6dec 100644
--- a/src/backend/catalog/pg_conversion.c
+++ b/src/backend/catalog/pg_conversion.c
@@ -167,7 +167,7 @@ RemoveConversionById(Oid conversionOid)
 
 	/* search for the target tuple */
 	if (HeapTupleIsValid(tuple = heap_getnext(scan, ForwardScanDirection)))
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 	else
 		elog(ERROR, "could not find tuple for conversion %u", conversionOid);
 	heap_endscan(scan);
diff --git a/src/backend/catalog/pg_db_role_setting.c b/src/backend/catalog/pg_db_role_setting.c
index 22342cf38fcd..c0c619e75fe8 100644
--- a/src/backend/catalog/pg_db_role_setting.c
+++ b/src/backend/catalog/pg_db_role_setting.c
@@ -99,7 +99,7 @@ AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt)
 				CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
 			}
 			else
-				simple_heap_delete(rel, &tuple->t_self);
+				CatalogTupleDelete(rel, &tuple->t_self);
 		}
 	}
 	else if (HeapTupleIsValid(tuple))
@@ -137,7 +137,7 @@ AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt)
 			CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
 		}
 		else
-			simple_heap_delete(rel, &tuple->t_self);
+			CatalogTupleDelete(rel, &tuple->t_self);
 	}
 	else if (valuestr)
 	{
@@ -319,7 +319,7 @@ DropSetting(Oid databaseid, Oid roleid)
 	scan = heap_beginscan_catalog(relsetting, numkeys, keys);
 	while (HeapTupleIsValid(tup = heap_getnext(scan, ForwardScanDirection)))
 	{
-		simple_heap_delete(relsetting, &tup->t_self);
+		CatalogTupleDelete(relsetting, &tup->t_self);
 	}
 	heap_endscan(scan);
 
diff --git a/src/backend/catalog/pg_depend.c b/src/backend/catalog/pg_depend.c
index 18e5f4d354ca..50452fe7897d 100644
--- a/src/backend/catalog/pg_depend.c
+++ b/src/backend/catalog/pg_depend.c
@@ -283,7 +283,7 @@ deleteDependencyRecordsFor(Oid classId, Oid objectId,
 		  ((Form_pg_depend) GETSTRUCT(tup))->deptype == DEPENDENCY_EXTENSION)
 			continue;
 
-		simple_heap_delete(depRel, &tup->t_self);
+		CatalogTupleDelete(depRel, &tup->t_self);
 		count++;
 	}
 
@@ -333,7 +333,7 @@ deleteDependencyRecordsForClass(Oid classId, Oid objectId,
 
 		if (depform->refclassid == refclassId && depform->deptype == deptype)
 		{
-			simple_heap_delete(depRel, &tup->t_self);
+			CatalogTupleDelete(depRel, &tup->t_self);
 			count++;
 		}
 	}
@@ -417,7 +417,7 @@ changeDependencyFor(Oid classId, Oid objectId,
 			depform->refobjid == oldRefObjectId)
 		{
 			if (newIsPinned)
-				simple_heap_delete(depRel, &tup->t_self);
+				CatalogTupleDelete(depRel, &tup->t_self);
 			else
 			{
 				/* make a modifiable copy */
diff --git a/src/backend/catalog/pg_enum.c b/src/backend/catalog/pg_enum.c
index d5ea7a05bdd0..9342a18aa3db 100644
--- a/src/backend/catalog/pg_enum.c
+++ b/src/backend/catalog/pg_enum.c
@@ -167,7 +167,7 @@ EnumValuesDelete(Oid enumTypeOid)
 
 	while (HeapTupleIsValid(tup = systable_getnext(scan)))
 	{
-		simple_heap_delete(pg_enum, &tup->t_self);
+		CatalogTupleDelete(pg_enum, &tup->t_self);
 	}
 
 	systable_endscan(scan);
diff --git a/src/backend/catalog/pg_exttable.c b/src/backend/catalog/pg_exttable.c
index ad44df8f1b4e..d8ca398db103 100644
--- a/src/backend/catalog/pg_exttable.c
+++ b/src/backend/catalog/pg_exttable.c
@@ -500,7 +500,7 @@ RemoveExtTableEntry(Oid relid)
 	 */
 	do
 	{
-		simple_heap_delete(pg_exttable_rel, &tuple->t_self);
+		CatalogTupleDelete(pg_exttable_rel, &tuple->t_self);
 	}
 	while (HeapTupleIsValid(tuple = systable_getnext(scan)));
 
diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index 1923bf4add08..3c7bad84d041 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -479,7 +479,7 @@ DeleteInheritsTuple(Oid inhrelid, Oid inhparent)
 		parent = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhparent;
 		if (!OidIsValid(inhparent) || parent == inhparent)
 		{
-			simple_heap_delete(catalogRelation, &inheritsTuple->t_self);
+			CatalogTupleDelete(catalogRelation, &inheritsTuple->t_self);
 			found = true;
 		}
 	}
diff --git a/src/backend/catalog/pg_largeobject.c b/src/backend/catalog/pg_largeobject.c
index 74b25904d954..1552f448e2e9 100644
--- a/src/backend/catalog/pg_largeobject.c
+++ b/src/backend/catalog/pg_largeobject.c
@@ -110,7 +110,7 @@ LargeObjectDrop(Oid loid)
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("large object %u does not exist", loid)));
 
-	simple_heap_delete(pg_lo_meta, &tuple->t_self);
+	CatalogTupleDelete(pg_lo_meta, &tuple->t_self);
 
 	systable_endscan(scan);
 
@@ -127,7 +127,7 @@ LargeObjectDrop(Oid loid)
 							  NULL, 1, skey);
 	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
 	{
-		simple_heap_delete(pg_largeobject, &tuple->t_self);
+		CatalogTupleDelete(pg_largeobject, &tuple->t_self);
 	}
 
 	systable_endscan(scan);
diff --git a/src/backend/catalog/pg_range.c b/src/backend/catalog/pg_range.c
index c1fdf7857a60..24ba7eee1b55 100644
--- a/src/backend/catalog/pg_range.c
+++ b/src/backend/catalog/pg_range.c
@@ -129,7 +129,7 @@ RangeDelete(Oid rangeTypeOid)
 
 	while (HeapTupleIsValid(tup = systable_getnext(scan)))
 	{
-		simple_heap_delete(pg_range, &tup->t_self);
+		CatalogTupleDelete(pg_range, &tup->t_self);
 	}
 
 	systable_endscan(scan);
diff --git a/src/backend/catalog/pg_shdepend.c b/src/backend/catalog/pg_shdepend.c
index 7ae665f1ff10..b2d9159e9d2d 100644
--- a/src/backend/catalog/pg_shdepend.c
+++ b/src/backend/catalog/pg_shdepend.c
@@ -245,7 +245,7 @@ shdepChangeDep(Relation sdepRel,
 	{
 		/* No new entry needed, so just delete existing entry if any */
 		if (oldtup)
-			simple_heap_delete(sdepRel, &oldtup->t_self);
+			CatalogTupleDelete(sdepRel, &oldtup->t_self);
 	}
 	else if (oldtup)
 	{
@@ -791,7 +791,7 @@ dropDatabaseDependencies(Oid databaseId)
 
 	while (HeapTupleIsValid(tup = systable_getnext(scan)))
 	{
-		simple_heap_delete(sdepRel, &tup->t_self);
+		CatalogTupleDelete(sdepRel, &tup->t_self);
 	}
 
 	systable_endscan(scan);
@@ -944,7 +944,7 @@ shdepDropDependency(Relation sdepRel,
 			continue;
 
 		/* OK, delete it */
-		simple_heap_delete(sdepRel, &tup->t_self);
+		CatalogTupleDelete(sdepRel, &tup->t_self);
 	}
 
 	systable_endscan(scan);
diff --git a/src/backend/cdb/cdbcat.c b/src/backend/cdb/cdbcat.c
index 49bc39450d70..0101620a4bcd 100644
--- a/src/backend/cdb/cdbcat.c
+++ b/src/backend/cdb/cdbcat.c
@@ -731,7 +731,7 @@ GpPolicyRemove(Oid tbloid)
 
 	while ((tuple = systable_getnext(sscan)) != NULL)
 	{
-		simple_heap_delete(gp_policy_rel, &tuple->t_self);
+		CatalogTupleDelete(gp_policy_rel, &tuple->t_self);
 	}
 
 	systable_endscan(sscan);
diff --git a/src/backend/cdb/cdbpartition.c b/src/backend/cdb/cdbpartition.c
index 84b383c08fc6..732d21bef675 100644
--- a/src/backend/cdb/cdbpartition.c
+++ b/src/backend/cdb/cdbpartition.c
@@ -1897,7 +1897,7 @@ del_part_template(Oid rootrelid, int16 parlevel, Oid parent)
 		return 2;
 	}
 
-	simple_heap_delete(part_rel, &tid);
+	CatalogTupleDelete(part_rel, &tid);
 
 	systable_endscan(sscan);
 
@@ -1916,7 +1916,7 @@ del_part_template(Oid rootrelid, int16 parlevel, Oid parent)
 
 	while ((tuple = systable_getnext(sscan)) != NULL)
 	{
-		simple_heap_delete(part_rule_rel, &tuple->t_self);
+		CatalogTupleDelete(part_rule_rel, &tuple->t_self);
 	}
 
 	systable_endscan(sscan);
@@ -8713,7 +8713,7 @@ remove_partition_encoding_entry(Oid paroid, AttrNumber attnum)
 			if (ppe->parencattnum != attnum)
 				continue;
 		}
-		simple_heap_delete(rel, &tup->t_self);
+		CatalogTupleDelete(rel, &tup->t_self);
 	}
 
 	systable_endscan(sscan);
diff --git a/src/backend/commands/comment.c b/src/backend/commands/comment.c
index a86a0b23562f..013476c4de7e 100644
--- a/src/backend/commands/comment.c
+++ b/src/backend/commands/comment.c
@@ -220,7 +220,7 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
 		/* Found the old tuple, so delete or update it */
 
 		if (comment == NULL)
-			simple_heap_delete(description, &oldtuple->t_self);
+			CatalogTupleDelete(description, &oldtuple->t_self);
 		else
 		{
 			newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(description), values,
@@ -310,7 +310,7 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
 		/* Found the old tuple, so delete or update it */
 
 		if (comment == NULL)
-			simple_heap_delete(shdescription, &oldtuple->t_self);
+			CatalogTupleDelete(shdescription, &oldtuple->t_self);
 		else
 		{
 			newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(shdescription),
@@ -384,7 +384,7 @@ DeleteComments(Oid oid, Oid classoid, int32 subid)
 							NULL, nkeys, skey);
 
 	while ((oldtuple = systable_getnext(sd)) != NULL)
-		simple_heap_delete(description, &oldtuple->t_self);
+		CatalogTupleDelete(description, &oldtuple->t_self);
 
 	/* Done */
 
@@ -420,7 +420,7 @@ DeleteSharedComments(Oid oid, Oid classoid)
 							NULL, 2, skey);
 
 	while ((oldtuple = systable_getnext(sd)) != NULL)
-		simple_heap_delete(shdescription, &oldtuple->t_self);
+		CatalogTupleDelete(shdescription, &oldtuple->t_self);
 
 	/* Done */
 
diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index 191df48a3764..92b4681bd851 100644
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -962,7 +962,7 @@ dropdb(const char *dbname, bool missing_ok)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "cache lookup failed for database %u", db_id);
 
-	simple_heap_delete(pgdbrel, &tup->t_self);
+	CatalogTupleDelete(pgdbrel, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 1e4caf2fd041..6f64d1ef277c 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -412,7 +412,7 @@ RemoveEventTriggerById(Oid trigOid)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "cache lookup failed for event trigger %u", trigOid);
 
-	simple_heap_delete(tgrel, &tup->t_self);
+	CatalogTupleDelete(tgrel, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
diff --git a/src/backend/commands/extension.c b/src/backend/commands/extension.c
index f284ef65b78b..a8a2a6952776 100644
--- a/src/backend/commands/extension.c
+++ b/src/backend/commands/extension.c
@@ -1736,7 +1736,7 @@ RemoveExtensionById(Oid extId)
 
 	/* We assume that there can be at most one matching tuple */
 	if (HeapTupleIsValid(tuple))
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 
 	systable_endscan(scandesc);
 
diff --git a/src/backend/commands/extprotocolcmds.c b/src/backend/commands/extprotocolcmds.c
index d966f8aacba9..cb7794a13ab4 100644
--- a/src/backend/commands/extprotocolcmds.c
+++ b/src/backend/commands/extprotocolcmds.c
@@ -139,7 +139,7 @@ RemoveExtProtocolById(Oid protOid)
 
 	while (HeapTupleIsValid(tup = systable_getnext(scan)))
 	{
-		simple_heap_delete(rel, &tup->t_self);
+		CatalogTupleDelete(rel, &tup->t_self);
 		found = true;
 	}
 	systable_endscan(scan);
diff --git a/src/backend/commands/foreigncmds.c b/src/backend/commands/foreigncmds.c
index fc9fa0388a98..5206e80353d3 100644
--- a/src/backend/commands/foreigncmds.c
+++ b/src/backend/commands/foreigncmds.c
@@ -874,7 +874,7 @@ RemoveForeignDataWrapperById(Oid fdwId)
 	if (!HeapTupleIsValid(tp))
 		elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwId);
 
-	simple_heap_delete(rel, &tp->t_self);
+	CatalogTupleDelete(rel, &tp->t_self);
 
 	ReleaseSysCache(tp);
 
@@ -1121,7 +1121,7 @@ RemoveForeignServerById(Oid srvId)
 	if (!HeapTupleIsValid(tp))
 		elog(ERROR, "cache lookup failed for foreign server %u", srvId);
 
-	simple_heap_delete(rel, &tp->t_self);
+	CatalogTupleDelete(rel, &tp->t_self);
 
 	ReleaseSysCache(tp);
 
@@ -1452,7 +1452,7 @@ RemoveUserMappingById(Oid umId)
 	if (!HeapTupleIsValid(tp))
 		elog(ERROR, "cache lookup failed for user mapping %u", umId);
 
-	simple_heap_delete(rel, &tp->t_self);
+	CatalogTupleDelete(rel, &tp->t_self);
 
 	ReleaseSysCache(tp);
 
diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
index ab2de0bd09d2..02f2481d5935 100644
--- a/src/backend/commands/functioncmds.c
+++ b/src/backend/commands/functioncmds.c
@@ -1425,7 +1425,7 @@ RemoveFunctionById(Oid funcOid)
 
 	isagg = ((Form_pg_proc) GETSTRUCT(tup))->proisagg;
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -1445,7 +1445,7 @@ RemoveFunctionById(Oid funcOid)
 		if (!HeapTupleIsValid(tup))		/* should not happen */
 			elog(ERROR, "cache lookup failed for pg_aggregate tuple for function %u", funcOid);
 
-		simple_heap_delete(relation, &tup->t_self);
+		CatalogTupleDelete(relation, &tup->t_self);
 
 		ReleaseSysCache(tup);
 
@@ -2129,7 +2129,7 @@ DropCastById(Oid castOid)
 	tuple = systable_getnext(scan);
 	if (!HeapTupleIsValid(tuple))
 		elog(ERROR, "could not find tuple for cast %u", castOid);
-	simple_heap_delete(relation, &tuple->t_self);
+	CatalogTupleDelete(relation, &tuple->t_self);
 
 	systable_endscan(scan);
 	heap_close(relation, RowExclusiveLock);
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index ec65e61eccb4..b2adc732b5d4 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -2764,7 +2764,7 @@ IndexSetParentIndex(Relation partitionIdx, Oid parentOid)
 			/*
 			 * There exists a pg_inherits row, which we want to clear; do so.
 			 */
-			simple_heap_delete(pg_inherits, &tuple->t_self);
+			CatalogTupleDelete(pg_inherits, &tuple->t_self);
 			fix_dependencies = true;
 		}
 		else
diff --git a/src/backend/commands/opclasscmds.c b/src/backend/commands/opclasscmds.c
index 4ec226f18caf..b8994986d8e7 100644
--- a/src/backend/commands/opclasscmds.c
+++ b/src/backend/commands/opclasscmds.c
@@ -1612,7 +1612,7 @@ RemoveOpFamilyById(Oid opfamilyOid)
 	if (!HeapTupleIsValid(tup)) /* should not happen */
 		elog(ERROR, "cache lookup failed for opfamily %u", opfamilyOid);
 
-	simple_heap_delete(rel, &tup->t_self);
+	CatalogTupleDelete(rel, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -1631,7 +1631,7 @@ RemoveOpClassById(Oid opclassOid)
 	if (!HeapTupleIsValid(tup)) /* should not happen */
 		elog(ERROR, "cache lookup failed for opclass %u", opclassOid);
 
-	simple_heap_delete(rel, &tup->t_self);
+	CatalogTupleDelete(rel, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -1661,7 +1661,7 @@ RemoveAmOpEntryById(Oid entryOid)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "could not find tuple for amop entry %u", entryOid);
 
-	simple_heap_delete(rel, &tup->t_self);
+	CatalogTupleDelete(rel, &tup->t_self);
 
 	systable_endscan(scan);
 	heap_close(rel, RowExclusiveLock);
@@ -1690,7 +1690,7 @@ RemoveAmProcEntryById(Oid entryOid)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "could not find tuple for amproc entry %u", entryOid);
 
-	simple_heap_delete(rel, &tup->t_self);
+	CatalogTupleDelete(rel, &tup->t_self);
 
 	systable_endscan(scan);
 	heap_close(rel, RowExclusiveLock);
diff --git a/src/backend/commands/operatorcmds.c b/src/backend/commands/operatorcmds.c
index 9c40b1212126..d068876b7c00 100644
--- a/src/backend/commands/operatorcmds.c
+++ b/src/backend/commands/operatorcmds.c
@@ -347,7 +347,7 @@ RemoveOperatorById(Oid operOid)
 	if (!HeapTupleIsValid(tup)) /* should not happen */
 		elog(ERROR, "cache lookup failed for operator %u", operOid);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
diff --git a/src/backend/commands/proclang.c b/src/backend/commands/proclang.c
index 2add1fd829a5..5f1a48277f20 100644
--- a/src/backend/commands/proclang.c
+++ b/src/backend/commands/proclang.c
@@ -562,7 +562,7 @@ DropProceduralLanguageById(Oid langOid)
 	if (!HeapTupleIsValid(langTup))		/* should not happen */
 		elog(ERROR, "cache lookup failed for language %u", langOid);
 
-	simple_heap_delete(rel, &langTup->t_self);
+	CatalogTupleDelete(rel, &langTup->t_self);
 
 	ReleaseSysCache(langTup);
 
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index b890adea6f87..ddd723b84881 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -277,7 +277,7 @@ RemoveSchemaById(Oid schemaOid)
 	if (!HeapTupleIsValid(tup)) /* should not happen */
 		elog(ERROR, "cache lookup failed for namespace %u", schemaOid);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
diff --git a/src/backend/commands/seclabel.c b/src/backend/commands/seclabel.c
index 0805b57ecc4f..7bf6bf540bd6 100644
--- a/src/backend/commands/seclabel.c
+++ b/src/backend/commands/seclabel.c
@@ -290,7 +290,7 @@ SetSharedSecurityLabel(const ObjectAddress *object,
 	if (HeapTupleIsValid(oldtup))
 	{
 		if (label == NULL)
-			simple_heap_delete(pg_shseclabel, &oldtup->t_self);
+			CatalogTupleDelete(pg_shseclabel, &oldtup->t_self);
 		else
 		{
 			replaces[Anum_pg_shseclabel_label - 1] = true;
@@ -377,7 +377,7 @@ SetSecurityLabel(const ObjectAddress *object,
 	if (HeapTupleIsValid(oldtup))
 	{
 		if (label == NULL)
-			simple_heap_delete(pg_seclabel, &oldtup->t_self);
+			CatalogTupleDelete(pg_seclabel, &oldtup->t_self);
 		else
 		{
 			replaces[Anum_pg_seclabel_label - 1] = true;
@@ -429,7 +429,7 @@ DeleteSharedSecurityLabel(Oid objectId, Oid classId)
 	scan = systable_beginscan(pg_shseclabel, SharedSecLabelObjectIndexId, true,
 							  NULL, 2, skey);
 	while (HeapTupleIsValid(oldtup = systable_getnext(scan)))
-		simple_heap_delete(pg_shseclabel, &oldtup->t_self);
+		CatalogTupleDelete(pg_shseclabel, &oldtup->t_self);
 	systable_endscan(scan);
 
 	heap_close(pg_shseclabel, RowExclusiveLock);
@@ -480,7 +480,7 @@ DeleteSecurityLabel(const ObjectAddress *object)
 	scan = systable_beginscan(pg_seclabel, SecLabelObjectIndexId, true,
 							  NULL, nkeys, skey);
 	while (HeapTupleIsValid(oldtup = systable_getnext(scan)))
-		simple_heap_delete(pg_seclabel, &oldtup->t_self);
+		CatalogTupleDelete(pg_seclabel, &oldtup->t_self);
 	systable_endscan(scan);
 
 	heap_close(pg_seclabel, RowExclusiveLock);
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 5f4172c4cbe8..a7150aa0fa5f 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -11519,7 +11519,7 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 			  foundDep->refobjid == attTup->attcollation))
 			elog(ERROR, "found unexpected dependency for column");
 
-		simple_heap_delete(depRel, &depTup->t_self);
+		CatalogTupleDelete(depRel, &depTup->t_self);
 	}
 
 	systable_endscan(scan);
@@ -14382,7 +14382,7 @@ drop_parent_dependency(Oid relid, Oid refclassid, Oid refobjid, bool is_partitio
 			((dep->deptype == DEPENDENCY_NORMAL && !is_partition) ||
 			 (dep->deptype == DEPENDENCY_AUTO && is_partition)))
 		{
-			simple_heap_delete(catalogRelation, &depTuple->t_self);
+			CatalogTupleDelete(catalogRelation, &depTuple->t_self);
 		}
 	}
 
diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c
index 053d4cdbd7d3..62c57689ab92 100644
--- a/src/backend/commands/tablespace.c
+++ b/src/backend/commands/tablespace.c
@@ -626,7 +626,7 @@ DropTableSpace(DropTableSpaceStmt *stmt)
 	/*
 	 * Remove the pg_tablespace tuple (this will roll back if we fail below)
 	 */
-	simple_heap_delete(rel, &tuple->t_self);
+	CatalogTupleDelete(rel, &tuple->t_self);
 
 	heap_endscan(scandesc);
 
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 1b360fd8732f..ee94da5851e3 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -1167,7 +1167,7 @@ RemoveTriggerById(Oid trigOid)
 	/*
 	 * Delete the pg_trigger tuple.
 	 */
-	simple_heap_delete(tgrel, &tup->t_self);
+	CatalogTupleDelete(tgrel, &tup->t_self);
 
 	systable_endscan(tgscan);
 	heap_close(tgrel, RowExclusiveLock);
diff --git a/src/backend/commands/tsearchcmds.c b/src/backend/commands/tsearchcmds.c
index 6005f6e1377b..c5da0683d593 100644
--- a/src/backend/commands/tsearchcmds.c
+++ b/src/backend/commands/tsearchcmds.c
@@ -316,7 +316,7 @@ RemoveTSParserById(Oid prsId)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "cache lookup failed for text search parser %u", prsId);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -537,7 +537,7 @@ RemoveTSDictionaryById(Oid dictId)
 		elog(ERROR, "cache lookup failed for text search dictionary %u",
 			 dictId);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -875,7 +875,7 @@ RemoveTSTemplateById(Oid tmplId)
 		elog(ERROR, "cache lookup failed for text search template %u",
 			 tmplId);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -1188,7 +1188,7 @@ RemoveTSConfigurationById(Oid cfgId)
 		elog(ERROR, "cache lookup failed for text search dictionary %u",
 			 cfgId);
 
-	simple_heap_delete(relCfg, &tup->t_self);
+	CatalogTupleDelete(relCfg, &tup->t_self);
 
 	ReleaseSysCache(tup);
 
@@ -1207,7 +1207,7 @@ RemoveTSConfigurationById(Oid cfgId)
 
 	while (HeapTupleIsValid((tup = systable_getnext(scan))))
 	{
-		simple_heap_delete(relMap, &tup->t_self);
+		CatalogTupleDelete(relMap, &tup->t_self);
 	}
 
 	systable_endscan(scan);
@@ -1371,7 +1371,7 @@ MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
 
 			while (HeapTupleIsValid((maptup = systable_getnext(scan))))
 			{
-				simple_heap_delete(relMap, &maptup->t_self);
+				CatalogTupleDelete(relMap, &maptup->t_self);
 			}
 
 			systable_endscan(scan);
@@ -1524,7 +1524,7 @@ DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
 
 		while (HeapTupleIsValid((maptup = systable_getnext(scan))))
 		{
-			simple_heap_delete(relMap, &maptup->t_self);
+			CatalogTupleDelete(relMap, &maptup->t_self);
 			found = true;
 		}
 
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 7dd718b292bb..e817670563e9 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -736,7 +736,7 @@ RemoveTypeById(Oid typeOid)
 	if (!HeapTupleIsValid(tup))
 		elog(ERROR, "cache lookup failed for type %u", typeOid);
 
-	simple_heap_delete(relation, &tup->t_self);
+	CatalogTupleDelete(relation, &tup->t_self);
 
 	/*
 	 * If it is an enum, delete the pg_enum entries too; we don't bother with
diff --git a/src/backend/commands/user.c b/src/backend/commands/user.c
index e646762d3191..9857c711f6da 100644
--- a/src/backend/commands/user.c
+++ b/src/backend/commands/user.c
@@ -1557,7 +1557,7 @@ DropRole(DropRoleStmt *stmt)
 		/*
 		 * Remove the role from the pg_authid table
 		 */
-		simple_heap_delete(pg_authid_rel, &tuple->t_self);
+		CatalogTupleDelete(pg_authid_rel, &tuple->t_self);
 
 		ReleaseSysCache(tuple);
 
@@ -1577,7 +1577,7 @@ DropRole(DropRoleStmt *stmt)
 
 		while (HeapTupleIsValid(tmp_tuple = systable_getnext(sscan)))
 		{
-			simple_heap_delete(pg_auth_members_rel, &tmp_tuple->t_self);
+			CatalogTupleDelete(pg_auth_members_rel, &tmp_tuple->t_self);
 		}
 
 		systable_endscan(sscan);
@@ -1592,7 +1592,7 @@ DropRole(DropRoleStmt *stmt)
 
 		while (HeapTupleIsValid(tmp_tuple = systable_getnext(sscan)))
 		{
-			simple_heap_delete(pg_auth_members_rel, &tmp_tuple->t_self);
+			CatalogTupleDelete(pg_auth_members_rel, &tmp_tuple->t_self);
 		}
 
 		systable_endscan(sscan);
@@ -2460,7 +2460,7 @@ DelRoleMems(const char *rolename, Oid roleid,
 		if (!admin_opt)
 		{
 			/* Remove the entry altogether */
-			simple_heap_delete(pg_authmem_rel, &authmem_tuple->t_self);
+			CatalogTupleDelete(pg_authmem_rel, &authmem_tuple->t_self);
 		}
 		else
 		{
@@ -2671,14 +2671,14 @@ DelRoleDenials(const char *rolename, Oid roleid, List *dropintervals)
 										DatumGetCString(DirectFunctionCall1(time_out, TimeADTGetDatum(existing->start.time))),
 										daysofweek[existing->end.day],
 										DatumGetCString(DirectFunctionCall1(time_out, TimeADTGetDatum(existing->end.time))))));
-					simple_heap_delete(pg_auth_time_rel, &tmp_tuple->t_self);
+					CatalogTupleDelete(pg_auth_time_rel, &tmp_tuple->t_self);
 					dropped_matching_interval = true;
 					break;
 				}
 			}
 		}
 		else
-			simple_heap_delete(pg_auth_time_rel, &tmp_tuple->t_self);
+			CatalogTupleDelete(pg_auth_time_rel, &tmp_tuple->t_self);
 	}
 
 	/* if intervals were specified and none was found, raise error */
diff --git a/src/backend/rewrite/rewriteRemove.c b/src/backend/rewrite/rewriteRemove.c
index a3ef6158ae8b..2bb45be17900 100644
--- a/src/backend/rewrite/rewriteRemove.c
+++ b/src/backend/rewrite/rewriteRemove.c
@@ -76,7 +76,7 @@ RemoveRewriteRuleById(Oid ruleOid)
 	/*
 	 * Now delete the pg_rewrite tuple for the rule
 	 */
-	simple_heap_delete(RewriteRelation, &tuple->t_self);
+	CatalogTupleDelete(RewriteRelation, &tuple->t_self);
 
 	systable_endscan(rcscan);
 
diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c
index 3fb40ffbd9c4..5ad64ee95ada 100644
--- a/src/backend/storage/large_object/inv_api.c
+++ b/src/backend/storage/large_object/inv_api.c
@@ -857,7 +857,7 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 		if (olddata != NULL)
 		{
 			Assert(olddata->pageno > pageno);
-			simple_heap_delete(lo_heap_r, &oldtuple->t_self);
+			CatalogTupleDelete(lo_heap_r, &oldtuple->t_self);
 		}
 
 		/*
@@ -893,7 +893,7 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 	{
 		while ((oldtuple = systable_getnext_ordered(sd, ForwardScanDirection)) != NULL)
 		{
-			simple_heap_delete(lo_heap_r, &oldtuple->t_self);
+			CatalogTupleDelete(lo_heap_r, &oldtuple->t_self);
 		}
 	}
 
diff --git a/src/backend/utils/gp/segadmin.c b/src/backend/utils/gp/segadmin.c
index a6dc5927e1b4..5c147b52e0c7 100644
--- a/src/backend/utils/gp/segadmin.c
+++ b/src/backend/utils/gp/segadmin.c
@@ -309,7 +309,7 @@ remove_segment_config(int16 dbid)
 							   NULL, 1, &scankey);
 	while ((tuple = systable_getnext(sscan)) != NULL)
 	{
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 		numDel++;
 	}
 	systable_endscan(sscan);
@@ -723,7 +723,7 @@ segment_config_activate_standby(int16 standby_dbid, int16 master_dbid)
 							   NULL, 1, &scankey);
 	while ((tuple = systable_getnext(sscan)) != NULL)
 	{
-		simple_heap_delete(rel, &tuple->t_self);
+		CatalogTupleDelete(rel, &tuple->t_self);
 		numDel++;
 	}
 	systable_endscan(sscan);
diff --git a/src/include/catalog/indexing.h b/src/include/catalog/indexing.h
index 0635a15669cb..7eb8d55bbee3 100644
--- a/src/include/catalog/indexing.h
+++ b/src/include/catalog/indexing.h
@@ -37,6 +37,7 @@ extern void CatalogIndexInsert(CatalogIndexState indstate,
 extern Oid CatalogTupleInsert(Relation heapRel, HeapTuple tup);
 extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid,
 				   HeapTuple tup);
+extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid);
 
 extern void CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup);
 

From 74f3375140202ac81285da70fd757a1f2bb2d849 Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Wed, 1 Feb 2017 17:18:36 -0500
Subject: [PATCH 08/22] Fix CatalogTupleInsert/Update abstraction for case of
 shared indstate.

Add CatalogTupleInsertWithInfo and CatalogTupleUpdateWithInfo to let
callers use the CatalogTupleXXX abstraction layer even in cases where
we want to share the results of CatalogOpenIndexes across multiple
inserts/updates for efficiency.  This finishes the job begun in commit
2f5c9d9c9, by allowing some remaining simple_heap_insert/update
calls to be replaced.  The abstraction layer is now complete enough
that we don't have to export CatalogIndexInsert at all anymore.

Also, this fixes several places in which 2f5c9d9c9 introduced performance
regressions by using retail CatalogTupleInsert or CatalogTupleUpdate even
though the previous coding had been able to amortize CatalogOpenIndexes
work across multiple tuples.

A possible future improvement is to arrange for the indexing.c functions
to cache the CatalogIndexState somewhere, maybe in the relcache, in which
case we could get rid of CatalogTupleInsertWithInfo and
CatalogTupleUpdateWithInfo again.  But that's a task for another day.

This is backport of aedd554

Discussion: https://postgr.es/m/27502.1485981379@sss.pgh.pa.us
---
 src/backend/catalog/heap.c                 | 19 ++----
 src/backend/catalog/indexing.c             | 69 ++++++++++++++++++----
 src/backend/catalog/pg_depend.c            |  6 +-
 src/backend/catalog/pg_shdepend.c          |  2 +-
 src/backend/commands/cluster.c             | 11 ++--
 src/backend/storage/large_object/inv_api.c | 10 ++--
 src/include/catalog/indexing.h             |  9 ++-
 7 files changed, 84 insertions(+), 42 deletions(-)

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index d107f517f399..a5d515bd9a6f 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -937,9 +937,10 @@ void MetaTrackDropObject(Oid		classid,
  * attribute to insert (but we ignore attacl and attoptions, which are always
  * initialized to NULL).
  *
- * indstate is the index state for CatalogIndexInsert.  It can be passed as
- * NULL, in which case we'll fetch the necessary info.  (Don't do this when
- * inserting multiple attributes, because it's a tad more expensive.)
+ * indstate is the index state for CatalogTupleInsertWithInfo.  It can be
+ * passed as NULL, in which case we'll fetch the necessary info.  (Don't do
+ * this when inserting multiple attributes, because it's a tad more
+ * expensive.)
  */
 void
 InsertPgAttributeTuple(Relation pg_attribute_rel,
@@ -981,18 +982,10 @@ InsertPgAttributeTuple(Relation pg_attribute_rel,
 	tup = heap_form_tuple(RelationGetDescr(pg_attribute_rel), values, nulls);
 
 	/* finally insert the new tuple, update the indexes, and clean up */
-	simple_heap_insert(pg_attribute_rel, tup);
-
 	if (indstate != NULL)
-		CatalogIndexInsert(indstate, tup);
+		CatalogTupleInsertWithInfo(pg_attribute_rel, tup, indstate);
 	else
-	{
-		CatalogIndexState indstate;
-
-		indstate = CatalogOpenIndexes(pg_attribute_rel);
-		CatalogIndexInsert(indstate, tup);
-		CatalogCloseIndexes(indstate);
-	}
+		CatalogTupleInsert(pg_attribute_rel, tup);
 
 	heap_freetuple(tup);
 }
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index dc992e4e1fc9..b2ba4d2c8cdb 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -68,7 +68,7 @@ CatalogCloseIndexes(CatalogIndexState indstate)
  *
  * This is effectively a cut-down version of ExecInsertIndexTuples.
  */
-void
+static void
 CatalogIndexInsert(CatalogIndexState indstate, HeapTuple heapTuple)
 {
 	int			i;
@@ -165,18 +165,20 @@ CatalogIndexInsert(CatalogIndexState indstate, HeapTuple heapTuple)
 /*
  * CatalogTupleInsert - do heap and indexing work for a new catalog tuple
  *
+ * Insert the tuple data in "tup" into the specified catalog relation.
+ * The Oid of the inserted tuple is returned.
+ *
  * This is a convenience routine for the common case of inserting a single
  * tuple in a system catalog; it inserts a new heap tuple, keeping indexes
- * current.  Avoid using it for multiple tuples, since opening the indexes and
- * building the index info structures is moderately expensive.
- *
- * The Oid of the inserted tuple is returned.
+ * current.  Avoid using it for multiple tuples, since opening the indexes
+ * and building the index info structures is moderately expensive.
+ * (Use CatalogTupleInsertWithInfo in such cases.)
  */
 Oid
 CatalogTupleInsert(Relation heapRel, HeapTuple tup)
 {
 	CatalogIndexState indstate;
-	Oid		oid;
+	Oid			oid;
 
 	indstate = CatalogOpenIndexes(heapRel);
 
@@ -188,14 +190,37 @@ CatalogTupleInsert(Relation heapRel, HeapTuple tup)
 	return oid;
 }
 
+/*
+ * CatalogTupleInsertWithInfo - as above, but with caller-supplied index info
+ *
+ * This should be used when it's important to amortize CatalogOpenIndexes/
+ * CatalogCloseIndexes work across multiple insertions.  At some point we
+ * might cache the CatalogIndexState data somewhere (perhaps in the relcache)
+ * so that callers needn't trouble over this ... but we don't do so today.
+ */
+Oid
+CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup,
+						   CatalogIndexState indstate)
+{
+	Oid			oid;
+
+	oid = simple_heap_insert(heapRel, tup);
+
+	CatalogIndexInsert(indstate, tup);
+
+	return oid;
+}
+
 /*
  * CatalogTupleUpdate - do heap and indexing work for updating a catalog tuple
  *
+ * Update the tuple identified by "otid", replacing it with the data in "tup".
+ *
  * This is a convenience routine for the common case of updating a single
- * tuple in a system catalog; it updates one heap tuple (identified by otid)
- * with tup, keeping indexes current.  Avoid using it for multiple tuples,
- * since opening the indexes and building the index info structures is
- * moderately expensive.
+ * tuple in a system catalog; it updates one heap tuple, keeping indexes
+ * current.  Avoid using it for multiple tuples, since opening the indexes
+ * and building the index info structures is moderately expensive.
+ * (Use CatalogTupleUpdateWithInfo in such cases.)
  */
 void
 CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
@@ -210,15 +235,37 @@ CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
 	CatalogCloseIndexes(indstate);
 }
 
+/*
+ * CatalogTupleUpdateWithInfo - as above, but with caller-supplied index info
+ *
+ * This should be used when it's important to amortize CatalogOpenIndexes/
+ * CatalogCloseIndexes work across multiple updates.  At some point we
+ * might cache the CatalogIndexState data somewhere (perhaps in the relcache)
+ * so that callers needn't trouble over this ... but we don't do so today.
+ */
+void
+CatalogTupleUpdateWithInfo(Relation heapRel, ItemPointer otid, HeapTuple tup,
+						   CatalogIndexState indstate)
+{
+	simple_heap_update(heapRel, otid, tup);
+
+	CatalogIndexInsert(indstate, tup);
+}
+
 /*
  * CatalogTupleDelete - do heap and indexing work for deleting a catalog tuple
  *
- * Delete the tuple identified by tid in the specified catalog.
+ * Delete the tuple identified by "tid" in the specified catalog.
  *
  * With Postgres heaps, there is no index work to do at deletion time;
  * cleanup will be done later by VACUUM.  However, callers of this function
  * shouldn't have to know that; we'd like a uniform abstraction for all
  * catalog tuple changes.  Hence, provide this currently-trivial wrapper.
+ *
+ * The abstraction is a bit leaky in that we don't provide an optimized
+ * CatalogTupleDeleteWithInfo version, because there is currently nothing to
+ * optimize.  If we ever need that, rather than touching a lot of call sites,
+ * it might be better to do something about caching CatalogIndexState.
  */
 void
 CatalogTupleDelete(Relation heapRel, ItemPointer tid)
diff --git a/src/backend/catalog/pg_depend.c b/src/backend/catalog/pg_depend.c
index 50452fe7897d..1ee606341970 100644
--- a/src/backend/catalog/pg_depend.c
+++ b/src/backend/catalog/pg_depend.c
@@ -107,13 +107,11 @@ recordMultipleDependencies(const ObjectAddress *depender,
 
 			tup = heap_form_tuple(dependDesc->rd_att, values, nulls);
 
-			simple_heap_insert(dependDesc, tup);
-
-			/* keep indexes current */
+			/* fetch index info only when we know we need it */
 			if (indstate == NULL)
 				indstate = CatalogOpenIndexes(dependDesc);
 
-			CatalogIndexInsert(indstate, tup);
+			CatalogTupleInsertWithInfo(dependDesc, tup, indstate);
 
 			heap_freetuple(tup);
 		}
diff --git a/src/backend/catalog/pg_shdepend.c b/src/backend/catalog/pg_shdepend.c
index b2d9159e9d2d..2cdceb9a790b 100644
--- a/src/backend/catalog/pg_shdepend.c
+++ b/src/backend/catalog/pg_shdepend.c
@@ -749,7 +749,7 @@ copyTemplateDependencies(Oid templateDbId, Oid newDbId)
 		HeapTuple	newtup;
 
 		newtup = heap_modify_tuple(tup, sdepDesc, values, nulls, replace);
-		CatalogTupleInsert(sdepRel, newtup);
+		CatalogTupleInsertWithInfo(sdepRel, newtup, indstate);
 
 		heap_freetuple(newtup);
 	}
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 215163022c47..7d4d16f561a6 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -1372,7 +1372,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 				relfilenode2;
 	Oid			swaptemp;
 	char		swapchar;
-	CatalogIndexState indstate;
 	bool		isAO1, isAO2;
 
 	/* We need writable copies of both pg_class tuples. */
@@ -1561,13 +1560,13 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 */
 	if (!target_is_pg_class)
 	{
-		simple_heap_update(relRelation, &reltup1->t_self, reltup1);
-		simple_heap_update(relRelation, &reltup2->t_self, reltup2);
+		CatalogIndexState indstate;
 
-		/* Keep system catalogs current */
 		indstate = CatalogOpenIndexes(relRelation);
-		CatalogIndexInsert(indstate, reltup1);
-		CatalogIndexInsert(indstate, reltup2);
+		CatalogTupleUpdateWithInfo(relRelation, &reltup1->t_self, reltup1,
+								   indstate);
+		CatalogTupleUpdateWithInfo(relRelation, &reltup2->t_self, reltup2,
+								   indstate);
 		CatalogCloseIndexes(indstate);
 	}
 	else
diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c
index 5ad64ee95ada..e517262d67d9 100644
--- a/src/backend/storage/large_object/inv_api.c
+++ b/src/backend/storage/large_object/inv_api.c
@@ -676,7 +676,8 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
 			replace[Anum_pg_largeobject_data - 1] = true;
 			newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
 									   values, nulls, replace);
-			CatalogTupleUpdate(lo_heap_r, &newtup->t_self, newtup);
+			CatalogTupleUpdateWithInfo(lo_heap_r, &newtup->t_self, newtup,
+									   indstate);
 			heap_freetuple(newtup);
 
 			/*
@@ -718,7 +719,7 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
 			values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
 			values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
 			newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
-			CatalogTupleInsert(lo_heap_r, newtup);
+			CatalogTupleInsertWithInfo(lo_heap_r, newtup, indstate);
 			heap_freetuple(newtup);
 		}
 		pageno++;
@@ -844,7 +845,8 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 		replace[Anum_pg_largeobject_data - 1] = true;
 		newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
 								   values, nulls, replace);
-		CatalogTupleUpdate(lo_heap_r, &newtup->t_self, newtup);
+		CatalogTupleUpdateWithInfo(lo_heap_r, &newtup->t_self, newtup,
+								   indstate);
 		heap_freetuple(newtup);
 	}
 	else
@@ -881,7 +883,7 @@ inv_truncate(LargeObjectDesc *obj_desc, int64 len)
 		values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
 		values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
 		newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
-		CatalogTupleInsert(lo_heap_r, newtup);
+		CatalogTupleInsertWithInfo(lo_heap_r, newtup, indstate);
 		heap_freetuple(newtup);
 	}
 
diff --git a/src/include/catalog/indexing.h b/src/include/catalog/indexing.h
index 7eb8d55bbee3..985f1a2b5054 100644
--- a/src/include/catalog/indexing.h
+++ b/src/include/catalog/indexing.h
@@ -32,11 +32,14 @@ typedef struct ResultRelInfo *CatalogIndexState;
  */
 extern CatalogIndexState CatalogOpenIndexes(Relation heapRel);
 extern void CatalogCloseIndexes(CatalogIndexState indstate);
-extern void CatalogIndexInsert(CatalogIndexState indstate,
-				   HeapTuple heapTuple);
-extern Oid CatalogTupleInsert(Relation heapRel, HeapTuple tup);
+extern Oid	CatalogTupleInsert(Relation heapRel, HeapTuple tup);
+extern Oid CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup,
+						   CatalogIndexState indstate);
 extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid,
 				   HeapTuple tup);
+extern void CatalogTupleUpdateWithInfo(Relation heapRel,
+						   ItemPointer otid, HeapTuple tup,
+						   CatalogIndexState indstate);
 extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid);
 
 extern void CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup);

From 3386c56231d05a3dae93a478be24f925139654d4 Mon Sep 17 00:00:00 2001
From: Robert Haas <rhaas@postgresql.org>
Date: Thu, 2 Mar 2017 17:03:50 +0530
Subject: [PATCH 09/22] Update comments overlooked by
 2f5c9d9c9cec436e55847ec580606d7e88067df6.

This is backport of fa42b20

Tomas Vondra
---
 src/backend/catalog/index.c        | 4 ++--
 src/backend/utils/cache/syscache.c | 8 +++-----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 1abe2a533672..98bfe7d371bc 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -2145,8 +2145,8 @@ index_update_stats(Relation rel,
 	 * 1. In bootstrap mode, we have no choice --- UPDATE wouldn't work.
 	 *
 	 * 2. We could be reindexing pg_class itself, in which case we can't move
-	 * its pg_class row because CatalogUpdateIndexes might not know about all
-	 * the indexes yet (see reindex_relation).
+	 * its pg_class row because CatalogTupleInsert/CatalogTupleUpdate might
+	 * not know about all the indexes yet (see reindex_relation).
 	 *
 	 * 3. Because we execute CREATE INDEX with just share lock on the parent
 	 * rel (to allow concurrent index creations), an ordinary update could
diff --git a/src/backend/utils/cache/syscache.c b/src/backend/utils/cache/syscache.c
index 154f21950793..c828b25e315a 100644
--- a/src/backend/utils/cache/syscache.c
+++ b/src/backend/utils/cache/syscache.c
@@ -100,11 +100,9 @@
 	(Adding an index requires a catversion.h update, while simply
 	adding/deleting caches only requires a recompile.)
 
-	Finally, any place your relation gets heap_insert() or heap_update()
-	calls, make sure there is a CatalogTupleInsert() or CatalogTupleUpdate()
-	or similar call.  The heap_* calls do not update indexes.
-
-	bjm 1999/11/22
+	Finally, any place your relation gets heap_insert() or
+	heap_update() calls, use CatalogTupleInsert() or CatalogTupleUpdate()
+	instead, which also update indexes.  The heap_* calls do not do that.
 
 *---------------------------------------------------------------------------
 */

From c60885a204e6c5709c41a30b10ec9b62d8d6cc82 Mon Sep 17 00:00:00 2001
From: Huansong Fu <fuhuansong@gmail.com>
Date: Sun, 26 Feb 2023 21:24:56 -0800
Subject: [PATCH 10/22] Fix inconsistency between gp_fastsequence row and index
 after crash

When we insert into gp_fastsequence, we insert a frozen row
(xmin=FrozenTransactionXid) and then update the index. That creates a
possibility of inconsistency in presence of server crash: if the WAL
for the frozen insert is flushed to persistent storage but the index
is not, after crash recovery we would be able to see the frozen row
in seqscan, but not in indexscan.

Now fixing this problem by doing regular heap_insert (normal MVCC) and
update the index first. Only after that we mark the row to be frozen.
That way we remove the inconsistency: if we crashed before we mark the
row frozen, the row follows regular MVCC and we won't be able to see it;
or if we crashed after we marked it frozen (and also it made to the disk),
we would replay both table row and index, so we would see the row in both
seqscan and indexscan.

Note that, now we use the upstream-aligned way to mark the tuple frozen
which is infomask |= HEAP_XMIN_FROZEN (commit 37484ad2aace), instead of
setting xmin = FrozenTransactionId. The freeze effect should be the same
though, but it helps leave behind a trail as to which transaction did the
freezing.

In addition, we use the same WAL type XLOG_HEAP2_FREEZE_PAGE as vacuum,
so we also align with upstream in how to replay the frozen tuple.
The alternative was to use the WAL type for heap_inplace_update, but then
we would need to change it to update the header portion as well as data
portion, which would be an unpleasant difference in WAL semantics.

The only other thing that has been changed from the previous way of doing
frozen_heap_insert is that now we don't set XLogRecord.xl_xid to
FrozenTransactionId anymore. However, this should be OK because:
(1) we are not setting xim=FrozenTransactionId anymore, the WAL record
should remain consistent.
(2) the change where we were setting this field in Greenplum seems to be
outdated itself. Upstream doesn't have even the capability to do that: it
never passes an arbitrary XID to that field, it's always
GetCurrentTransactionIdIfAny() (see XLogRecordAssemble()), even if you
insert a tuple w/ xmin=FrozenTransactionId (e.g. for PG sequence, see
fill_seq_with_data()). GPDB doesn't have a reason to differ.

Finally, need to make a fewn adjustment in the regress test output where
xmin is queried for gp_fastsequence.

This is backport of 961de2d

Co-authored-by: Ashwin Agrawal <aashwin@vmware.com>
---
 src/backend/access/heap/heapam.c              |  59 ++++-
 src/backend/catalog/gp_fastsequence.c         |  24 +-
 src/include/access/heapam.h                   |   1 +
 .../expected/frozen_insert_crash.out          | 226 ++++++++++++++++
 .../isolation2/expected/prevent_ao_wal.out    |  12 -
 .../isolation2/expected/prevent_ao_wal_1.out  |  12 -
 src/test/isolation2/init_file_isolation2      |  10 +
 src/test/isolation2/isolation2_schedule       |   1 +
 .../isolation2/sql/frozen_insert_crash.sql    | 112 ++++++++
 src/test/isolation2/sql/prevent_ao_wal.sql    |  11 -
 .../regress/expected/alter_table_aocs.out     |  57 ++--
 src/test/regress/input/appendonly.source      |  75 +++---
 src/test/regress/output/appendonly.source     | 250 +++++++++---------
 src/test/regress/sql/alter_table_aocs.sql     |   9 +-
 14 files changed, 631 insertions(+), 228 deletions(-)
 create mode 100644 src/test/isolation2/expected/frozen_insert_crash.out
 create mode 100644 src/test/isolation2/sql/frozen_insert_crash.sql

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index fccb019c7d4b..c835423b5fe1 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -6665,6 +6665,60 @@ heap_freeze_tuple(HeapTupleHeader tuple,
 	return do_freeze;
 }
 
+/*
+ * GPDB: heap_freeze_tuple_wal_logged
+ *		Similar to heap_freeze_tuple, but with WAL logging AND do not check
+ * 		cutoff xid (i.e. we blindly freeze a tuple and write WAL for it).
+ *
+ * Useful when we want to freeze a tuple immediately after inserting it.
+ */
+void
+heap_freeze_tuple_wal_logged(Relation rel, HeapTuple tup)
+{
+	xl_heap_freeze_tuple 	frozen = {0};
+	XLogRecPtr      	recptr;
+	Buffer 			buffer;
+	Page 			page;
+	HeapTupleHeader		htup;
+
+	/* Set the passed-in tuple to be frozen */
+	HeapTupleHeaderSetXminFrozen(tup->t_data);
+
+	/*
+	 * Prepare the xl_heap_freeze_tuple manually (instead of heap_prepare_freeze_tuple)
+	 * as we do not need the checks in heap_prepare_freeze_tuple. Note that this would
+	 * suffer from having more field been added to xl_heap_freeze_tuple in future. 
+	 * But that would be caught by a test case in isolation2/frozen_insert_crash.
+	 * Also, we don't set frozen->frzflags as those are to be set only during vacuum.
+	 */
+	frozen.xmax = HeapTupleHeaderGetRawXmax(tup->t_data);
+	frozen.offset = ItemPointerGetOffsetNumber(&(tup->t_self));
+	frozen.t_infomask = tup->t_data->t_infomask;
+	frozen.t_infomask2 = tup->t_data->t_infomask2;
+
+	buffer = ReadBuffer(rel, ItemPointerGetBlockNumber(&(tup->t_self)));
+	LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
+
+	page = (Page) BufferGetPage(buffer);
+
+	START_CRIT_SECTION();
+
+	MarkBufferDirty(buffer);
+
+	/* freeze the tuple in buffer */
+	htup = (HeapTupleHeader) PageGetItem(page, PageGetItemId(page, frozen.offset));
+	heap_execute_freeze_tuple(htup, &frozen);
+
+	/* WAL logging */
+	recptr = log_heap_freeze(rel, buffer, InvalidTransactionId /* cutoff_xid */,
+								&frozen, 1 /*ntuples*/);
+	PageSetLSN(page, recptr);
+
+	END_CRIT_SECTION();
+
+	UnlockReleaseBuffer(buffer);
+}
+
 /*
  * For a given MultiXactId, return the hint bits that should be set in the
  * tuple's infomask.
@@ -8188,8 +8242,11 @@ heap_xlog_freeze_page(XLogRecPtr lsn, XLogRecord *record)
 	/*
 	 * In Hot Standby mode, ensure that there's no queries running which still
 	 * consider the frozen xids as running.
+	 * GPDB: but do nothing if there is no valid cutoff xid, which means the
+	 * record is not generated by vacuum but by specifically freezing a tuple
+	 * (see heap_freeze_tuple_no_cutoff).
 	 */
-	if (InHotStandby)
+	if (InHotStandby && TransactionIdIsValid(cutoff_xid))
 	{
 		TransactionId latestRemovedXid = cutoff_xid;
 
diff --git a/src/backend/catalog/gp_fastsequence.c b/src/backend/catalog/gp_fastsequence.c
index b6ef1954ffa8..a6f505c6f046 100644
--- a/src/backend/catalog/gp_fastsequence.c
+++ b/src/backend/catalog/gp_fastsequence.c
@@ -21,6 +21,8 @@
 #include "access/genam.h"
 #include "access/htup.h"
 #include "access/heapam.h"
+#include "access/xact.h"
+#include "utils/faultinjector.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 #include "access/appendonlywriter.h"
@@ -179,7 +181,27 @@ insert_or_update_fastsequence(Relation gp_fastsequence_rel,
 
 		newTuple = heaptuple_form_to(tupleDesc, values, nulls, NULL, NULL);
 
-		CatalogTupleInsertFrozen(gp_fastsequence_rel, newTuple);
+		/* insert the tuple */
+		CatalogTupleInsert(gp_fastsequence_rel, newTuple);
+
+#ifdef FAULT_INJECTOR
+		FaultInjector_InjectFaultIfSet(
+								"insert_fastsequence_before_freeze",
+								DDLNotSpecified,
+								"", //databaseName
+								RelationGetRelationName(gp_fastsequence_rel));
+#endif
+
+		/* freeze the tuple */
+		heap_freeze_tuple_wal_logged(gp_fastsequence_rel, newTuple);
+
+#ifdef FAULT_INJECTOR
+		FaultInjector_InjectFaultIfSet(
+								"insert_fastsequence_after_freeze",
+								DDLNotSpecified,
+								"", //databaseName
+								RelationGetRelationName(gp_fastsequence_rel));
+#endif
 
 		heap_freetuple(newTuple);
 	}
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index b1588f32644a..bbb91dbd3124 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -170,6 +170,7 @@ extern void heap_inplace_update(Relation relation, HeapTuple tuple);
 extern bool heap_freeze_tuple(HeapTupleHeader tuple,
 				  TransactionId relfrozenxid, TransactionId relminmxid,
 				  TransactionId cutoff_xid, TransactionId cutoff_multi);
+extern void heap_freeze_tuple_wal_logged(Relation rel, HeapTuple tuple);
 extern bool heap_tuple_needs_freeze(HeapTupleHeader tuple, TransactionId cutoff_xid,
 						MultiXactId cutoff_multi, Buffer buf);
 
diff --git a/src/test/isolation2/expected/frozen_insert_crash.out b/src/test/isolation2/expected/frozen_insert_crash.out
new file mode 100644
index 000000000000..999f78a9e948
--- /dev/null
+++ b/src/test/isolation2/expected/frozen_insert_crash.out
@@ -0,0 +1,226 @@
+-- Test server crash in case of frozen insert. Make sure that after crash
+-- recovery, the frozen insert and index are consistent:
+--
+-- 1. If crash happened before the row is frozen, the row will be invisible;
+-- 2. If crash happened after the row is frozen, the row will be visible.
+--
+-- And the above behavior should remain consistent using seqscan or indexscan.
+--
+-- We test gp_fastsequence here since it does frozen insert and has an index.
+
+-- Case 1. crash after the regular MVCC insert has made to disk, but not
+-- the WAL record responsible for updating it to frozen.
+-- After crash recovery, the insert will follow regular MVCC and not be seen.
+1: create table tab_fi(a int) with (appendoptimized=true) distributed replicated;
+CREATE
+
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+
+2: insert into tab_fi select generate_series(1, 1000);
+INSERT 1000
+2: update tab_fi set a = 1 where a > 10;
+UPDATE 990
+
+-- suspend right after the insert into gp_fastsequence during an AO table insert,
+-- but before freezing the tuple
+1: select gp_inject_fault('insert_fastsequence_before_freeze', 'suspend', ''/*DDL*/, ''/*DB*/, 'gp_fastsequence'/*table*/, 1/*start occur*/, 1/*end occur*/, 0/*extra_arg*/, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+
+2>: vacuum tab_fi;  <waiting ...>
+
+1: select gp_wait_until_triggered_fault('insert_fastsequence_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_wait_until_triggered_fault 
+-------------------------------
+ Success:                      
+(1 row)
+
+-- switch WAL on seg0, so the new row gets flushed (including its index)
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+
+-- inject a panic, and resume the insert. The WAL for the freeze operation is not
+-- going to be made to disk (we just flushed WALs), so we won't replay it during restart later.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault_infinite 
+--------------------------
+ Success:                 
+(1 row)
+1: select gp_inject_fault('appendonly_insert', 'panic', ''/*DDL*/, ''/*DB*/, 'tab_fi'/*table*/, 1/*start occur*/, -1/*end occur*/, 0/*extra_arg*/, 2/*db_id*/);
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('insert_fastsequence_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+
+2<:  <... completed>
+ERROR:  fault triggered, fault name:'appendonly_insert' fault type:'panic'  (seg0 127.0.1.1:7002 pid=14710)
+
+1q: ... <quitting>
+
+-- check the gp_fastsequence content w/ table vs index scan, neither should see the
+-- new inserted row (objmod=1) following MVCC
+1: set enable_indexscan = off;
+SET
+1: set enable_seqscan = on;
+SET
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+ gp_segment_id | objmod | last_sequence 
+---------------+--------+---------------
+ 0             | 0      | 0             
+ 0             | 1      | 2100          
+(2 rows)
+1: set enable_indexscan = on;
+SET
+1: set enable_seqscan = off;
+SET
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+ gp_segment_id | objmod | last_sequence 
+---------------+--------+---------------
+ 0             | 0      | 0             
+ 0             | 1      | 2100          
+(2 rows)
+1: reset enable_indexscan;
+RESET
+1: reset enable_seqscan;
+RESET
+
+1: drop table tab_fi;
+DROP
+
+-- Case 2. crash after we have flushed the WAL that updates the row to be frozen.
+-- After crash recovery, the insert should be seen.
+1: create table tab_fi(a int) with (appendoptimized=true) distributed replicated;
+CREATE
+
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+
+2: insert into tab_fi select generate_series(1, 1000);
+INSERT 1000
+2: update tab_fi set a = 1 where a > 10;
+UPDATE 990
+
+-- suspend right after freezing the tuple
+1: select gp_inject_fault('insert_fastsequence_after_freeze', 'suspend', ''/*DDL*/, ''/*DB*/, 'gp_fastsequence'/*table*/, 1/*start occur*/, 1/*end occur*/, 0/*extra_arg*/, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+
+2>: vacuum tab_fi;  <waiting ...>
+
+1: select gp_wait_until_triggered_fault('insert_fastsequence_after_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_wait_until_triggered_fault 
+-------------------------------
+ Success:                      
+(1 row)
+
+-- switch WAL on seg0, so the freeze record gets flushed
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+
+-- While we are on it, check the wal record for the freeze operation.
+-- One of the purposes is to guard against unexpected addition to the xl_heap_freeze_tuple struct in future.
+-- If this test failed due to WAL size, please check to see if the xl_heap_freeze_tuple struct
+-- has changed, and if we should initialize any new field in heap_freeze_tuple_no_cutoff().
+! seg0_datadir=$(psql -At -c "select datadir from gp_segment_configuration where content = 0 and role = 'p'" postgres) && seg0_last_wal_file=$(psql -At -c "SELECT pg_xlogfile_name(pg_current_xlog_location()) from gp_dist_random('gp_id') where gp_segment_id = 0" postgres) && pg_xlogdump ${seg0_last_wal_file} -p ${seg0_datadir}/pg_xlog | grep freeze_page;
+rmgr: Heap2       len (rec/tot):     36/    68, tx: ##, lsn: #/########, prev #/########, bkp: 0000, desc: freeze_page: rel ####/######/######; blk 0; cutoff xid 0 ntuples 1
+
+
+-- inject a panic and resume in same way as Case 1. But this time we will be able to replay the frozen insert.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault_infinite 
+--------------------------
+ Success:                 
+(1 row)
+1: select gp_inject_fault('appendonly_insert', 'panic', ''/*DDL*/, ''/*DB*/, 'tab_fi'/*table*/, 1/*start occur*/, -1/*end occur*/, 0/*extra_arg*/, 2/*db_id*/);
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('insert_fastsequence_after_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+
+2<:  <... completed>
+ERROR:  fault triggered, fault name:'appendonly_insert' fault type:'panic'  (seg0 127.0.1.1:7002 pid=14775)
+
+1q: ... <quitting>
+
+-- check the gp_fastsequence content w/ table vs index scan, both should see the new inserted row (objmod=1)
+1: set enable_indexscan = off;
+SET
+1: set enable_seqscan = on;
+SET
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+ gp_segment_id | objmod | last_sequence 
+---------------+--------+---------------
+ 0             | 0      | 0             
+ 0             | 1      | 2100          
+ 0             | 2      | 0             
+(3 rows)
+1: set enable_indexscan = on;
+SET
+1: set enable_seqscan = off;
+SET
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+ gp_segment_id | objmod | last_sequence 
+---------------+--------+---------------
+ 0             | 0      | 0             
+ 0             | 1      | 2100          
+ 0             | 2      | 0             
+(3 rows)
+1: reset enable_indexscan;
+RESET
+1: reset enable_seqscan;
+RESET
+
+1: drop table tab_fi;
+DROP
+
+-- validate that we've actually tested desired scan method
+-- for some reason this disrupts the output of subsequent queries so
+-- validating at the end here
+! psql postgres -At -c "set enable_indexscan = off; set enable_seqscan = on; explain (costs off) select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');" | grep "Seq Scan on gp_fastsequence";
+                                ->  Seq Scan on gp_fastsequence f
+
+! psql postgres -At -c "set enable_indexscan = on; set enable_seqscan = off; explain (costs off) select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');" | grep "Index Scan using gp_fastsequence";
+                                ->  Index Scan using gp_fastsequence_objid_objmod_index on gp_fastsequence f
+
+
diff --git a/src/test/isolation2/expected/prevent_ao_wal.out b/src/test/isolation2/expected/prevent_ao_wal.out
index 2bc01178ff04..9ed00dc57eb0 100644
--- a/src/test/isolation2/expected/prevent_ao_wal.out
+++ b/src/test/isolation2/expected/prevent_ao_wal.out
@@ -21,18 +21,6 @@ GP_IGNORE: formatted by atmsort.pm
 -- end_matchignore
 GP_IGNORE: defined new match expression
 
--- start_matchsubs
--- m/tx:\s+\d+/
--- s/tx:\s+\d+/tx: ##/
-
--- m/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/
--- s/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/lsn: #\/########, prev #\/########/
-
--- m/rel \d+\/\d+\/\d+/
--- s/rel \d+\/\d+\/\d+/rel ####\/######\/######/
--- end_matchsubs
-GP_IGNORE: defined new match expression
-
 -- Create tables (AO, AOCO)
 -1U: CREATE TABLE ao_foo (n int) WITH (appendonly=true);
 CREATE
diff --git a/src/test/isolation2/expected/prevent_ao_wal_1.out b/src/test/isolation2/expected/prevent_ao_wal_1.out
index 37e73021e6be..23aed4f01814 100644
--- a/src/test/isolation2/expected/prevent_ao_wal_1.out
+++ b/src/test/isolation2/expected/prevent_ao_wal_1.out
@@ -21,18 +21,6 @@ GP_IGNORE: formatted by atmsort.pm
 -- end_matchignore
 GP_IGNORE: defined new match expression
 
--- start_matchsubs
--- m/tx:\s+\d+/
--- s/tx:\s+\d+/tx: ##/
-
--- m/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/
--- s/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/lsn: #\/########, prev #\/########/
-
--- m/rel \d+\/\d+\/\d+/
--- s/rel \d+\/\d+\/\d+/rel ####\/######\/######/
--- end_matchsubs
-GP_IGNORE: defined new match expression
-
 -- Create tables (AO, AOCO)
 -1U: CREATE TABLE ao_foo (n int) WITH (appendonly=true);
 CREATE
diff --git a/src/test/isolation2/init_file_isolation2 b/src/test/isolation2/init_file_isolation2
index 256efe3c47a1..5c7cf6f4eacb 100644
--- a/src/test/isolation2/init_file_isolation2
+++ b/src/test/isolation2/init_file_isolation2
@@ -67,4 +67,14 @@ s/available \d+ MB//
 m/\(cdbdisp_async\.c\:\d+\)/
 s/\(cdbdisp_async\.c:\d+\)/\(cdbdisp_async\.c:LINE_NUM\)/
 
+# remove WAL details from pg_waldump output
+m/tx:\s+\d+/
+s/tx:\s+\d+/tx: ##/
+
+m/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/
+s/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/lsn: #\/########, prev #\/########/
+
+m/rel \d+\/\d+\/\d+/
+s/rel \d+\/\d+\/\d+/rel ####\/######\/######/
+
 -- end_matchsubs
diff --git a/src/test/isolation2/isolation2_schedule b/src/test/isolation2/isolation2_schedule
index fa635a477f3e..920c1a7b2af4 100644
--- a/src/test/isolation2/isolation2_schedule
+++ b/src/test/isolation2/isolation2_schedule
@@ -22,6 +22,7 @@ test: unlogged_heap_tables
 test: unlogged_appendonly_tables
 test: udf_exception_blocks_panic_scenarios
 test: ao_same_trans_truncate_crash
+test: frozen_insert_crash
 test: ao_fsync_panic
 test: uao_crash_compaction_column
 test: uao_crash_compaction_row
diff --git a/src/test/isolation2/sql/frozen_insert_crash.sql b/src/test/isolation2/sql/frozen_insert_crash.sql
new file mode 100644
index 000000000000..53c8f787dc5c
--- /dev/null
+++ b/src/test/isolation2/sql/frozen_insert_crash.sql
@@ -0,0 +1,112 @@
+-- Test server crash in case of frozen insert. Make sure that after crash
+-- recovery, the frozen insert and index are consistent:
+-- 
+-- 1. If crash happened before the row is frozen, the row will be invisible;
+-- 2. If crash happened after the row is frozen, the row will be visible.
+-- 
+-- And the above behavior should remain consistent using seqscan or indexscan.
+--
+-- We test gp_fastsequence here since it does frozen insert and has an index.
+
+-- Case 1. crash after the regular MVCC insert has made to disk, but not
+-- the WAL record responsible for updating it to frozen.
+-- After crash recovery, the insert will follow regular MVCC and not be seen.
+1: create table tab_fi(a int) with (appendoptimized=true) distributed replicated;
+
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+
+2: insert into tab_fi select generate_series(1, 1000);
+2: update tab_fi set a = 1 where a > 10;
+
+-- suspend right after the insert into gp_fastsequence during an AO table insert,
+-- but before freezing the tuple
+1: select gp_inject_fault('insert_fastsequence_before_freeze', 'suspend', ''/*DDL*/, ''/*DB*/, 'gp_fastsequence'/*table*/, 1/*start occur*/, 1/*end occur*/, 0/*extra_arg*/, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+
+2>: vacuum tab_fi;
+
+1: select gp_wait_until_triggered_fault('insert_fastsequence_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+
+-- switch WAL on seg0, so the new row gets flushed (including its index)
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+
+-- inject a panic, and resume the insert. The WAL for the freeze operation is not
+-- going to be made to disk (we just flushed WALs), so we won't replay it during restart later.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+1: select gp_inject_fault('appendonly_insert', 'panic', ''/*DDL*/, ''/*DB*/, 'tab_fi'/*table*/, 1/*start occur*/, -1/*end occur*/, 0/*extra_arg*/, 2/*db_id*/);
+1: select gp_inject_fault('insert_fastsequence_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+
+2<:
+
+1q:
+
+-- check the gp_fastsequence content w/ table vs index scan, neither should see the 
+-- new inserted row (objmod=1) following MVCC
+1: set enable_indexscan = off;
+1: set enable_seqscan = on;
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+1: set enable_indexscan = on;
+1: set enable_seqscan = off;
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+1: reset enable_indexscan;
+1: reset enable_seqscan;
+
+1: drop table tab_fi;
+
+-- Case 2. crash after we have flushed the WAL that updates the row to be frozen.
+-- After crash recovery, the insert should be seen.
+1: create table tab_fi(a int) with (appendoptimized=true) distributed replicated;
+
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+
+2: insert into tab_fi select generate_series(1, 1000);
+2: update tab_fi set a = 1 where a > 10;
+
+-- suspend right after freezing the tuple
+1: select gp_inject_fault('insert_fastsequence_after_freeze', 'suspend', ''/*DDL*/, ''/*DB*/, 'gp_fastsequence'/*table*/, 1/*start occur*/, 1/*end occur*/, 0/*extra_arg*/, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+
+2>: vacuum tab_fi;
+
+1: select gp_wait_until_triggered_fault('insert_fastsequence_after_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+
+-- switch WAL on seg0, so the freeze record gets flushed
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+
+-- While we are on it, check the wal record for the freeze operation.
+-- One of the purposes is to guard against unexpected addition to the xl_heap_freeze_tuple struct in future.
+-- If this test failed due to WAL size, please check to see if the xl_heap_freeze_tuple struct
+-- has changed, and if we should initialize any new field in heap_freeze_tuple_no_cutoff().
+! seg0_datadir=$(psql -At -c "select datadir from gp_segment_configuration where content = 0 and role = 'p'" postgres) && seg0_last_wal_file=$(psql -At -c "SELECT pg_xlogfile_name(pg_current_xlog_location()) from gp_dist_random('gp_id') where gp_segment_id = 0" postgres) && pg_xlogdump ${seg0_last_wal_file} -p ${seg0_datadir}/pg_xlog | grep freeze_page;
+
+-- inject a panic and resume in same way as Case 1. But this time we will be able to replay the frozen insert.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+1: select gp_inject_fault('appendonly_insert', 'panic', ''/*DDL*/, ''/*DB*/, 'tab_fi'/*table*/, 1/*start occur*/, -1/*end occur*/, 0/*extra_arg*/, 2/*db_id*/);
+1: select gp_inject_fault('insert_fastsequence_after_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+
+2<:
+
+1q:
+
+-- check the gp_fastsequence content w/ table vs index scan, both should see the new inserted row (objmod=1)
+1: set enable_indexscan = off;
+1: set enable_seqscan = on;
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+1: set enable_indexscan = on;
+1: set enable_seqscan = off;
+1: select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');
+1: reset enable_indexscan;
+1: reset enable_seqscan;
+
+1: drop table tab_fi;
+
+-- validate that we've actually tested desired scan method
+-- for some reason this disrupts the output of subsequent queries so
+-- validating at the end here
+! psql postgres -At -c "set enable_indexscan = off; set enable_seqscan = on; explain (costs off) select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');" | grep "Seq Scan on gp_fastsequence";
+! psql postgres -At -c "set enable_indexscan = on; set enable_seqscan = off; explain (costs off) select distinct f.gp_segment_id, f.objmod, f.last_sequence from gp_dist_random('gp_fastsequence') f left join gp_dist_random('pg_appendonly') a on segrelid = objid and a.gp_segment_id = f.gp_segment_id where a.gp_segment_id = 0 and relid = (select oid from pg_class where relname = 'tab_fi');" | grep "Index Scan using gp_fastsequence";
+
diff --git a/src/test/isolation2/sql/prevent_ao_wal.sql b/src/test/isolation2/sql/prevent_ao_wal.sql
index a69787648802..a28cbd28885e 100644
--- a/src/test/isolation2/sql/prevent_ao_wal.sql
+++ b/src/test/isolation2/sql/prevent_ao_wal.sql
@@ -19,17 +19,6 @@
 -- m/.*Table doesn't have 'DISTRIBUTED BY' clause*/
 -- end_matchignore
 
--- start_matchsubs
--- m/tx:\s+\d+/
--- s/tx:\s+\d+/tx: ##/
-
--- m/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/
--- s/lsn: \d\/[0-9a-fA-F]+, prev \d\/[0-9a-fA-F]+/lsn: #\/########, prev #\/########/
-
--- m/rel \d+\/\d+\/\d+/
--- s/rel \d+\/\d+\/\d+/rel ####\/######\/######/
--- end_matchsubs
-
 -- Create tables (AO, AOCO)
 -1U: CREATE TABLE ao_foo (n int) WITH (appendonly=true);
 -1U: CREATE TABLE aoco_foo (n int, m int) WITH (appendonly=true, orientation=column);
diff --git a/src/test/regress/expected/alter_table_aocs.out b/src/test/regress/expected/alter_table_aocs.out
index 7c98505f679f..79f95eab032e 100644
--- a/src/test/regress/expected/alter_table_aocs.out
+++ b/src/test/regress/expected/alter_table_aocs.out
@@ -265,34 +265,32 @@ begin;
 insert into addcol6 select i,i from generate_series(1,10)i;
 -- abort the first insert, still should advance gp_fastsequence for this
 -- relation.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           100 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           100 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           100 |             0
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             1
+      1 |           100 |             1
+      0 |             0 |             2
+      1 |           100 |             2
+      0 |             0 |             0
+      1 |           100 |             0
 (6 rows)
 
 abort;
 -- check gp_fastsequence remains advanced.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           100 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           100 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           100 |             0
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             1
+      1 |           100 |             1
+      0 |             0 |             2
+      1 |           100 |             2
+      0 |             0 |             0
+      1 |           100 |             0
 (6 rows)
 
 insert into addcol6 select i,i/2 from generate_series(1,20)i;
@@ -312,18 +310,17 @@ select a,c from addcol6 where b > 5 order by a;
 (9 rows)
 
 -- Lets validate after alter gp_fastsequence reflects correctly.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           200 |             0
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           200 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           200 |             2
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             0
+      1 |           200 |             0
+      0 |             0 |             1
+      1 |           200 |             1
+      0 |             0 |             2
+      1 |           200 |             2
 (6 rows)
 
 -- add column with default value as sequence
diff --git a/src/test/regress/input/appendonly.source b/src/test/regress/input/appendonly.source
index 8e1b5e58515f..d01830cc9648 100644
--- a/src/test/regress/input/appendonly.source
+++ b/src/test/regress/input/appendonly.source
@@ -24,9 +24,9 @@ CREATE TABLE tenk_heap (
 -- valid
 CREATE TABLE tenk_ao1 (like tenk_heap) with (appendonly=true, checksum=true) distributed by(unique1);
 
--- creating AO table should create entry in gp_fastsequence with normal xid
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+-- We used to check xmin here and other places in this test, but now the new gp_fastsequence
+-- rows are frozen via hintbits (HEAP_XMIN_FROZEN) so not checking that anymore.
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='tenk_ao1'));
 
@@ -183,8 +183,7 @@ SELECT count(*) FROM tenk_ao1; -- should show previous count
 SELECT aototal('tenk_ao1');
 -- gp_fastsequence should reflect bump in lastsequence, even if above
 -- transaction aborted as its tuples is in place updated.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='tenk_ao1'));
 
@@ -258,12 +257,14 @@ CREATE TABLE tenk_ao1 with(appendonly=true, checksum=true) AS SELECT * FROM tenk
 -- With and without ORCA last_sequence fluctuates bit and hence using >= 3300 as
 -- inserting 10k tuples to 3 node system must atleast have last_sequence >= 3300
 -- on each node.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod, CASE
-WHEN objmod = 0 THEN last_sequence >= 3300 WHEN objmod = 1 THEN last_sequence =
-0 END, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid IN (SELECT
-segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class WHERE
-relname='tenk_ao1'));
-
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+	    ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao1'));
 -- Since we check last_sequence for the tenk_ao2 table later, the data distribution should be same for orca and planner.
 -- If we don't specify the DISTRIBUTED BY caluse, ORCA will mark the table distributed randomly.
 CREATE TABLE tenk_ao2 with(appendonly=true, compresslevel=0, blocksize=262144) AS SELECT * FROM tenk_heap DISTRIBUTED BY (unique1);
@@ -282,13 +283,11 @@ BEGIN;
 CREATE TABLE appendonly_sametxn_create_insert(a int, b int) with (appendonly=true);
 INSERT INTO appendonly_sametxn_create_insert select * from generate_series(1, 10);
 -- Make sure insert is using segfile 1 for the insert, as part of create table itself.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_sametxn_create_insert'));
 INSERT INTO appendonly_sametxn_create_insert select * from generate_series(1, 10);
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_sametxn_create_insert'));
 ABORT;
@@ -332,20 +331,28 @@ SELECT unique1 FROM tenk_ao1 EXCEPT SELECT unique1 FROM tenk_ao1;
 SELECT unique1 FROM tenk_heap EXCEPT SELECT unique1 FROM tenk_ao3;
 
 -- Get gp_fastsequence details before truncate
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence > 0, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
-IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
-WHERE relname='tenk_ao2'));
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+           ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao2'));
 
 -- TRUNCATE
 TRUNCATE tenk_ao2;
 
--- Truncate changes relfilnode, as a result old pg_aoseg table is truncated, and
--- gp_fastsequence entries are also reinitialized
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence = 0, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
-IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
-WHERE relname='tenk_ao2'));
+-- Truncate changes relfilnode, as a result old pg_aoseg table is truncated and
+-- gp_fastsequence entries are also reinitialized.
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+           ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao2'));
 
 -- OIDS
 CREATE TABLE aowithoids(a int, b int) WITH (appendonly=true,oids=true);
@@ -495,7 +502,7 @@ select count(*) from tenk_ao1 where unique2 < 0;
 ALTER TABLE tenk_ao1 RENAME TO tenk_renamed;
 ALTER TABLE tenk_renamed ADD COLUMN newcol int default 10;
 -- Validate post alter gp_fastsequence reflects correctly
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod, CASE
+SELECT objmod, CASE
 WHEN objmod = 0 THEN last_sequence >= 3300 WHEN objmod = 1 THEN last_sequence =
 0 END, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid IN (SELECT
 segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class WHERE
@@ -550,14 +557,12 @@ DROP TABLE IF EXISTS ao_selection;
 CREATE TABLE ao_selection (a INT, b INT) WITH (appendonly=true);
 INSERT INTO ao_selection VALUES (generate_series(1,100000), generate_series(1,10000));
 -- Validates insert is using single segfile to perform the insert to gp_fastsequence.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='ao_selection'));
 -- Following insert without concurrency is also using same segfile as above
 INSERT INTO ao_selection values (generate_series(1,100000), generate_series(1,10000));
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='ao_selection'));
 
@@ -618,15 +623,17 @@ BEGIN;
 SAVEPOINT sp1;
 CREATE TABLE appendonly_subxans_test(a int, b int) WITH (appendonly=true);
 INSERT INTO appendonly_subxans_test SELECT * FROM generate_series(1, 10);
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_subxans_test'));
 ROLLBACK TO SAVEPOINT sp1;
 COMMIT;
 
--- create table and insert in nested subtransaction, to validate insert to
--- gp_fastsequence is using NormalXid and not FrozenXid.
+-- create table and insert in nested subtransaction.
+-- The original purpose of this test is to validate that insert to gp_fastsequence
+-- is using NormalXid and not FrozenXid. But since now we do not set the xmin to
+-- FrozenTransactionXid anymore, it makes less sense in that regard, but this
+-- nested transaction case might still be valuable, so keep running it.
 BEGIN;
 SAVEPOINT sp1;
 CREATE TABLE appendonly_subxans_test(a int, b int) WITH (appendonly=true);
diff --git a/src/test/regress/output/appendonly.source b/src/test/regress/output/appendonly.source
index fe566fd24abd..7f3c5e98cb7c 100644
--- a/src/test/regress/output/appendonly.source
+++ b/src/test/regress/output/appendonly.source
@@ -22,19 +22,19 @@ CREATE TABLE tenk_heap (
 --
 -- valid
 CREATE TABLE tenk_ao1 (like tenk_heap) with (appendonly=true, checksum=true) distributed by(unique1);
--- creating AO table should create entry in gp_fastsequence with normal xid
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+-- We used to check xmin here and other places in this test, but now the new gp_fastsequence
+-- rows are frozen via hintbits (HEAP_XMIN_FROZEN) so not checking that anymore.
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='tenk_ao1'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |             0 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |             0 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |             0 |             0
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             0
+      1 |             0 |             0
+      0 |             0 |             1
+      1 |             0 |             1
+      0 |             0 |             2
+      1 |             0 |             2
 (6 rows)
 
 CREATE TABLE tenk_ao2 (like tenk_heap) with (appendonly=true, compresslevel=0, blocksize=262144) distributed by(unique1);
@@ -337,18 +337,17 @@ SELECT aototal('tenk_ao1');
 
 -- gp_fastsequence should reflect bump in lastsequence, even if above
 -- transaction aborted as its tuples is in place updated.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='tenk_ao1'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |         17100 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |         16400 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |         17000 |             0
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             0
+      1 |         17000 |             0
+      0 |             0 |             1
+      1 |         17100 |             1
+      0 |             0 |             2
+      1 |         16400 |             2
 (6 rows)
 
 -- commit
@@ -486,19 +485,22 @@ CREATE TABLE tenk_ao1 with(appendonly=true, checksum=true) AS SELECT * FROM tenk
 -- With and without ORCA last_sequence fluctuates bit and hence using >= 3300 as
 -- inserting 10k tuples to 3 node system must atleast have last_sequence >= 3300
 -- on each node.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod, CASE
-WHEN objmod = 0 THEN last_sequence >= 3300 WHEN objmod = 1 THEN last_sequence =
-0 END, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid IN (SELECT
-segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class WHERE
-relname='tenk_ao1'));
-   case    | objmod | case | gp_segment_id 
------------+--------+------+---------------
- NormalXid |      0 | t    |             1
- NormalXid |      1 | t    |             1
- NormalXid |      0 | t    |             2
- NormalXid |      1 | t    |             2
- NormalXid |      0 | t    |             0
- NormalXid |      1 | t    |             0
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+	    ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao1'));
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 | >= 3300       |             2
+      1 | zero          |             2
+      0 | >= 3300       |             0
+      1 | zero          |             0
+      0 | >= 3300       |             1
+      1 | zero          |             1
 (6 rows)
 
 -- Since we check last_sequence for the tenk_ao2 table later, the data distribution should be same for orca and planner.
@@ -555,33 +557,31 @@ NOTICE:  Table doesn't have 'DISTRIBUTED BY' clause -- Using column named 'a' as
 HINT:  The 'DISTRIBUTED BY' clause determines the distribution of data. Make sure column(s) chosen are the optimal data distribution key to minimize skew.
 INSERT INTO appendonly_sametxn_create_insert select * from generate_series(1, 10);
 -- Make sure insert is using segfile 1 for the insert, as part of create table itself.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_sametxn_create_insert'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           100 |             0
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           100 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           100 |             2
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             1
+      1 |           100 |             1
+      0 |             0 |             2
+      1 |           100 |             2
+      0 |             0 |             0
+      1 |           100 |             0
 (6 rows)
 
 INSERT INTO appendonly_sametxn_create_insert select * from generate_series(1, 10);
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_sametxn_create_insert'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           200 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           200 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           200 |             0
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             1
+      1 |           200 |             1
+      0 |             0 |             2
+      1 |           200 |             2
+      0 |             0 |             0
+      1 |           200 |             0
 (6 rows)
 
 ABORT;
@@ -711,36 +711,44 @@ SELECT unique1 FROM tenk_heap EXCEPT SELECT unique1 FROM tenk_ao3;
 (0 rows)
 
 -- Get gp_fastsequence details before truncate
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence > 0, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
-IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
-WHERE relname='tenk_ao2'));
-   case    | objmod | ?column? | gp_segment_id 
------------+--------+----------+---------------
- NormalXid |      0 | t        |             1
- NormalXid |      1 | t        |             1
- NormalXid |      0 | t        |             2
- NormalXid |      1 | t        |             2
- NormalXid |      0 | t        |             0
- NormalXid |      1 | t        |             0
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+           ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao2'));
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 | >= 3300       |             1
+      1 | 1-2900        |             1
+      0 | >= 3300       |             2
+      1 | 1-2900        |             2
+      0 | >= 3300       |             0
+      1 | 1-2900        |             0
 (6 rows)
 
 -- TRUNCATE
 TRUNCATE tenk_ao2;
--- Truncate changes relfilnode, as a result old pg_aoseg table is truncated, and
--- gp_fastsequence entries are also reinitialized
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence = 0, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
-IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
-WHERE relname='tenk_ao2'));
-   case    | objmod | ?column? | gp_segment_id 
------------+--------+----------+---------------
- NormalXid |      0 | t        |             1
- NormalXid |      1 | t        |             1
- NormalXid |      0 | t        |             2
- NormalXid |      1 | t        |             2
- NormalXid |      0 | t        |             0
- NormalXid |      1 | t        |             0
+-- Truncate changes relfilnode, as a result old pg_aoseg table is truncated and
+-- gp_fastsequence entries are also reinitialized.
+SELECT objmod,
+       CASE WHEN last_sequence = 0 THEN 'zero'
+            WHEN last_sequence >= 3300 THEN '>= 3300'
+           ELSE '1-2900' END AS last_sequence,
+       gp_segment_id
+FROM gp_dist_random('gp_fastsequence')
+WHERE objid IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (
+  SELECT oid FROM pg_class WHERE relname='tenk_ao2'));
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 | zero          |             1
+      1 | zero          |             1
+      0 | zero          |             2
+      1 | zero          |             2
+      0 | zero          |             0
+      1 | zero          |             0
 (6 rows)
 
 -- OIDS
@@ -1107,19 +1115,19 @@ select count(*) from tenk_ao1 where unique2 < 0;
 ALTER TABLE tenk_ao1 RENAME TO tenk_renamed;
 ALTER TABLE tenk_renamed ADD COLUMN newcol int default 10;
 -- Validate post alter gp_fastsequence reflects correctly
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod, CASE
+SELECT objmod, CASE
 WHEN objmod = 0 THEN last_sequence >= 3300 WHEN objmod = 1 THEN last_sequence =
 0 END, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid IN (SELECT
 segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class WHERE
 relname='tenk_renamed'));
-   case    | objmod | case | gp_segment_id 
------------+--------+------+---------------
- NormalXid |      0 | t    |             1
- NormalXid |      1 | t    |             1
- NormalXid |      0 | t    |             0
- NormalXid |      1 | t    |             0
- NormalXid |      0 | t    |             2
- NormalXid |      1 | t    |             2
+ objmod | case | gp_segment_id 
+--------+------+---------------
+      0 | t    |             0
+      1 | t    |             0
+      0 | t    |             2
+      1 | t    |             2
+      0 | t    |             1
+      1 | t    |             1
 (6 rows)
 
 ALTER TABLE tenk_renamed ALTER COLUMN twothousand SET NOT NULL;
@@ -1197,34 +1205,32 @@ DROP TABLE IF EXISTS ao_selection;
 CREATE TABLE ao_selection (a INT, b INT) WITH (appendonly=true);
 INSERT INTO ao_selection VALUES (generate_series(1,100000), generate_series(1,10000));
 -- Validates insert is using single segfile to perform the insert to gp_fastsequence.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='ao_selection'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |         33500 |             0
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |         33400 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |         33300 |             2
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             2
+      1 |         33300 |             2
+      0 |             0 |             0
+      1 |         33500 |             0
+      0 |             0 |             1
+      1 |         33400 |             1
 (6 rows)
 
 -- Following insert without concurrency is also using same segfile as above
 INSERT INTO ao_selection values (generate_series(1,100000), generate_series(1,10000));
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='ao_selection'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |         67000 |             0
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |         66800 |             1
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |         66600 |             2
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             0
+      1 |         67000 |             0
+      0 |             0 |             1
+      1 |         66800 |             1
+      0 |             0 |             2
+      1 |         66600 |             2
 (6 rows)
 
 -- Check compression and distribution
@@ -1359,24 +1365,26 @@ CREATE TABLE appendonly_subxans_test(a int, b int) WITH (appendonly=true);
 NOTICE:  Table doesn't have 'DISTRIBUTED BY' clause -- Using column named 'a' as the Greenplum Database data distribution key for this table.
 HINT:  The 'DISTRIBUTED BY' clause determines the distribution of data. Make sure column(s) chosen are the optimal data distribution key to minimize skew.
 INSERT INTO appendonly_subxans_test SELECT * FROM generate_series(1, 10);
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='appendonly_subxans_test'));
-   case    | objmod | last_sequence | gp_segment_id 
------------+--------+---------------+---------------
- NormalXid |      0 |             0 |             2
- NormalXid |      1 |           100 |             2
- NormalXid |      0 |             0 |             0
- NormalXid |      1 |           100 |             0
- NormalXid |      0 |             0 |             1
- NormalXid |      1 |           100 |             1
+ objmod | last_sequence | gp_segment_id 
+--------+---------------+---------------
+      0 |             0 |             2
+      1 |           100 |             2
+      0 |             0 |             0
+      1 |           100 |             0
+      0 |             0 |             1
+      1 |           100 |             1
 (6 rows)
 
 ROLLBACK TO SAVEPOINT sp1;
 COMMIT;
--- create table and insert in nested subtransaction, to validate insert to
--- gp_fastsequence is using NormalXid and not FrozenXid.
+-- create table and insert in nested subtransaction.
+-- The original purpose of this test is to validate that insert to gp_fastsequence
+-- is using NormalXid and not FrozenXid. But since now we do not set the xmin to
+-- FrozenTransactionXid anymore, it makes less sense in that regard, but this
+-- nested transaction case might still be valuable, so keep running it.
 BEGIN;
 SAVEPOINT sp1;
 CREATE TABLE appendonly_subxans_test(a int, b int) WITH (appendonly=true);
diff --git a/src/test/regress/sql/alter_table_aocs.sql b/src/test/regress/sql/alter_table_aocs.sql
index abe732a55c59..7856c4c61f27 100644
--- a/src/test/regress/sql/alter_table_aocs.sql
+++ b/src/test/regress/sql/alter_table_aocs.sql
@@ -180,15 +180,13 @@ begin;
 insert into addcol6 select i,i from generate_series(1,10)i;
 -- abort the first insert, still should advance gp_fastsequence for this
 -- relation.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
 abort;
 
 -- check gp_fastsequence remains advanced.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
 
@@ -197,8 +195,7 @@ alter table addcol6 add column c float default 1.2;
 select a,c from addcol6 where b > 5 order by a;
 
 -- Lets validate after alter gp_fastsequence reflects correctly.
-SELECT CASE WHEN xmin = 2 THEN 'FrozenXid' ELSE 'NormalXid' END, objmod,
-last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
+SELECT objmod, last_sequence, gp_segment_id from gp_dist_random('gp_fastsequence') WHERE objid
 IN (SELECT segrelid FROM pg_appendonly WHERE relid IN (SELECT oid FROM pg_class
 WHERE relname='addcol6'));
 

From 206ab6b95ef248f7b71284d3eedeaa9c1fb3c8fc Mon Sep 17 00:00:00 2001
From: Huansong Fu <fuhuansong@gmail.com>
Date: Wed, 12 Apr 2023 07:05:17 -0700
Subject: [PATCH 11/22] Only write WAL when needed in
 heap_freeze_tuple_wal_logged()

Relations such as temporary tables or unlogged tables should not have
WALs created.

This is backport of 5245dcd
---
 src/backend/access/heap/heapam.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index c835423b5fe1..97cc5b09bceb 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -6676,7 +6676,6 @@ void
 heap_freeze_tuple_wal_logged(Relation rel, HeapTuple tup)
 {
 	xl_heap_freeze_tuple 	frozen = {0};
-	XLogRecPtr      	recptr;
 	Buffer 			buffer;
 	Page 			page;
 	HeapTupleHeader		htup;
@@ -6710,9 +6709,14 @@ heap_freeze_tuple_wal_logged(Relation rel, HeapTuple tup)
 	heap_execute_freeze_tuple(htup, &frozen);
 
 	/* WAL logging */
-	recptr = log_heap_freeze(rel, buffer, InvalidTransactionId /* cutoff_xid */,
-								&frozen, 1 /*ntuples*/);
-	PageSetLSN(page, recptr);
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr      	recptr;
+
+		recptr = log_heap_freeze(rel, buffer, InvalidTransactionId /* cutoff_xid */,
+									&frozen, 1 /*ntuples*/);
+		PageSetLSN(page, recptr);
+	}
 
 	END_CRIT_SECTION();
 

From 1502befb5be3a511d287d9eff694bb1c0434156f Mon Sep 17 00:00:00 2001
From: Huansong Fu <fuhuansong@gmail.com>
Date: Wed, 5 Apr 2023 08:38:11 -0700
Subject: [PATCH 12/22] Fix possible inconsistency between bitmap LOV table and
 index

Similar to gp_fastsequence, there was a potential inconsistency between
the bitmap LOV table and its index due to the frozen insert. Now we fix
the inconsistency by similar method as in 961de2da40858ed302b2a656b5258aa8d17c87b9

This is backport of 8accc02
SIMPLE_FAULT_INJECTOR("qe_exec_finished") was taken from e30909f for test.
Fault injectors for insert_bmlov_before_freeze and insert_bmlov_after_freeze
were changed because test does not work with the originals.
---
 src/backend/access/bitmap/bitmapattutil.c     |   8 +-
 src/backend/tcop/postgres.c                   |   1 +
 .../expected/frozen_insert_crash.out          | 203 +++++++++++++++++-
 .../isolation2/sql/frozen_insert_crash.sql    |  97 ++++++++-
 4 files changed, 306 insertions(+), 3 deletions(-)

diff --git a/src/backend/access/bitmap/bitmapattutil.c b/src/backend/access/bitmap/bitmapattutil.c
index 94431632106d..83c05b1d5329 100644
--- a/src/backend/access/bitmap/bitmapattutil.c
+++ b/src/backend/access/bitmap/bitmapattutil.c
@@ -42,6 +42,7 @@
 #include "nodes/makefuncs.h"
 #include "optimizer/clauses.h"
 #include "utils/builtins.h"
+#include "utils/faultinjector.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
 #include "utils/snapmgr.h"
@@ -325,7 +326,7 @@ _bitmap_insert_lov(Relation lovHeap, Relation lovIndex, Datum *datum,
 
 	/* insert this tuple into the heap */
 	tuple = heap_form_tuple(tupDesc, datum, nulls);
-	frozen_heap_insert(lovHeap, tuple);
+	simple_heap_insert(lovHeap, tuple);
 
 	/* insert a new tuple into the index */
 	indexDatum = palloc0((tupDesc->natts - 2) * sizeof(Datum));
@@ -335,6 +336,11 @@ _bitmap_insert_lov(Relation lovHeap, Relation lovIndex, Datum *datum,
 	result = index_insert(lovIndex, indexDatum, indexNulls,
 					 	  &(tuple->t_self), lovHeap, true);
 
+	SIMPLE_FAULT_INJECTOR("insert_bmlov_before_freeze");
+	/* freeze the tuple */
+	heap_freeze_tuple_wal_logged(lovHeap, tuple);
+
+	SIMPLE_FAULT_INJECTOR("insert_bmlov_after_freeze");
 	pfree(indexDatum);
 	pfree(indexNulls);
 	Assert(result);
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 71db148a1915..c65c8bf0f922 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -5492,6 +5492,7 @@ PostgresMain(int argc, char *argv[],
 
 					SetUserIdAndSecContext(GetOuterUserId(), 0);
 
+					SIMPLE_FAULT_INJECTOR("qe_exec_finished");
 					send_ready_for_query = true;
 				}
 				break;
diff --git a/src/test/isolation2/expected/frozen_insert_crash.out b/src/test/isolation2/expected/frozen_insert_crash.out
index 999f78a9e948..d29a0694159a 100644
--- a/src/test/isolation2/expected/frozen_insert_crash.out
+++ b/src/test/isolation2/expected/frozen_insert_crash.out
@@ -6,7 +6,8 @@
 --
 -- And the above behavior should remain consistent using seqscan or indexscan.
 --
--- We test gp_fastsequence here since it does frozen insert and has an index.
+-- We test gp_fastsequence and bitmap here since they do frozen insert and
+-- normal index insert, so that the inconsistency could exist.
 
 -- Case 1. crash after the regular MVCC insert has made to disk, but not
 -- the WAL record responsible for updating it to frozen.
@@ -214,6 +215,206 @@ RESET
 1: drop table tab_fi;
 DROP
 
+
+-- Same set of tests for bitmap LOV insert.
+create extension if not exists pageinspect;
+CREATE
+
+-- Function to check the bitmap lov content regarding the column 'b'
+-- which is the table column that we will have bitmap created on.
+-- Basically, we want to see if "SELECT b FROM pg_bitmapindex.pg_bm_xxx"
+-- returns the same result in seqscan and indexscan.
+CREATE OR REPLACE FUNCTION insert_bm_lov_res() RETURNS void AS $$ DECLARE lov_table text; /* in func */ sql text; /* in func */ BEGIN /* in func */ drop table if exists bm_lov_res; /* in func */ create temp table bm_lov_res(b int); /* in func */ SELECT c.relname INTO lov_table /* in func */ FROM bm_metap('tab_fi_idx') b /* in func */ JOIN pg_class c ON b.auxrelid = c.oid; /* in func */ sql := format('INSERT INTO bm_lov_res SELECT b FROM pg_bitmapindex.%I', lov_table); /* in func */ EXECUTE sql; /* in func */ END; /* in func */ $$ LANGUAGE plpgsql;
+CREATE
+
+1: create table tab_fi(a int, b int) with (appendoptimized=true) distributed replicated;
+CREATE
+1: create index tab_fi_idx on tab_fi using bitmap(b);
+CREATE
+1: insert into tab_fi values(1, 1);
+INSERT 1
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+
+-- case 1: suspend and flush WAL before freezing the tuple
+
+-- suspend right after the insert into the bitmap lov table and its index
+-- during a table insert, but before freezing the tuple
+1: select gp_inject_fault('insert_bmlov_before_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+2>: insert into tab_fi values(2, 2);  <waiting ...>
+1: select gp_wait_until_triggered_fault('insert_bmlov_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_wait_until_triggered_fault 
+-------------------------------
+ Success:                      
+(1 row)
+-- switch WAL on seg0, so the new row gets flushed (including its index)
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+-- inject a panic, and resume the insert. The WAL for the freeze operation is not
+-- going to be made to disk (we just flushed WALs), so we won't replay it during restart later.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault_infinite 
+--------------------------
+ Success:                 
+(1 row)
+1: select gp_inject_fault('qe_exec_finished', 'panic', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('insert_bmlov_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+2<:  <... completed>
+ERROR:  fault triggered, fault name:'qe_exec_finished' fault type:'panic'
+1q: ... <quitting>
+-- check the lov table content w/ table vs index scan, neither should see the
+-- new inserted row (b=2)
+0U: set enable_indexscan = on;
+SET
+0U: set enable_seqscan = off;
+SET
+0U: select insert_bm_lov_res();
+ insert_bm_lov_res 
+-------------------
+                   
+(1 row)
+0U: select * from bm_lov_res;
+ b 
+---
+ 1 
+(1 row)
+0U: set enable_indexscan = off;
+SET
+0U: set enable_seqscan = on;
+SET
+0U: select insert_bm_lov_res();
+ insert_bm_lov_res 
+-------------------
+                   
+(1 row)
+0U: select * from bm_lov_res;
+ b 
+---
+ 1 
+(1 row)
+0Uq: ... <quitting>
+1: drop table tab_fi;
+DROP
+
+-- case 2: suspend and flush WAL after freezing the tuple
+
+1: create table tab_fi(a int, b int) with (appendoptimized=true) distributed replicated;
+CREATE
+1: create index tab_fi_idx on tab_fi using bitmap(b);
+CREATE
+1: insert into tab_fi values(1, 1);
+INSERT 1
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+-- suspend right after freezing the tuple
+1: select gp_inject_fault('insert_bmlov_after_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+2>: insert into tab_fi values(2, 2);  <waiting ...>
+1: select gp_wait_until_triggered_fault('insert_bmlov_after_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_wait_until_triggered_fault 
+-------------------------------
+ Success:                      
+(1 row)
+-- switch WAL on seg0, so the freeze record gets flushed
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+ gp_segment_id | ?column? 
+---------------+----------
+ 0             | t        
+(1 row)
+-- While we are on it, check the wal record for the freeze operation.
+! seg0_datadir=$(psql -At -c "select datadir from gp_segment_configuration where content = 0 and role = 'p'" postgres) && seg0_last_wal_file=$(psql -At -c "SELECT pg_xlogfile_name(pg_current_xlog_location()) from gp_dist_random('gp_id') where gp_segment_id = 0" postgres) && pg_xlogdump ${seg0_last_wal_file} -p ${seg0_datadir}/pg_xlog | grep freeze_page;
+rmgr: Heap2       len (rec/tot):     36/    68, tx: ##, lsn: #/########, prev #/########, bkp: 0000, desc: freeze_page: rel ####/######/######; blk 0; cutoff xid 0 ntuples 1
+
+-- inject a panic and resume in same way as Case 1. But this time we will be able to replay the frozen insert.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault_infinite 
+--------------------------
+ Success:                 
+(1 row)
+1: select gp_inject_fault('qe_exec_finished', 'panic', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('insert_bmlov_after_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+2<:  <... completed>
+ERROR:  fault triggered, fault name:'qe_exec_finished' fault type:'panic'
+1q: ... <quitting>
+-- check the lov table content w/ table vs index scan, both should see the
+-- new inserted row (b=2)
+0U: set enable_indexscan = on;
+SET
+0U: set enable_seqscan = off;
+SET
+0U: select insert_bm_lov_res();
+ insert_bm_lov_res 
+-------------------
+                   
+(1 row)
+0U: select * from bm_lov_res;
+ b 
+---
+ 1 
+ 2 
+(2 rows)
+0U: set enable_indexscan = off;
+SET
+0U: set enable_seqscan = on;
+SET
+0U: select insert_bm_lov_res();
+ insert_bm_lov_res 
+-------------------
+                   
+(1 row)
+0U: select * from bm_lov_res;
+ b 
+---
+ 1 
+ 2 
+(2 rows)
+
 -- validate that we've actually tested desired scan method
 -- for some reason this disrupts the output of subsequent queries so
 -- validating at the end here
diff --git a/src/test/isolation2/sql/frozen_insert_crash.sql b/src/test/isolation2/sql/frozen_insert_crash.sql
index 53c8f787dc5c..89cf7fb2e701 100644
--- a/src/test/isolation2/sql/frozen_insert_crash.sql
+++ b/src/test/isolation2/sql/frozen_insert_crash.sql
@@ -6,7 +6,8 @@
 -- 
 -- And the above behavior should remain consistent using seqscan or indexscan.
 --
--- We test gp_fastsequence here since it does frozen insert and has an index.
+-- We test gp_fastsequence and bitmap here since they do frozen insert and
+-- normal index insert, so that the inconsistency could exist.
 
 -- Case 1. crash after the regular MVCC insert has made to disk, but not
 -- the WAL record responsible for updating it to frozen.
@@ -104,6 +105,100 @@
 
 1: drop table tab_fi;
 
+
+-- Same set of tests for bitmap LOV insert.
+create extension if not exists pageinspect;
+
+-- Function to check the bitmap lov content regarding the column 'b'
+-- which is the table column that we will have bitmap created on.
+-- Basically, we want to see if "SELECT b FROM pg_bitmapindex.pg_bm_xxx"
+-- returns the same result in seqscan and indexscan.
+CREATE OR REPLACE FUNCTION insert_bm_lov_res() RETURNS void AS $$
+DECLARE
+  lov_table text; /* in func */
+  sql text; /* in func */
+BEGIN /* in func */
+  drop table if exists bm_lov_res; /* in func */
+  create temp table bm_lov_res(b int); /* in func */
+  SELECT c.relname INTO lov_table /* in func */
+  FROM bm_metap('tab_fi_idx') b /* in func */
+  JOIN pg_class c ON b.auxrelid = c.oid; /* in func */
+  sql := format('INSERT INTO bm_lov_res SELECT b FROM pg_bitmapindex.%I', lov_table); /* in func */
+  EXECUTE sql; /* in func */
+END; /* in func */
+$$ LANGUAGE plpgsql;
+
+1: create table tab_fi(a int, b int) with (appendoptimized=true) distributed replicated;
+1: create index tab_fi_idx on tab_fi using bitmap(b);
+1: insert into tab_fi values(1, 1);
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+
+-- case 1: suspend and flush WAL before freezing the tuple
+
+-- suspend right after the insert into the bitmap lov table and its index 
+-- during a table insert, but before freezing the tuple
+1: select gp_inject_fault('insert_bmlov_before_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+2>: insert into tab_fi values(2, 2);
+1: select gp_wait_until_triggered_fault('insert_bmlov_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+-- switch WAL on seg0, so the new row gets flushed (including its index)
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+-- inject a panic, and resume the insert. The WAL for the freeze operation is not
+-- going to be made to disk (we just flushed WALs), so we won't replay it during restart later.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+1: select gp_inject_fault('qe_exec_finished', 'panic', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('insert_bmlov_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+2<:
+1q:
+-- check the lov table content w/ table vs index scan, neither should see the 
+-- new inserted row (b=2)
+0U: set enable_indexscan = on;
+0U: set enable_seqscan = off;
+0U: select insert_bm_lov_res();
+0U: select * from bm_lov_res;
+0U: set enable_indexscan = off;
+0U: set enable_seqscan = on;
+0U: select insert_bm_lov_res();
+0U: select * from bm_lov_res;
+0Uq:
+1: drop table tab_fi;
+
+-- case 2: suspend and flush WAL after freezing the tuple
+
+1: create table tab_fi(a int, b int) with (appendoptimized=true) distributed replicated;
+1: create index tab_fi_idx on tab_fi using bitmap(b);
+1: insert into tab_fi values(1, 1);
+-- switch WAL on seg0 to reduce flakiness
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+-- suspend right after freezing the tuple
+1: select gp_inject_fault('insert_bmlov_after_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+2>: insert into tab_fi values(2, 2);
+1: select gp_wait_until_triggered_fault('insert_bmlov_after_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+-- switch WAL on seg0, so the freeze record gets flushed
+1: select gp_segment_id, pg_switch_xlog() is not null from gp_dist_random('gp_id') where gp_segment_id = 0;
+-- While we are on it, check the wal record for the freeze operation.
+! seg0_datadir=$(psql -At -c "select datadir from gp_segment_configuration where content = 0 and role = 'p'" postgres) && seg0_last_wal_file=$(psql -At -c "SELECT pg_xlogfile_name(pg_current_xlog_location()) from gp_dist_random('gp_id') where gp_segment_id = 0" postgres) && pg_xlogdump ${seg0_last_wal_file} -p ${seg0_datadir}/pg_xlog | grep freeze_page;
+-- inject a panic and resume in same way as Case 1. But this time we will be able to replay the frozen insert.
+-- skip FTS probe to prevent unexpected mirror promotion
+1: select gp_inject_fault_infinite('fts_probe', 'skip', dbid) from gp_segment_configuration where role='p' and content=-1;
+1: select gp_inject_fault('qe_exec_finished', 'panic', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('insert_bmlov_after_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: select gp_inject_fault('fts_probe', 'reset', dbid) from gp_segment_configuration where role='p' and content=-1;
+2<:
+1q:
+-- check the lov table content w/ table vs index scan, both should see the 
+-- new inserted row (b=2)
+0U: set enable_indexscan = on;
+0U: set enable_seqscan = off;
+0U: select insert_bm_lov_res();
+0U: select * from bm_lov_res;
+0U: set enable_indexscan = off;
+0U: set enable_seqscan = on;
+0U: select insert_bm_lov_res();
+0U: select * from bm_lov_res;
+
 -- validate that we've actually tested desired scan method
 -- for some reason this disrupts the output of subsequent queries so
 -- validating at the end here

From 85a7ee51d9aad9825ede080c7fc328ee67f0e446 Mon Sep 17 00:00:00 2001
From: Huansong Fu <fuhuansong@gmail.com>
Date: Wed, 5 Apr 2023 14:57:59 -0700
Subject: [PATCH 13/22] Change how new aoseg/aocsseg tuples are frozen

Now using the similar method as used in 961de2da40858ed302b2a656b5258aa8d17c87b9
to mark the new aoseg/aocsseg tuples frozen, which is first insert the tuple
using normal heap insert, and then update it to be frozen using same mechanism
as vacuum freeze.

Note that, the inconsistency issue targeted by the above commit does not exist
in aoseg/aocsseg tables, because they do not have index. However, we still want
to be consistent about how we do this kind of things with both Greenplum itself
and the upstream (which never does "insert a new frozen tuple").

With that, we also get rid of CatalogTupleFrozenInsert.

This is backport of 1306d47
frozen_heap_insert was removed from InsertInitialAOCSFileSegInfo by a5e28ec
---
 src/backend/access/appendonly/aosegfiles.c    |  5 ++-
 src/backend/catalog/indexing.c                | 18 --------
 src/include/catalog/indexing.h                |  2 -
 .../expected/frozen_insert_crash.out          | 45 +++++++++++++++++++
 .../isolation2/sql/frozen_insert_crash.sql    | 19 ++++++++
 5 files changed, 68 insertions(+), 21 deletions(-)

diff --git a/src/backend/access/appendonly/aosegfiles.c b/src/backend/access/appendonly/aosegfiles.c
index 8d1bad91f1cb..5d7c3e86425b 100644
--- a/src/backend/access/appendonly/aosegfiles.c
+++ b/src/backend/access/appendonly/aosegfiles.c
@@ -39,6 +39,7 @@
 #include "storage/lmgr.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/faultinjector.h"
 #include "utils/guc.h"
 #include "utils/int8.h"
 #include "utils/lsyscache.h"
@@ -141,7 +142,9 @@ InsertInitialSegnoEntry(Relation parentrel, int segno)
 	if (!HeapTupleIsValid(pg_aoseg_tuple))
 		elog(ERROR, "failed to build AO file segment tuple");
 
-	frozen_heap_insert(pg_aoseg_rel, pg_aoseg_tuple);
+	simple_heap_insert(pg_aoseg_rel, pg_aoseg_tuple);
+	SIMPLE_FAULT_INJECTOR("insert_aoseg_before_freeze");
+	heap_freeze_tuple_wal_logged(pg_aoseg_rel, pg_aoseg_tuple);
 
 	heap_freetuple(pg_aoseg_tuple);
 
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index b2ba4d2c8cdb..22638825e674 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -272,21 +272,3 @@ CatalogTupleDelete(Relation heapRel, ItemPointer tid)
 {
 	simple_heap_delete(heapRel, tid);
 }
-
-/*
- * Greenplum: this interface is used to insert tuples into gp_fastsequence
- * and aoseg relations during an appendoptimized (row as well as column)
- * insert transaction.
- */
-void
-CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup)
-{
-	CatalogIndexState indstate;
-
-	indstate = CatalogOpenIndexes(heapRel);
-
-	frozen_heap_insert(heapRel, tup);
-
-	CatalogIndexInsert(indstate, tup);
-	CatalogCloseIndexes(indstate);
-}
diff --git a/src/include/catalog/indexing.h b/src/include/catalog/indexing.h
index 985f1a2b5054..a20ab67b07ea 100644
--- a/src/include/catalog/indexing.h
+++ b/src/include/catalog/indexing.h
@@ -42,8 +42,6 @@ extern void CatalogTupleUpdateWithInfo(Relation heapRel,
 						   CatalogIndexState indstate);
 extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid);
 
-extern void CatalogTupleInsertFrozen(Relation heapRel, HeapTuple tup);
-
 /*
  * These macros are just to keep the C compiler from spitting up on the
  * upcoming commands for genbki.pl.
diff --git a/src/test/isolation2/expected/frozen_insert_crash.out b/src/test/isolation2/expected/frozen_insert_crash.out
index d29a0694159a..8b4f6df5efe2 100644
--- a/src/test/isolation2/expected/frozen_insert_crash.out
+++ b/src/test/isolation2/expected/frozen_insert_crash.out
@@ -154,6 +154,7 @@ UPDATE 990
 -- has changed, and if we should initialize any new field in heap_freeze_tuple_no_cutoff().
 ! seg0_datadir=$(psql -At -c "select datadir from gp_segment_configuration where content = 0 and role = 'p'" postgres) && seg0_last_wal_file=$(psql -At -c "SELECT pg_xlogfile_name(pg_current_xlog_location()) from gp_dist_random('gp_id') where gp_segment_id = 0" postgres) && pg_xlogdump ${seg0_last_wal_file} -p ${seg0_datadir}/pg_xlog | grep freeze_page;
 rmgr: Heap2       len (rec/tot):     36/    68, tx: ##, lsn: #/########, prev #/########, bkp: 0000, desc: freeze_page: rel ####/######/######; blk 0; cutoff xid 0 ntuples 1
+rmgr: Heap2       len (rec/tot):     36/    68, tx: ##, lsn: #/########, prev #/########, bkp: 0000, desc: freeze_page: rel ####/######/######; blk 0; cutoff xid 0 ntuples 1
 
 
 -- inject a panic and resume in same way as Case 1. But this time we will be able to replay the frozen insert.
@@ -415,6 +416,50 @@ SET
  2 
 (2 rows)
 
+1: drop extension pageinspect;
+DROP
+
+-- Test for aoseg: suspend the insert into aoseg table before we mark the row frozen.
+-- Another session should still be able to choose a different segno.
+1: create table tab_aoseg(a int) with (appendoptimized=true, orientation=row);
+CREATE
+1: select gp_inject_fault('insert_aoseg_before_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+1: begin;
+BEGIN
+1>: insert into tab_aoseg select * from generate_series(1,10);  <waiting ...>
+-- wait until the aoseg record is inserted but not yet frozen
+2: select gp_wait_until_triggered_fault('insert_aoseg_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_wait_until_triggered_fault 
+-------------------------------
+ Success:                      
+(1 row)
+2: begin;
+BEGIN
+2>: insert into tab_aoseg select * from generate_series(1,10);  <waiting ...>
+3: select gp_inject_fault('insert_aoseg_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+ gp_inject_fault 
+-----------------
+ Success:        
+(1 row)
+2<:  <... completed>
+INSERT 10
+2: end;
+END
+1<:  <... completed>
+INSERT 10
+1: end;
+END
+0U: select segno, eof from gp_toolkit.__gp_aoseg('tab_aoseg');
+ segno | eof 
+-------+-----
+ 1     | 88  
+ 2     | 88  
+(2 rows)
+
 -- validate that we've actually tested desired scan method
 -- for some reason this disrupts the output of subsequent queries so
 -- validating at the end here
diff --git a/src/test/isolation2/sql/frozen_insert_crash.sql b/src/test/isolation2/sql/frozen_insert_crash.sql
index 89cf7fb2e701..57667575f09f 100644
--- a/src/test/isolation2/sql/frozen_insert_crash.sql
+++ b/src/test/isolation2/sql/frozen_insert_crash.sql
@@ -199,6 +199,25 @@ $$ LANGUAGE plpgsql;
 0U: select insert_bm_lov_res();
 0U: select * from bm_lov_res;
 
+1: drop extension pageinspect;
+
+-- Test for aoseg: suspend the insert into aoseg table before we mark the row frozen.
+-- Another session should still be able to choose a different segno.
+1: create table tab_aoseg(a int) with (appendoptimized=true, orientation=row);
+1: select gp_inject_fault('insert_aoseg_before_freeze', 'suspend', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+1: begin;
+1>: insert into tab_aoseg select * from generate_series(1,10);
+-- wait until the aoseg record is inserted but not yet frozen
+2: select gp_wait_until_triggered_fault('insert_aoseg_before_freeze', 1, dbid) from gp_segment_configuration where role = 'p' and content = 0;
+2: begin;
+2>: insert into tab_aoseg select * from generate_series(1,10);
+3: select gp_inject_fault('insert_aoseg_before_freeze', 'reset', dbid) from gp_segment_configuration where role = 'p' and content = 0;
+2<:
+2: end;
+1<:
+1: end;
+0U: select segno, eof from gp_toolkit.__gp_aoseg('tab_aoseg');
+
 -- validate that we've actually tested desired scan method
 -- for some reason this disrupts the output of subsequent queries so
 -- validating at the end here

From 8a40ff61b42ceca09c3ad2d0cdd3f7fa9d8939fd Mon Sep 17 00:00:00 2001
From: Huansong Fu <fuhuansong@gmail.com>
Date: Wed, 5 Apr 2023 15:13:57 -0700
Subject: [PATCH 14/22] Remove remainings of "frozen insert"

The previous commits have replaced the logic for "frozen insert" with the
safer way of "insert & freezing". Now removing the remainings of that
concept from the code base. GPDB now should be aligned with the upstream
wrt the interfaces concerned here.

Note that the frozen insert into a table also does frozen insert into its
toast tables (i.e. toast_insert_or_update() called with isFrozen=true).
One may question why we had the code to do that, given that none of
gp_fastsequence, bitmap indexes and ao(cs)seg tables has a toast table.
Here's some context regarding why we had that logic in the first place:
it was added to support an edge case with "error tables" for external tables,
which have been removed from GPDB since 3fd4bd9c6634d90f23099bdce75a910ba2813fad.
For example, the old syntax for the mentioned feature:
```
copy foo from 'foo.csv' csv LOG ERRORS INTO errtable SEGMENT REJECT LIMIT 10 ROWS;
```
So we should remove the related code for toast table too.

This is backport of 998f4c2
---
 src/backend/access/appendonly/appendonlyam.c |  1 -
 src/backend/access/heap/heapam.c             | 23 +++++---------
 src/backend/access/heap/rewriteheap.c        |  2 +-
 src/backend/access/heap/tuptoaster.c         | 33 +++++++-------------
 src/backend/access/transam/xlog.c            |  7 -----
 src/include/access/tuptoaster.h              |  5 ++-
 src/include/access/xlog.h                    |  1 -
 7 files changed, 22 insertions(+), 50 deletions(-)

diff --git a/src/backend/access/appendonly/appendonlyam.c b/src/backend/access/appendonly/appendonlyam.c
index 2f87be269c25..60383bad6748 100755
--- a/src/backend/access/appendonly/appendonlyam.c
+++ b/src/backend/access/appendonly/appendonlyam.c
@@ -2885,7 +2885,6 @@ appendonly_insert(AppendOnlyInsertDesc aoInsertDesc,
 		tup = toast_insert_or_update_memtup(relation, instup,
 											NULL, aoInsertDesc->mt_bind,
 											aoInsertDesc->toast_tuple_target,
-											false,	/* errtbl is never AO */
 											0);
 	else
 		tup = instup;
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 97cc5b09bceb..201a4ff4daaf 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -88,7 +88,7 @@ static HeapScanDesc heap_beginscan_internal(Relation relation,
 						bool allow_strat, bool allow_sync,
 						bool is_bitmapscan, bool temp_snap);
 static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
-					TransactionId xid, CommandId cid, int options, bool isFrozen);
+					TransactionId xid, CommandId cid, int options);
 static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
 				Buffer newbuf, HeapTuple oldtup,
 				HeapTuple newtup, HeapTuple old_key_tup,
@@ -2367,7 +2367,6 @@ Oid
 heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 			int options, BulkInsertState bistate, TransactionId xid)
 {
-	bool		isFrozen = (xid == FrozenTransactionId);
 	HeapTuple	heaptup;
 	Buffer		buffer;
 	Buffer		vmbuffer = InvalidBuffer;
@@ -2389,7 +2388,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 	 * Note: below this point, heaptup is the data we actually intend to store
 	 * into the relation; tup is the caller's original untoasted data.
 	 */
-	heaptup = heap_prepare_insert(relation, tup, xid, cid, options, isFrozen);
+	heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
 
 	/*
 	 * Find buffer to insert this tuple into.  If the page is all visible,
@@ -2527,10 +2526,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 			rdata[1].buffer = rdata[2].buffer = rdata[3].buffer = InvalidBuffer;
 		}
 
-		if (!isFrozen)
-			recptr = XLogInsert(RM_HEAP_ID, info, rdata);
-		else
-			recptr = XLogInsert_OverrideXid(RM_HEAP_ID, info, rdata, FrozenTransactionId);
+		recptr = XLogInsert(RM_HEAP_ID, info, rdata);
 
 		PageSetLSN(page, recptr);
 	}
@@ -2586,7 +2582,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
  */
 static HeapTuple
 heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
-					CommandId cid, int options, bool isFrozen)
+					CommandId cid, int options)
 {
 	Insist(RelationIsHeap(relation));
 
@@ -2632,8 +2628,6 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
 	}
 
 	tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
-	if (isFrozen)
-		tup->t_data->t_infomask |= HEAP_XMIN_COMMITTED;
 	tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
 	tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
 	HeapTupleHeaderSetXmin(tup->t_data, xid);
@@ -2656,7 +2650,7 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
 	}
 	else if (HeapTupleHasExternal(tup) || tup->t_len > TOAST_TUPLE_THRESHOLD)
 		return toast_insert_or_update(relation, tup, NULL,
-									  TOAST_TUPLE_TARGET, isFrozen,
+									  TOAST_TUPLE_TARGET,
 									  options);
 	else
 		return tup;
@@ -2677,7 +2671,6 @@ void
 heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 				  CommandId cid, int options, BulkInsertState bistate, TransactionId xid)
 {
-	bool        isFrozen = (xid == FrozenTransactionId);
 	HeapTuple  *heaptuples;
 	int			i;
 	int			ndone;
@@ -2699,7 +2692,7 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 	heaptuples = palloc(ntuples * sizeof(HeapTuple));
 	for (i = 0; i < ntuples; i++)
 		heaptuples[i] = heap_prepare_insert(relation, tuples[i],
-											xid, cid, options, isFrozen);
+											xid, cid, options);
 
 	/*
 	 * We're about to do the actual inserts -- but check for conflict first,
@@ -3408,7 +3401,7 @@ heap_delete(Relation relation, ItemPointer tid,
 				xlrec.flags |= XLOG_HEAP_CONTAINS_OLD_KEY;
 		}
 
-		recptr = XLogInsert_OverrideXid(RM_HEAP_ID, XLOG_HEAP_DELETE, rdata, xid);
+		recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE, rdata);
 
 		PageSetLSN(page, recptr);
 	}
@@ -4111,7 +4104,7 @@ heap_update_internal(Relation relation, ItemPointer otid, HeapTuple newtup,
 		{
 			/* Note we always use WAL and FSM during updates */
 			heaptup = toast_insert_or_update(relation, newtup, &oldtup,
-											 TOAST_TUPLE_TARGET, false, 0);
+											 TOAST_TUPLE_TARGET, 0);
 			newtupsize = MAXALIGN(heaptup->t_len);
 		}
 		else
diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index da5d6ddf4d5d..64bc5de462ea 100644
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -666,7 +666,7 @@ raw_heap_insert(RewriteState state, HeapTuple tup)
 		options |= HEAP_INSERT_NO_LOGICAL;
 
 		heaptup = toast_insert_or_update(state->rs_new_rel, tup, NULL,
-										 TOAST_TUPLE_TARGET, false,
+										 TOAST_TUPLE_TARGET,
 										 options);
 	}
 	else
diff --git a/src/backend/access/heap/tuptoaster.c b/src/backend/access/heap/tuptoaster.c
index 02045d7415ff..35df197ec18a 100644
--- a/src/backend/access/heap/tuptoaster.c
+++ b/src/backend/access/heap/tuptoaster.c
@@ -48,7 +48,7 @@
 
 static void toast_delete_datum(Relation rel, Datum value);
 static Datum toast_save_datum(Relation rel, Datum value,
-				 struct varlena * oldexternal, bool isFrozen, int options);
+				 struct varlena * oldexternal, int options);
 static bool toastrel_valueid_exists(Relation toastrel, Oid valueid);
 static bool toastid_valueid_exists(Oid toastrelid, Oid valueid);
 static struct varlena *toast_fetch_datum(struct varlena * attr);
@@ -623,8 +623,7 @@ compute_dest_tuplen(TupleDesc tupdesc, MemTupleBinding *pbind, bool hasnull, Dat
 
 static GenericTuple
 toast_insert_or_update_generic(Relation rel, GenericTuple newtup, GenericTuple oldtup,
-					   MemTupleBinding *pbind, int toast_tuple_target,
-					   bool isFrozen, int options)
+					   MemTupleBinding *pbind, int toast_tuple_target, int options)
 {
 	GenericTuple result_gtuple;
 	TupleDesc	tupleDesc;
@@ -919,7 +918,7 @@ toast_insert_or_update_generic(Relation rel, GenericTuple newtup, GenericTuple o
 			old_value = toast_values[i];
 			toast_action[i] = 'p';
 			toast_values[i] = toast_save_datum(rel, toast_values[i],
-											   toast_oldexternal[i], isFrozen, options);
+											   toast_oldexternal[i], options);
 			if (toast_free[i])
 				pfree(DatumGetPointer(old_value));
 			toast_free[i] = true;
@@ -970,7 +969,7 @@ toast_insert_or_update_generic(Relation rel, GenericTuple newtup, GenericTuple o
 		old_value = toast_values[i];
 		toast_action[i] = 'p';
 		toast_values[i] = toast_save_datum(rel, toast_values[i],
-										   toast_oldexternal[i], isFrozen, options);
+										   toast_oldexternal[i], options);
 		if (toast_free[i])
 			pfree(DatumGetPointer(old_value));
 		toast_free[i] = true;
@@ -1092,7 +1091,7 @@ toast_insert_or_update_generic(Relation rel, GenericTuple newtup, GenericTuple o
 		old_value = toast_values[i];
 		toast_action[i] = 'p';
 		toast_values[i] = toast_save_datum(rel, toast_values[i],
-										   toast_oldexternal[i], isFrozen, options);
+										   toast_oldexternal[i], options);
 		if (toast_free[i])
 			pfree(DatumGetPointer(old_value));
 		toast_free[i] = true;
@@ -1207,28 +1206,26 @@ toast_insert_or_update_generic(Relation rel, GenericTuple newtup, GenericTuple o
 HeapTuple
 toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
 					   int toast_tuple_target,
-					   bool isFrozen, int options)
+					   int options)
 {
 	return (HeapTuple) toast_insert_or_update_generic(rel,
 													  (GenericTuple) newtup,
 													  (GenericTuple) oldtup,
 													  NULL,
 													  toast_tuple_target,
-													  isFrozen,
 													  options);
 }
 
 MemTuple
 toast_insert_or_update_memtup(Relation rel, MemTuple newtup, MemTuple oldtup,
 					   MemTupleBinding *pbind, int toast_tuple_target,
-					   bool isFrozen, int options)
+					   int options)
 {
 	return (MemTuple) toast_insert_or_update_generic(rel,
 													 (GenericTuple) newtup,
 													 (GenericTuple) oldtup,
 													 pbind,
 													 toast_tuple_target,
-													 isFrozen,
 													 options);
 }
 
@@ -1555,7 +1552,7 @@ toast_get_valid_index(Oid toastoid, LOCKMODE lock)
  */
 static Datum
 toast_save_datum(Relation rel, Datum value,
-				 struct varlena * oldexternal, bool isFrozen, int options)
+				 struct varlena * oldexternal, int options)
 {
 	Relation	toastrel;
 	Relation   *toastidxs;
@@ -1788,17 +1785,9 @@ toast_save_datum(Relation rel, Datum value,
 		memcpy(VARDATA(&chunk_data), data_p, chunk_size);
 		toasttup = heap_form_tuple(toasttupDesc, t_values, t_isnull);
 
-		if (!isFrozen)
-		{
-			/* the normal case. regular insert */
-			heap_insert(toastrel, toasttup, mycid, options, NULL, myxid);
-		}
-		else
-		{
-			/* insert and freeze the tuple. used for errtables and their related toast data */
-			frozen_heap_insert(toastrel, toasttup);
-		}
-			
+		/* the normal case. regular insert */
+		heap_insert(toastrel, toasttup, mycid, options, NULL, myxid);
+
 		/*
 		 * Create the index entry.  We cheat a little here by not using
 		 * FormIndexDatum: this relies on the knowledge that the index columns
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index f8397f89d7d9..7f9782d34ae7 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -953,13 +953,6 @@ XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata)
 	return XLogInsert_Internal(rmid, info, rdata, GetCurrentTransactionIdIfAny());
 }
 
-XLogRecPtr
-XLogInsert_OverrideXid(RmgrId rmid, uint8 info, XLogRecData *rdata, TransactionId overrideXid)
-{
-	return XLogInsert_Internal(rmid, info, rdata, overrideXid);
-}
-
-
 static XLogRecPtr
 XLogInsert_Internal(RmgrId rmid, uint8 info, XLogRecData *rdata, TransactionId headerXid)
 {
diff --git a/src/include/access/tuptoaster.h b/src/include/access/tuptoaster.h
index 22ef28a78c9a..ce93bbee2a18 100644
--- a/src/include/access/tuptoaster.h
+++ b/src/include/access/tuptoaster.h
@@ -148,13 +148,12 @@ do { \
  */
 extern HeapTuple toast_insert_or_update(Relation rel,
 					   HeapTuple newtup, HeapTuple oldtup, 
-					   int toast_tuple_target,
-					   bool isFrozen, int options);
+					   int toast_tuple_target, int options);
 
 extern MemTuple toast_insert_or_update_memtup(Relation rel,
 							  MemTuple newtup, MemTuple oldtup, 
 							  MemTupleBinding *pbind, int toast_tuple_target,
-							  bool isFrozen, int options);
+							  int options);
 
 /* ----------
  * toast_delete -
diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index ede0e2b052f6..9e8a366b38da 100644
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -305,7 +305,6 @@ typedef struct CheckpointStatsData
 extern CheckpointStatsData CheckpointStats;
 
 extern XLogRecPtr XLogInsert(RmgrId rmid, uint8 info, XLogRecData *rdata);
-extern XLogRecPtr XLogInsert_OverrideXid(RmgrId rmid, uint8 info, XLogRecData *rdata, TransactionId overrideXid);
 extern XLogRecPtr XLogLastInsertBeginLoc(void);
 extern bool XLogCheckBufferNeedsBackup(Buffer buffer);
 

From 8cf6144161ac2ca26f7f1ec670190c5c20181064 Mon Sep 17 00:00:00 2001
From: Teodor Sigaev <teodor@sigaev.ru>
Date: Mon, 27 Mar 2017 18:34:42 +0300
Subject: [PATCH 15/22] Improve performance of
 find_tabstat_entry()/get_tabstat_entry()

Patch introduces a hash map reloid -> PgStat_TableStatus which improves
performance in case of large number of tables/partitions.

Author: Aleksander Alekseev
Reviewed-by: Andres Freund, Anastasia Lubennikova, Tels, me

https://commitfest.postgresql.org/13/1058/

greenplum 6 specific changes: using HASH_FUNCTION instead of HASH_BLOBS

(cherry picked from commit 090010f2ec9b1f9ac1124dc628b89586f911b641)
---
 src/backend/postmaster/pgstat.c | 140 +++++++++++++++++++++-----------
 1 file changed, 94 insertions(+), 46 deletions(-)

diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index d4ab027c025f..cbc9b147ab9e 100644
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -172,6 +172,20 @@ typedef struct TabStatusArray
 
 static TabStatusArray *pgStatTabList = NULL;
 
+/*
+ * pgStatTabHash entry
+ */
+typedef struct TabStatHashEntry
+{
+	Oid t_id;
+	PgStat_TableStatus* tsa_entry;
+} TabStatHashEntry;
+
+/*
+ * Hash table for O(1) t_id -> tsa_entry lookup
+ */
+static HTAB *pgStatTabHash = NULL;
+
 /*
  * Backends store per-function info that's waiting to be sent to the collector
  * in this hash table (indexed by function OID).
@@ -871,6 +885,14 @@ pgstat_report_stat(bool force)
 		tsa->tsa_used = 0;
 	}
 
+	/*
+	 * pgStatTabHash is outdated on this point so we have to clean it,
+	 * hash_destroy() will remove hash memory context, allocated in
+	 * make_sure_stat_tab_initialized()
+	 */
+	hash_destroy(pgStatTabHash);
+	pgStatTabHash = NULL;
+
 	/*
 	 * Send partial messages.  Make sure that any pending xact commit/abort
 	 * gets counted, even if there are no table stats to send.
@@ -1724,60 +1746,89 @@ pgstat_initstats(Relation rel)
 	rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
 }
 
+/*
+ * Make sure pgStatTabList and pgStatTabHash are initialized.
+ */
+static void
+make_sure_stat_tab_initialized()
+{
+	HASHCTL			ctl;
+	MemoryContext	new_ctx;
+
+	if(!pgStatTabList)
+	{
+		/* This is first time procedure is called */
+		pgStatTabList = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
+												sizeof(TabStatusArray));
+	}
+
+	if(pgStatTabHash)
+		return;
+
+	/* Hash table was freed or never existed.  */
+
+	new_ctx = AllocSetContextCreate(
+		TopMemoryContext,
+		"PGStatLookupHashTableContext",
+		ALLOCSET_DEFAULT_SIZES);
+
+	memset(&ctl, 0, sizeof(ctl));
+	ctl.keysize = sizeof(Oid);
+	ctl.entrysize = sizeof(TabStatHashEntry);
+	ctl.hcxt = new_ctx;
+	ctl.hash = oid_hash;
+
+	pgStatTabHash = hash_create("pgstat t_id to tsa_entry lookup hash table",
+		TABSTAT_QUANTUM, &ctl, HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
+}
+
 /*
  * get_tabstat_entry - find or create a PgStat_TableStatus entry for rel
  */
 static PgStat_TableStatus *
 get_tabstat_entry(Oid rel_id, bool isshared)
 {
+	TabStatHashEntry* hash_entry;
 	PgStat_TableStatus *entry;
 	TabStatusArray *tsa;
-	TabStatusArray *prev_tsa;
-	int			i;
+	bool found;
+
+	make_sure_stat_tab_initialized();
 
 	/*
-	 * Search the already-used tabstat slots for this relation.
+	 * Find an entry or create a new one.
 	 */
-	prev_tsa = NULL;
-	for (tsa = pgStatTabList; tsa != NULL; prev_tsa = tsa, tsa = tsa->tsa_next)
+	hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_ENTER, &found);
+	if(found)
+		return hash_entry->tsa_entry;
+
+	/*
+	 * `hash_entry` was just created and now we have to fill it.
+	 * First make sure there is a free space in a last element of pgStatTabList.
+	 */
+	tsa = pgStatTabList;
+	while(tsa->tsa_used == TABSTAT_QUANTUM)
 	{
-		for (i = 0; i < tsa->tsa_used; i++)
+		if(tsa->tsa_next == NULL)
 		{
-			entry = &tsa->tsa_entries[i];
-			if (entry->t_id == rel_id)
-				return entry;
+			tsa->tsa_next = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
+														sizeof(TabStatusArray));
 		}
 
-		if (tsa->tsa_used < TABSTAT_QUANTUM)
-		{
-			/*
-			 * It must not be present, but we found a free slot instead. Fine,
-			 * let's use this one.  We assume the entry was already zeroed,
-			 * either at creation or after last use.
-			 */
-			entry = &tsa->tsa_entries[tsa->tsa_used++];
-			entry->t_id = rel_id;
-			entry->t_shared = isshared;
-			return entry;
-		}
+		tsa = tsa->tsa_next;
 	}
 
 	/*
-	 * We ran out of tabstat slots, so allocate more.  Be sure they're zeroed.
-	 */
-	tsa = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
-													sizeof(TabStatusArray));
-	if (prev_tsa)
-		prev_tsa->tsa_next = tsa;
-	else
-		pgStatTabList = tsa;
-
-	/*
-	 * Use the first entry of the new TabStatusArray.
+	 * Add an entry.
 	 */
 	entry = &tsa->tsa_entries[tsa->tsa_used++];
 	entry->t_id = rel_id;
 	entry->t_shared = isshared;
+
+	/*
+	 * Add a corresponding entry to pgStatTabHash.
+	 */
+	hash_entry->tsa_entry = entry;
 	return entry;
 }
 
@@ -1789,22 +1840,19 @@ get_tabstat_entry(Oid rel_id, bool isshared)
 PgStat_TableStatus *
 find_tabstat_entry(Oid rel_id)
 {
-	PgStat_TableStatus *entry;
-	TabStatusArray *tsa;
-	int			i;
+	TabStatHashEntry* hash_entry;
 
-	for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
-	{
-		for (i = 0; i < tsa->tsa_used; i++)
-		{
-			entry = &tsa->tsa_entries[i];
-			if (entry->t_id == rel_id)
-				return entry;
-		}
-	}
+	/*
+	 * There are no entries at all.
+	 */
+	if(!pgStatTabHash)
+		return NULL;
 
-	/* Not present */
-	return NULL;
+	hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_FIND, NULL);
+	if(!hash_entry)
+		return NULL;
+
+	return hash_entry->tsa_entry;
 }
 
 /*

From fc87ae5b3bfb46220b153eefba769ee36af02dcd Mon Sep 17 00:00:00 2001
From: Tom Lane <tgl@sss.pgh.pa.us>
Date: Sun, 14 May 2017 22:52:41 -0400
Subject: [PATCH 16/22] Make pgstat tabstat lookup hash table less fragile.

Code review for commit 090010f2e.

Fix cases where an elog(ERROR) partway through a function would leave the
persistent data structures in a corrupt state.  pgstat_report_stat got this
wrong by invalidating PgStat_TableEntry structs before removing hashtable
entries pointing to them, and get_tabstat_entry got it wrong by ignoring
the possibility of palloc failure after it had already created a hashtable
entry.

Also, avoid leaking a memory context per transaction, which the previous
code did through misunderstanding hash_create's API.  We do not need to
create a context to hold the hash table; hash_create will do that.
(The leak wasn't that large, amounting to only a memory context header
per iteration, but it's still surprising that nobody noticed it yet.)

greenplum 6 specific changes: using HASH_FUNCTION instead of HASH_BLOBS

(cherry picked from commit 5d00b764cd682f6071b35033f508a431d9d3f920)
---
 src/backend/postmaster/pgstat.c | 126 ++++++++++++++++----------------
 1 file changed, 65 insertions(+), 61 deletions(-)

diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index cbc9b147ab9e..be85d76d63e3 100644
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -173,7 +173,7 @@ typedef struct TabStatusArray
 static TabStatusArray *pgStatTabList = NULL;
 
 /*
- * pgStatTabHash entry
+ * pgStatTabHash entry: map from relation OID to PgStat_TableStatus pointer
  */
 typedef struct TabStatHashEntry
 {
@@ -835,6 +835,17 @@ pgstat_report_stat(bool force)
 		return;
 	last_report = now;
 
+	/*
+	 * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
+	 * entries it points to.  (Should we fail partway through the loop below,
+	 * it's okay to have removed the hashtable already --- the only
+	 * consequence is we'd get multiple entries for the same table in the
+	 * pgStatTabList, and that's safe.)
+	 */
+	if (pgStatTabHash)
+		hash_destroy(pgStatTabHash);
+	pgStatTabHash = NULL;
+
 	/*
 	 * Scan through the TabStatusArray struct(s) to find tables that actually
 	 * have counts, and build messages to send.  We have to separate shared
@@ -885,14 +896,6 @@ pgstat_report_stat(bool force)
 		tsa->tsa_used = 0;
 	}
 
-	/*
-	 * pgStatTabHash is outdated on this point so we have to clean it,
-	 * hash_destroy() will remove hash memory context, allocated in
-	 * make_sure_stat_tab_initialized()
-	 */
-	hash_destroy(pgStatTabHash);
-	pgStatTabHash = NULL;
-
 	/*
 	 * Send partial messages.  Make sure that any pending xact commit/abort
 	 * gets counted, even if there are no table stats to send.
@@ -1746,42 +1749,6 @@ pgstat_initstats(Relation rel)
 	rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
 }
 
-/*
- * Make sure pgStatTabList and pgStatTabHash are initialized.
- */
-static void
-make_sure_stat_tab_initialized()
-{
-	HASHCTL			ctl;
-	MemoryContext	new_ctx;
-
-	if(!pgStatTabList)
-	{
-		/* This is first time procedure is called */
-		pgStatTabList = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
-												sizeof(TabStatusArray));
-	}
-
-	if(pgStatTabHash)
-		return;
-
-	/* Hash table was freed or never existed.  */
-
-	new_ctx = AllocSetContextCreate(
-		TopMemoryContext,
-		"PGStatLookupHashTableContext",
-		ALLOCSET_DEFAULT_SIZES);
-
-	memset(&ctl, 0, sizeof(ctl));
-	ctl.keysize = sizeof(Oid);
-	ctl.entrysize = sizeof(TabStatHashEntry);
-	ctl.hcxt = new_ctx;
-	ctl.hash = oid_hash;
-
-	pgStatTabHash = hash_create("pgstat t_id to tsa_entry lookup hash table",
-		TABSTAT_QUANTUM, &ctl, HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
-}
-
 /*
  * get_tabstat_entry - find or create a PgStat_TableStatus entry for rel
  */
@@ -1793,42 +1760,76 @@ get_tabstat_entry(Oid rel_id, bool isshared)
 	TabStatusArray *tsa;
 	bool found;
 
-	make_sure_stat_tab_initialized();
+	/*
+	 * Create hash table if we don't have it already.
+	 */
+	if (pgStatTabHash == NULL)
+	{
+		HASHCTL			ctl;
+
+		memset(&ctl, 0, sizeof(ctl));
+		ctl.keysize = sizeof(Oid);
+		ctl.entrysize = sizeof(TabStatHashEntry);
+		ctl.hash = oid_hash;
+
+		pgStatTabHash = hash_create("pgstat TabStatusArray lookup hash table",
+									TABSTAT_QUANTUM,
+									&ctl,
+									HASH_ELEM | HASH_FUNCTION);
+	}
 
 	/*
 	 * Find an entry or create a new one.
 	 */
 	hash_entry = hash_search(pgStatTabHash, &rel_id, HASH_ENTER, &found);
-	if(found)
+	if (!found)
+	{
+		/* initialize new entry with null pointer */
+		hash_entry->tsa_entry = NULL;
+	}
+
+	/*
+	 * If entry is already valid, we're done.
+	 */
+	if (hash_entry->tsa_entry)
 		return hash_entry->tsa_entry;
 
 	/*
-	 * `hash_entry` was just created and now we have to fill it.
-	 * First make sure there is a free space in a last element of pgStatTabList.
+	 * Locate the first pgStatTabList entry with free space, making a new list
+	 * entry if needed.  Note that we could get an OOM failure here, but if so
+	 * we have left the hashtable and the list in a consistent state.
 	 */
-	tsa = pgStatTabList;
-	while(tsa->tsa_used == TABSTAT_QUANTUM)
+	if (pgStatTabList == NULL)
 	{
-		if(tsa->tsa_next == NULL)
-		{
-			tsa->tsa_next = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
-														sizeof(TabStatusArray));
-		}
+		/* Set up first pgStatTabList entry */
+		pgStatTabList = (TabStatusArray *)
+			MemoryContextAllocZero(TopMemoryContext,
+								   sizeof(TabStatusArray));
+	}
 
+	tsa = pgStatTabList;
+	while (tsa->tsa_used >= TABSTAT_QUANTUM)
+	{
+		if (tsa->tsa_next == NULL)
+			tsa->tsa_next = (TabStatusArray *)
+				MemoryContextAllocZero(TopMemoryContext,
+									   sizeof(TabStatusArray));
 		tsa = tsa->tsa_next;
 	}
 
 	/*
-	 * Add an entry.
+	 * Allocate a PgStat_TableStatus entry within this list entry.  We assume
+	 * the entry was already zeroed, either at creation or after last use.
 	 */
 	entry = &tsa->tsa_entries[tsa->tsa_used++];
 	entry->t_id = rel_id;
 	entry->t_shared = isshared;
 
 	/*
-	 * Add a corresponding entry to pgStatTabHash.
+	 * Now we can fill the entry in pgStatTabHash.
 	 */
 	hash_entry->tsa_entry = entry;
+
 	return entry;
 }
 
@@ -1836,15 +1837,17 @@ get_tabstat_entry(Oid rel_id, bool isshared)
  * find_tabstat_entry - find any existing PgStat_TableStatus entry for rel
  *
  * If no entry, return NULL, don't create a new one
+ *
+ * Note: if we got an error in the most recent execution of pgstat_report_stat,
+ * it's possible that an entry exists but there's no hashtable entry for it.
+ * That's okay, we'll treat this case as "doesn't exist".
  */
 PgStat_TableStatus *
 find_tabstat_entry(Oid rel_id)
 {
 	TabStatHashEntry* hash_entry;
 
-	/*
-	 * There are no entries at all.
-	 */
+	/* If hashtable doesn't exist, there are no entries at all */
 	if(!pgStatTabHash)
 		return NULL;
 
@@ -1852,6 +1855,7 @@ find_tabstat_entry(Oid rel_id)
 	if(!hash_entry)
 		return NULL;
 
+	/* Note that this step could also return NULL, but that's correct */
 	return hash_entry->tsa_entry;
 }
 

From 38c8f80aad843ef11966e3b44f17d2fc5b528363 Mon Sep 17 00:00:00 2001
From: Georgy Shelkovy <g.shelkovy@arenadata.io>
Date: Fri, 17 Nov 2023 13:26:42 +0500
Subject: [PATCH 17/22] Implement vacuum/analyze ordering functions for
 arenadata_toolkit (#641)

This patch extends the functionality of the arenadata_toolkit extension
by adding two functions to obtain different table orders for vacuum/analyze.
These two functions are planned to be used in the vacuum command in
the operation.py script. By default, the bundle will use the current approach,
in which new tables are placed at the beginning of the list. But users will
be able to reconfigure it to use a second function that places new tables
at the end of the list, or even use a custom query to determine the order.
---
 gpcontrib/arenadata_toolkit/Makefile          |  7 ++-
 .../arenadata_toolkit--1.2--1.3.sql           | 62 +++++++++++++++++++
 .../arenadata_toolkit.control                 |  2 +-
 .../expected/adb_vacuum_strategy_test.out     | 56 +++++++++++++++++
 .../expected/arenadata_toolkit_test.out       | 20 ++++--
 .../sql/adb_vacuum_strategy_test.sql          | 40 ++++++++++++
 6 files changed, 179 insertions(+), 8 deletions(-)
 create mode 100644 gpcontrib/arenadata_toolkit/arenadata_toolkit--1.2--1.3.sql
 create mode 100644 gpcontrib/arenadata_toolkit/expected/adb_vacuum_strategy_test.out
 create mode 100644 gpcontrib/arenadata_toolkit/sql/adb_vacuum_strategy_test.sql

diff --git a/gpcontrib/arenadata_toolkit/Makefile b/gpcontrib/arenadata_toolkit/Makefile
index 97a38ebfdcc2..98698fd9f123 100644
--- a/gpcontrib/arenadata_toolkit/Makefile
+++ b/gpcontrib/arenadata_toolkit/Makefile
@@ -3,11 +3,12 @@
 MODULES = arenadata_toolkit
 
 EXTENSION = arenadata_toolkit
-EXTENSION_VERSION = 1.2
+EXTENSION_VERSION = 1.3
 DATA = \
        arenadata_toolkit--1.0.sql \
        arenadata_toolkit--1.0--1.1.sql \
-       arenadata_toolkit--1.1--1.2.sql
+       arenadata_toolkit--1.1--1.2.sql \
+       arenadata_toolkit--1.2--1.3.sql
 
 DATA_built = $(EXTENSION)--$(EXTENSION_VERSION).sql
 
@@ -15,7 +16,7 @@ $(DATA_built): $(DATA)
 	cat $(DATA) > $(DATA_built)
 
 REGRESS = arenadata_toolkit_test arenadata_toolkit_skew_test adb_get_relfilenodes_test \
-          adb_collect_table_stats_test
+          adb_collect_table_stats_test adb_vacuum_strategy_test
 REGRESS_OPTS += --init-file=$(top_srcdir)/src/test/regress/init_file
 
 ifdef USE_PGXS
diff --git a/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.2--1.3.sql b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.2--1.3.sql
new file mode 100644
index 000000000000..bd787bc4bd92
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/arenadata_toolkit--1.2--1.3.sql
@@ -0,0 +1,62 @@
+/* gpcontrib/arenadata_toolkit/arenadata_toolkit--1.2--1.3.sql */
+
+/*
+ * Returns columns (table_schema, table_name) ordered by increasing vacuum time. In this
+ * list, if newest_first is true, then tables that are not yet vacuumed are located first,
+ * and already vacuumed - at the end, else (newest_first is false) tables that are already
+ * vacuumed are located first, and tables that are not yet vacuumed are located at the end.
+ */
+CREATE FUNCTION arenadata_toolkit.adb_vacuum_strategy(actionname TEXT, newest_first BOOLEAN)
+RETURNS TABLE (table_schema NAME, table_name NAME) AS
+$func$
+BEGIN
+	RETURN query EXECUTE format($$
+	SELECT nspname, relname
+	FROM pg_catalog.pg_class c
+		JOIN pg_catalog.pg_namespace n ON relnamespace = n.oid
+		LEFT JOIN pg_catalog.pg_partition_rule ON parchildrelid = c.oid
+		LEFT JOIN pg_catalog.pg_stat_last_operation ON staactionname = UPPER(%L)
+			AND objid = c.oid AND classid = 'pg_catalog.pg_class'::pg_catalog.regclass
+	WHERE relkind = 'r' AND relstorage != 'x' AND parchildrelid IS NULL
+		AND nspname NOT IN (SELECT schema_name FROM arenadata_toolkit.operation_exclude)
+	ORDER BY statime ASC NULLS %s
+	$$, actionname, CASE WHEN newest_first THEN 'FIRST' ELSE 'LAST' END);
+END;
+$func$ LANGUAGE plpgsql STABLE EXECUTE ON MASTER;
+
+/*
+ * Only for admin usage.
+ */
+REVOKE ALL ON FUNCTION arenadata_toolkit.adb_vacuum_strategy(TEXT, BOOLEAN) FROM public;
+
+/*
+ * Returns columns (table_schema, table_name) ordered by increasing vacuum time.
+ * In this list, tables that are not yet vacuumed are located first,
+ * and already vacuumed - at the end (default strategy).
+ */
+CREATE FUNCTION arenadata_toolkit.adb_vacuum_strategy_newest_first(actionname TEXT)
+RETURNS TABLE (table_schema NAME, table_name NAME) AS
+$$
+	SELECT arenadata_toolkit.adb_vacuum_strategy(actionname, true);
+$$ LANGUAGE sql STABLE EXECUTE ON MASTER;
+
+/*
+ * Only for admin usage.
+ */
+REVOKE ALL ON FUNCTION arenadata_toolkit.adb_vacuum_strategy_newest_first(TEXT) FROM public;
+
+/*
+ * Returns columns (table_schema, table_name) ordered by increasing vacuum time.
+ * In this list, tables that are already vacuumed are located first,
+ * and tables that are not yet vacuumed are located at the end.
+ */
+CREATE FUNCTION arenadata_toolkit.adb_vacuum_strategy_newest_last(actionname TEXT)
+RETURNS TABLE (table_schema NAME, table_name NAME) AS
+$$
+	SELECT arenadata_toolkit.adb_vacuum_strategy(actionname, false);
+$$ LANGUAGE sql STABLE EXECUTE ON MASTER;
+
+/*
+ * Only for admin usage.
+ */
+REVOKE ALL ON FUNCTION arenadata_toolkit.adb_vacuum_strategy_newest_last(TEXT) FROM public;
diff --git a/gpcontrib/arenadata_toolkit/arenadata_toolkit.control b/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
index 69986410bab2..505f3ad1ad62 100644
--- a/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
+++ b/gpcontrib/arenadata_toolkit/arenadata_toolkit.control
@@ -1,5 +1,5 @@
 # arenadata_toolkit extension
 comment = 'extension is used for manipulation of objects created by adb-bundle'
-default_version = '1.2'
+default_version = '1.3'
 module_pathname = '$libdir/arenadata_toolkit'
 relocatable = false
diff --git a/gpcontrib/arenadata_toolkit/expected/adb_vacuum_strategy_test.out b/gpcontrib/arenadata_toolkit/expected/adb_vacuum_strategy_test.out
new file mode 100644
index 000000000000..0c577198c042
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/expected/adb_vacuum_strategy_test.out
@@ -0,0 +1,56 @@
+CREATE EXTENSION arenadata_toolkit;
+SELECT arenadata_toolkit.adb_create_tables();
+ adb_create_tables 
+-------------------
+ 
+(1 row)
+
+CREATE SCHEMA test_vacuum;
+CREATE TABLE test_vacuum.vacuumed (a int) DISTRIBUTED BY (a);
+CREATE TABLE test_vacuum.not_vacuumed (a int) DISTRIBUTED BY (a);
+-- Disable multiple notifications about the creation of multiple subpartitions.
+SET client_min_messages=WARNING;
+CREATE TABLE test_vacuum.part_table (id INT, a INT, b INT, c INT, d INT, str TEXT)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (a)
+	SUBPARTITION BY RANGE (b)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (c)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (d)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY LIST (str)
+		SUBPARTITION TEMPLATE (
+			SUBPARTITION sub_prt1 VALUES ('sub_prt1'),
+			SUBPARTITION sub_prt2 VALUES ('sub_prt2'))
+	(START (1) END (3) EVERY (1));
+RESET client_min_messages;
+INSERT INTO test_vacuum.vacuumed SELECT generate_series(1, 10);
+INSERT INTO test_vacuum.not_vacuumed SELECT generate_series(1, 10);
+DELETE FROM test_vacuum.vacuumed WHERE a >= 5;
+DELETE FROM test_vacuum.not_vacuumed WHERE a >= 5;
+VACUUM test_vacuum.vacuumed;
+-- default strategy
+SELECT * FROM arenadata_toolkit.adb_vacuum_strategy_newest_first('VACUUM') WHERE table_schema = 'test_vacuum';
+ table_schema |  table_name  
+--------------+--------------
+ test_vacuum  | part_table
+ test_vacuum  | not_vacuumed
+ test_vacuum  | vacuumed
+(3 rows)
+
+-- reversed strategy
+SELECT * FROM arenadata_toolkit.adb_vacuum_strategy_newest_last('VACUUM') WHERE table_schema = 'test_vacuum';
+ table_schema |  table_name  
+--------------+--------------
+ test_vacuum  | vacuumed
+ test_vacuum  | not_vacuumed
+ test_vacuum  | part_table
+(3 rows)
+
+DROP SCHEMA test_vacuum CASCADE;
+NOTICE:  drop cascades to 3 other objects
+DETAIL:  drop cascades to table test_vacuum.vacuumed
+drop cascades to table test_vacuum.not_vacuumed
+drop cascades to table test_vacuum.part_table
+DROP EXTENSION arenadata_toolkit;
diff --git a/gpcontrib/arenadata_toolkit/expected/arenadata_toolkit_test.out b/gpcontrib/arenadata_toolkit/expected/arenadata_toolkit_test.out
index f4e2ad78f3df..4977ab778832 100644
--- a/gpcontrib/arenadata_toolkit/expected/arenadata_toolkit_test.out
+++ b/gpcontrib/arenadata_toolkit/expected/arenadata_toolkit_test.out
@@ -96,6 +96,9 @@ SELECT objname, objtype, objstorage, objacl FROM toolkit_objects_info ORDER BY o
  adb_relation_storage_size             | proc    | -          | {=X/owner,owner=X/owner}
  adb_relation_storage_size_on_segments | proc    | -          | {=X/owner,owner=X/owner}
  adb_skew_coefficients                 | table   | v          | {owner=arwdDxt/owner,=r/owner}
+ adb_vacuum_strategy                   | proc    | -          | {owner=X/owner}
+ adb_vacuum_strategy_newest_first      | proc    | -          | {owner=X/owner}
+ adb_vacuum_strategy_newest_last       | proc    | -          | {owner=X/owner}
  arenadata_toolkit                     | schema  | -          | {owner=UC/owner,=U/owner}
  daily_operation                       | table   | a          | 
  db_files_current                      | table   | h          | {owner=arwdDxt/owner,=r/owner}
@@ -103,7 +106,7 @@ SELECT objname, objtype, objstorage, objacl FROM toolkit_objects_info ORDER BY o
  db_files_history_1_prt_default_part   | table   | a          | 
  db_files_history_1_prt_pYYYYMM        | table   | a          | 
  operation_exclude                     | table   | a          | 
-(16 rows)
+(19 rows)
 
 -- check that toolkit objects now depends on extension
 SELECT objname, objtype, extname, deptype FROM pg_depend d JOIN
@@ -121,7 +124,10 @@ WHERE d.deptype = 'e' AND e.extname = 'arenadata_toolkit' ORDER BY objname;
  adb_relation_storage_size             | proc    | arenadata_toolkit | e
  adb_relation_storage_size_on_segments | proc    | arenadata_toolkit | e
  adb_skew_coefficients                 | table   | arenadata_toolkit | e
-(9 rows)
+ adb_vacuum_strategy                   | proc    | arenadata_toolkit | e
+ adb_vacuum_strategy_newest_first      | proc    | arenadata_toolkit | e
+ adb_vacuum_strategy_newest_last       | proc    | arenadata_toolkit | e
+(12 rows)
 
 DROP EXTENSION arenadata_toolkit;
 DROP SCHEMA arenadata_toolkit cascade;
@@ -149,6 +155,9 @@ SELECT objname, objtype, objstorage, objacl FROM toolkit_objects_info ORDER BY o
  adb_relation_storage_size             | proc    | -          | {=X/owner,owner=X/owner}
  adb_relation_storage_size_on_segments | proc    | -          | {=X/owner,owner=X/owner}
  adb_skew_coefficients                 | table   | v          | {owner=arwdDxt/owner,=r/owner}
+ adb_vacuum_strategy                   | proc    | -          | {owner=X/owner}
+ adb_vacuum_strategy_newest_first      | proc    | -          | {owner=X/owner}
+ adb_vacuum_strategy_newest_last       | proc    | -          | {owner=X/owner}
  arenadata_toolkit                     | schema  | -          | {owner=UC/owner,=U/owner}
  daily_operation                       | table   | a          | {owner=arwdDxt/owner}
  db_files_current                      | table   | h          | {owner=arwdDxt/owner,=r/owner}
@@ -156,7 +165,7 @@ SELECT objname, objtype, objstorage, objacl FROM toolkit_objects_info ORDER BY o
  db_files_history_1_prt_default_part   | table   | a          | {owner=arwdDxt/owner}
  db_files_history_1_prt_pYYYYMM        | table   | a          | {owner=arwdDxt/owner}
  operation_exclude                     | table   | a          | {owner=arwdDxt/owner}
-(16 rows)
+(19 rows)
 
 -- check that toolkit objects now depends on extension
 SELECT objname, objtype, extname, deptype FROM pg_depend d JOIN
@@ -174,7 +183,10 @@ WHERE d.deptype = 'e' AND e.extname = 'arenadata_toolkit' ORDER BY objname;
  adb_relation_storage_size             | proc    | arenadata_toolkit | e
  adb_relation_storage_size_on_segments | proc    | arenadata_toolkit | e
  adb_skew_coefficients                 | table   | arenadata_toolkit | e
-(9 rows)
+ adb_vacuum_strategy                   | proc    | arenadata_toolkit | e
+ adb_vacuum_strategy_newest_first      | proc    | arenadata_toolkit | e
+ adb_vacuum_strategy_newest_last       | proc    | arenadata_toolkit | e
+(12 rows)
 
 DROP EXTENSION arenadata_toolkit;
 DROP SCHEMA arenadata_toolkit cascade;
diff --git a/gpcontrib/arenadata_toolkit/sql/adb_vacuum_strategy_test.sql b/gpcontrib/arenadata_toolkit/sql/adb_vacuum_strategy_test.sql
new file mode 100644
index 000000000000..9d2ccb03a8cd
--- /dev/null
+++ b/gpcontrib/arenadata_toolkit/sql/adb_vacuum_strategy_test.sql
@@ -0,0 +1,40 @@
+CREATE EXTENSION arenadata_toolkit;
+SELECT arenadata_toolkit.adb_create_tables();
+
+CREATE SCHEMA test_vacuum;
+
+CREATE TABLE test_vacuum.vacuumed (a int) DISTRIBUTED BY (a);
+CREATE TABLE test_vacuum.not_vacuumed (a int) DISTRIBUTED BY (a);
+-- Disable multiple notifications about the creation of multiple subpartitions.
+SET client_min_messages=WARNING;
+CREATE TABLE test_vacuum.part_table (id INT, a INT, b INT, c INT, d INT, str TEXT)
+DISTRIBUTED BY (id)
+PARTITION BY RANGE (a)
+	SUBPARTITION BY RANGE (b)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (c)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY RANGE (d)
+		SUBPARTITION TEMPLATE (START (1) END (3) EVERY (1))
+	SUBPARTITION BY LIST (str)
+		SUBPARTITION TEMPLATE (
+			SUBPARTITION sub_prt1 VALUES ('sub_prt1'),
+			SUBPARTITION sub_prt2 VALUES ('sub_prt2'))
+	(START (1) END (3) EVERY (1));
+RESET client_min_messages;
+
+INSERT INTO test_vacuum.vacuumed SELECT generate_series(1, 10);
+INSERT INTO test_vacuum.not_vacuumed SELECT generate_series(1, 10);
+
+DELETE FROM test_vacuum.vacuumed WHERE a >= 5;
+DELETE FROM test_vacuum.not_vacuumed WHERE a >= 5;
+
+VACUUM test_vacuum.vacuumed;
+
+-- default strategy
+SELECT * FROM arenadata_toolkit.adb_vacuum_strategy_newest_first('VACUUM') WHERE table_schema = 'test_vacuum';
+-- reversed strategy
+SELECT * FROM arenadata_toolkit.adb_vacuum_strategy_newest_last('VACUUM') WHERE table_schema = 'test_vacuum';
+
+DROP SCHEMA test_vacuum CASCADE;
+DROP EXTENSION arenadata_toolkit;

From 120aaef599cf4cce1fac430b833a1b74b4a5d8bd Mon Sep 17 00:00:00 2001
From: Viktor Kurilko <murlockkinght@gmail.com>
Date: Fri, 24 Nov 2023 20:04:24 +0300
Subject: [PATCH 18/22] Fix CTEs with volatile target list for case of
 SegmentGeneral and General locuses (#633)

Plan nodes with the General and SegmentGeneral locus type should return the same
result on each of the segments. But a volatile function does not guarantee the
same result for different calls, and therefore if the target list of a plan node
with General or SegmentGeneral locus type contains a volatile function, then the
locus of such a plan node should be brought to SingleQE. In the current
implementation, plan node with volatile function in target list is brought to
SingleQE not for all subqueries. If volatile function is in target list of CTE,
multiset functions and union/except/intersect then they can hide the volatile
function in the underlying nodes and current implementation can't detect them.
The volatile function can be executed on more than one segment and each of them
will work with a different result set which is not correct.

This patch fixes the error by moving the processing of volatile functions in the
target list for plan nodes with the General and SegmentGeneral locus type to
subquery_planner so that processing is performed for all subqueries.
---
 src/backend/optimizer/path/allpaths.c       |  15 --
 src/backend/optimizer/plan/planner.c        |  18 +++
 src/backend/optimizer/plan/subselect.c      |  15 --
 src/test/regress/expected/bfv_planner.out   | 152 ++++++++++++++++++++
 src/test/regress/expected/rpt.out           | 124 ++++++++++++++++
 src/test/regress/expected/rpt_optimizer.out | 124 ++++++++++++++++
 src/test/regress/sql/bfv_planner.sql        |  50 +++++++
 src/test/regress/sql/rpt.sql                |  48 +++++++
 8 files changed, 516 insertions(+), 30 deletions(-)

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 4319d5973827..f43745159e48 100644
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1717,21 +1717,6 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
 		/* XXX rel->onerow = ??? */
 	}
 
-	if (rel->subplan->flow->locustype == CdbLocusType_General &&
-		(contain_volatile_functions((Node *) rel->subplan->targetlist) ||
-		 contain_volatile_functions(subquery->havingQual)))
-	{
-		rel->subplan->flow->locustype = CdbLocusType_SingleQE;
-		rel->subplan->flow->flotype = FLOW_SINGLETON;
-	}
-
-	if (rel->subplan->flow->locustype == CdbLocusType_SegmentGeneral &&
-		(contain_volatile_functions((Node *) rel->subplan->targetlist) ||
-		 contain_volatile_functions(subquery->havingQual)))
-	{
-		rel->subplan = (Plan *) make_motion_gather(subroot, rel->subplan, NIL, CdbLocusType_SingleQE);
-	}
-
 	rel->subroot = subroot;
 
 	/* Isolate the params needed by this specific subplan */
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 215d43f7b60c..e0b998b9671f 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -923,6 +923,24 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
 		SS_finalize_plan(root, plan, true);
 	}
 
+	/*
+	 * If plan contains volatile functions in the target list, then we need
+	 * bring it to SingleQE
+	 */
+	if (plan->flow->locustype == CdbLocusType_General &&
+		(contain_volatile_functions((Node *) plan->targetlist) ||
+		 contain_volatile_functions(parse->havingQual)))
+	{
+		plan->flow->locustype = CdbLocusType_SingleQE;
+		plan->flow->flotype = FLOW_SINGLETON;
+	}
+	else if (plan->flow->locustype == CdbLocusType_SegmentGeneral &&
+		(contain_volatile_functions((Node *) plan->targetlist) ||
+		 contain_volatile_functions(parse->havingQual)))
+	{
+		plan = (Plan *) make_motion_gather(root, plan, NIL, CdbLocusType_SingleQE);
+	}
+
 	/* Return internal info if caller wants it */
 	if (subroot)
 		*subroot = root;
diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index ceb711d5e93e..1d7253ec35d5 100644
--- a/src/backend/optimizer/plan/subselect.c
+++ b/src/backend/optimizer/plan/subselect.c
@@ -669,21 +669,6 @@ make_subplan(PlannerInfo *root, Query *orig_subquery, SubLinkType subLinkType,
 							&subroot,
 							config);
 
-	if (plan->flow->locustype == CdbLocusType_General &&
-		(contain_volatile_functions((Node *) plan->targetlist) ||
-		 contain_volatile_functions(subquery->havingQual)))
-	{
-		plan->flow->locustype = CdbLocusType_SingleQE;
-		plan->flow->flotype = FLOW_SINGLETON;
-	}
-
-	if (plan->flow->locustype == CdbLocusType_SegmentGeneral &&
-		(contain_volatile_functions((Node *) plan->targetlist) ||
-		 contain_volatile_functions(subquery->havingQual)))
-	{
-		plan = (Plan *) make_motion_gather(subroot, plan, NIL, CdbLocusType_SingleQE);
-	}
-
 	/* Isolate the params needed by this specific subplan */
 	plan_params = root->plan_params;
 	root->plan_params = NIL;
diff --git a/src/test/regress/expected/bfv_planner.out b/src/test/regress/expected/bfv_planner.out
index 6e4f499ae099..d648bcbab34c 100644
--- a/src/test/regress/expected/bfv_planner.out
+++ b/src/test/regress/expected/bfv_planner.out
@@ -566,6 +566,158 @@ explain (costs off) select * from t_hashdist cross join (select * from generate_
  Optimizer: Postgres query optimizer
 (8 rows)
 
+set gp_cte_sharing = on;
+-- ensure that the volatile function is executed on one segment if it is in the CTE target list
+explain (costs off, verbose) with cte as (
+    select a * random() as a from generate_series(1, 5) a
+)
+select * from cte join (select * from t_hashdist join cte using(a)) b using(a);
+                                      QUERY PLAN                                       
+---------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice3; segments: 3)
+   Output: share0_ref1.a, b.b, b.c
+   ->  Hash Join
+         Output: share0_ref1.a, b.b, b.c
+         Hash Cond: (b.a = share0_ref1.a)
+         ->  Subquery Scan on b
+               Output: b.b, b.c, b.a
+               ->  Hash Join
+                     Output: share0_ref2.a, t_hashdist.b, t_hashdist.c
+                     Hash Cond: ((t_hashdist.a)::double precision = share0_ref2.a)
+                     ->  Seq Scan on public.t_hashdist
+                           Output: t_hashdist.b, t_hashdist.c, t_hashdist.a
+                     ->  Hash
+                           Output: share0_ref2.a
+                           ->  Broadcast Motion 1:3  (slice1; segments: 1)
+                                 Output: share0_ref2.a
+                                 ->  Shared Scan (share slice:id 1:0)
+                                       Output: share0_ref2.a
+         ->  Hash
+               Output: share0_ref1.a
+               ->  Broadcast Motion 1:3  (slice2; segments: 1)
+                     Output: share0_ref1.a
+                     ->  Shared Scan (share slice:id 2:0)
+                           Output: share0_ref1.a
+                           ->  Materialize
+                                 Output: (((a.a)::double precision * random()))
+                                 ->  Function Scan on pg_catalog.generate_series a
+                                       Output: ((a.a)::double precision * random())
+                                       Function Call: generate_series(1, 5)
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=on, optimizer=off
+(31 rows)
+
+set gp_cte_sharing = off;
+explain (costs off, verbose) with cte as (
+    select a, a * random() from generate_series(1, 5) a
+)
+select * from cte join t_hashdist using(a);
+                                       QUERY PLAN                                        
+-----------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: a.a, (((a.a)::double precision * random())), t_hashdist.b, t_hashdist.c
+   ->  Hash Join
+         Output: a.a, (((a.a)::double precision * random())), t_hashdist.b, t_hashdist.c
+         Hash Cond: (t_hashdist.a = a.a)
+         ->  Seq Scan on public.t_hashdist
+               Output: t_hashdist.b, t_hashdist.c, t_hashdist.a
+         ->  Hash
+               Output: a.a, (((a.a)::double precision * random()))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: a.a, (((a.a)::double precision * random()))
+                     Hash Key: a.a
+                     ->  Function Scan on pg_catalog.generate_series a
+                           Output: a.a, ((a.a)::double precision * random())
+                           Function Call: generate_series(1, 5)
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=off, optimizer=off
+(17 rows)
+
+reset gp_cte_sharing;
+-- ensure that the volatile function is executed on one segment if it is in the union target list
+explain (costs off, verbose) select * from (
+    select random() as a from generate_series(1, 5)
+    union
+    select random() as a from generate_series(1, 5)
+)
+a join t_hashdist on a.a = t_hashdist.a;
+                                            QUERY PLAN                                             
+---------------------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: (random()), t_hashdist.a, t_hashdist.b, t_hashdist.c
+   ->  Hash Join
+         Output: (random()), t_hashdist.a, t_hashdist.b, t_hashdist.c
+         Hash Cond: ((t_hashdist.a)::double precision = (random()))
+         ->  Seq Scan on public.t_hashdist
+               Output: t_hashdist.a, t_hashdist.b, t_hashdist.c
+         ->  Hash
+               Output: (random())
+               ->  Broadcast Motion 1:3  (slice1; segments: 1)
+                     Output: (random())
+                     ->  HashAggregate
+                           Output: (random())
+                           Group Key: (random())
+                           ->  Append
+                                 ->  Function Scan on pg_catalog.generate_series
+                                       Output: random()
+                                       Function Call: generate_series(1, 5)
+                                 ->  Function Scan on pg_catalog.generate_series generate_series_1
+                                       Output: random()
+                                       Function Call: generate_series(1, 5)
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, optimizer=off
+(23 rows)
+
+-- ensure that the volatile function is executed on one segment if it is in target list of subplan of multiset function
+explain (costs off, verbose) select * from (
+    SELECT count(*) as a FROM anytable_out( TABLE( SELECT random()::int from generate_series(1, 5) a ) )
+) a join t_hashdist using(a);
+                                    QUERY PLAN                                     
+-----------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: (count(*)), t_hashdist.b, t_hashdist.c
+   ->  Hash Join
+         Output: (count(*)), t_hashdist.b, t_hashdist.c
+         Hash Cond: (t_hashdist.a = (count(*)))
+         ->  Seq Scan on public.t_hashdist
+               Output: t_hashdist.b, t_hashdist.c, t_hashdist.a
+         ->  Hash
+               Output: (count(*))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: (count(*))
+                     Hash Key: (count(*))
+                     ->  Aggregate
+                           Output: count(*)
+                           ->  Table Function Scan on pg_catalog.anytable_out
+                                 Output: anytable_out
+                                 ->  Function Scan on pg_catalog.generate_series a
+                                       Output: (random())::integer
+                                       Function Call: generate_series(1, 5)
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, optimizer=off
+(21 rows)
+
+-- if there is a volatile function in the target list of a plan with the locus type
+-- General or Segment General, then such a plan should be executed on single
+-- segment, since it is assumed that nodes with such locus types will give the same
+-- result on all segments, which is impossible for a volatile function.
+-- start_ignore
+drop table if exists d;
+-- end_ignore
+create table d (b int, a int default 1) distributed by (b);
+insert into d select * from generate_series(0, 20) j;
+-- change distribution without reorganize
+alter table d set distributed randomly;
+with cte as (
+    select a as a, a * random() as rand from generate_series(0, 3)a
+)
+select count(distinct(rand)) from cte join d on cte.a = d.a;
+ count 
+-------
+     1
+(1 row)
+
+drop table d;
 -- CTAS on general locus into replicated table
 create temp SEQUENCE test_seq;
 explain (costs off) create table t_rep as select nextval('test_seq') from (select generate_series(1,10)) t1 distributed replicated;
diff --git a/src/test/regress/expected/rpt.out b/src/test/regress/expected/rpt.out
index b0a595e468df..d61092721457 100644
--- a/src/test/regress/expected/rpt.out
+++ b/src/test/regress/expected/rpt.out
@@ -1513,6 +1513,130 @@ explain (costs off, verbose) select * from t1 where 1 <= ALL (select i from t gr
  Settings: enable_bitmapscan=off, enable_seqscan=off
 (20 rows)
 
+set gp_cte_sharing = on;
+-- ensure that the volatile function is executed on one segment if it is in the CTE target list
+explain (costs off, verbose) with cte as (
+    select a * random() as a from t2
+)
+select * from cte join (select * from t1 join cte using(a)) b using(a);
+                                      QUERY PLAN                                       
+---------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice4; segments: 3)
+   Output: share0_ref1.a
+   ->  Hash Join
+         Output: share0_ref1.a
+         Hash Cond: (share0_ref2.a = share0_ref1.a)
+         ->  Hash Join
+               Output: share0_ref2.a
+               Hash Cond: ((t1.a)::double precision = share0_ref2.a)
+               ->  Redistribute Motion 3:3  (slice1; segments: 3)
+                     Output: t1.a
+                     Hash Key: (t1.a)::double precision
+                     ->  Seq Scan on rpt.t1
+                           Output: t1.a
+               ->  Hash
+                     Output: share0_ref2.a
+                     ->  Redistribute Motion 1:3  (slice2; segments: 1)
+                           Output: share0_ref2.a
+                           Hash Key: share0_ref2.a
+                           ->  Shared Scan (share slice:id 2:0)
+                                 Output: share0_ref2.a
+         ->  Hash
+               Output: share0_ref1.a
+               ->  Redistribute Motion 1:3  (slice3; segments: 1)
+                     Output: share0_ref1.a
+                     Hash Key: share0_ref1.a
+                     ->  Shared Scan (share slice:id 3:0)
+                           Output: share0_ref1.a
+                           ->  Materialize
+                                 Output: (((t2.a)::double precision * random()))
+                                 ->  Seq Scan on rpt.t2
+                                       Output: ((t2.a)::double precision * random())
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=on, optimizer=off
+(33 rows)
+
+set gp_cte_sharing = off;
+explain (costs off, verbose) with cte as (
+    select a, a * random() from t2
+)
+select * from cte join t1 using(a);
+                                       QUERY PLAN                                       
+----------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: t2.a, (((t2.a)::double precision * random()))
+   ->  Hash Join
+         Output: t2.a, (((t2.a)::double precision * random()))
+         Hash Cond: (t1.a = t2.a)
+         ->  Seq Scan on rpt.t1
+               Output: t1.a
+         ->  Hash
+               Output: t2.a, (((t2.a)::double precision * random()))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: t2.a, (((t2.a)::double precision * random()))
+                     Hash Key: t2.a
+                     ->  Seq Scan on rpt.t2
+                           Output: t2.a, ((t2.a)::double precision * random())
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=off, optimizer=off
+(16 rows)
+
+reset gp_cte_sharing;
+-- ensure that the volatile function is executed on one segment if it is in target list of subplan of multiset function
+explain (costs off, verbose) select * from (
+    SELECT count(*) as a FROM anytable_out( TABLE( SELECT random()::int from t2 ) )
+) a join t1 using(a);
+                                  QUERY PLAN                                  
+------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: (count(*))
+   ->  Hash Join
+         Output: (count(*))
+         Hash Cond: (t1.a = (count(*)))
+         ->  Seq Scan on rpt.t1
+               Output: t1.a
+         ->  Hash
+               Output: (count(*))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: (count(*))
+                     Hash Key: (count(*))
+                     ->  Aggregate
+                           Output: count(*)
+                           ->  Table Function Scan on pg_catalog.anytable_out
+                                 Output: anytable_out
+                                 ->  Seq Scan on rpt.t2
+                                       Output: (random())::integer
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, optimizer=off
+(20 rows)
+
+-- if there is a volatile function in the target list of a plan with the locus type
+-- General or Segment General, then such a plan should be executed on single
+-- segment, since it is assumed that nodes with such locus types will give the same
+-- result on all segments, which is impossible for a volatile function.
+-- start_ignore
+drop table if exists d;
+NOTICE:  table "d" does not exist, skipping
+drop table if exists r;
+NOTICE:  table "r" does not exist, skipping
+-- end_ignore
+create table r (a int, b int) distributed replicated;
+create table d (b int, a int default 1) distributed by (b);
+insert into d select * from generate_series(0, 20) j;
+-- change distribution without reorganize
+alter table d set distributed randomly;
+insert into r values (1, 1), (2, 2), (3, 3);
+with cte as (
+    select a, b * random() as rand from r
+)
+select count(distinct(rand)) from cte join d on cte.a = d.a;
+ count 
+-------
+     1
+(1 row)
+
+drop table r;
+drop table d;
 drop table if exists t;
 drop table if exists t1;
 drop table if exists t2;
diff --git a/src/test/regress/expected/rpt_optimizer.out b/src/test/regress/expected/rpt_optimizer.out
index 490a94274753..36e4d859430d 100644
--- a/src/test/regress/expected/rpt_optimizer.out
+++ b/src/test/regress/expected/rpt_optimizer.out
@@ -1513,6 +1513,130 @@ explain (costs off, verbose) select * from t1 where 1 <= ALL (select i from t gr
  Settings: enable_bitmapscan=off, enable_seqscan=off
 (20 rows)
 
+set gp_cte_sharing = on;
+-- ensure that the volatile function is executed on one segment if it is in the CTE target list
+explain (costs off, verbose) with cte as (
+    select a * random() as a from t2
+)
+select * from cte join (select * from t1 join cte using(a)) b using(a);
+                                     QUERY PLAN                                      
+-------------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice4; segments: 3)
+   Output: share0_ref1.a
+   ->  Hash Join
+         Output: share0_ref1.a
+         Hash Cond: (share0_ref2.a = share0_ref1.a)
+         ->  Hash Join
+               Output: share0_ref2.a
+               Hash Cond: ((t1.a)::double precision = share0_ref2.a)
+               ->  Redistribute Motion 3:3  (slice1; segments: 3)
+                     Output: t1.a
+                     Hash Key: (t1.a)::double precision
+                     ->  Seq Scan on rpt.t1
+                           Output: t1.a
+               ->  Hash
+                     Output: share0_ref2.a
+                     ->  Redistribute Motion 1:3  (slice2; segments: 1)
+                           Output: share0_ref2.a
+                           Hash Key: share0_ref2.a
+                           ->  Shared Scan (share slice:id 2:0)
+                                 Output: share0_ref2.a
+         ->  Hash
+               Output: share0_ref1.a
+               ->  Redistribute Motion 1:3  (slice3; segments: 1)
+                     Output: share0_ref1.a
+                     Hash Key: share0_ref1.a
+                     ->  Shared Scan (share slice:id 3:0)
+                           Output: share0_ref1.a
+                           ->  Materialize
+                                 Output: (((t2.a)::double precision * random()))
+                                 ->  Seq Scan on rpt.t2
+                                       Output: ((t2.a)::double precision * random())
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=on
+(33 rows)
+
+set gp_cte_sharing = off;
+explain (costs off, verbose) with cte as (
+    select a, a * random() from t2
+)
+select * from cte join t1 using(a);
+                                  QUERY PLAN                                   
+-------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: t2.a, (((t2.a)::double precision * random()))
+   ->  Hash Join
+         Output: t2.a, (((t2.a)::double precision * random()))
+         Hash Cond: (t1.a = t2.a)
+         ->  Seq Scan on rpt.t1
+               Output: t1.a
+         ->  Hash
+               Output: t2.a, (((t2.a)::double precision * random()))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: t2.a, (((t2.a)::double precision * random()))
+                     Hash Key: t2.a
+                     ->  Seq Scan on rpt.t2
+                           Output: t2.a, ((t2.a)::double precision * random())
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off, gp_cte_sharing=off
+(16 rows)
+
+reset gp_cte_sharing;
+-- ensure that the volatile function is executed on one segment if it is in target list of subplan of multiset function
+explain (costs off, verbose) select * from (
+    SELECT count(*) as a FROM anytable_out( TABLE( SELECT random()::int from t2 ) )
+) a join t1 using(a);
+                                  QUERY PLAN                                  
+------------------------------------------------------------------------------
+ Gather Motion 3:1  (slice2; segments: 3)
+   Output: (count(*))
+   ->  Hash Join
+         Output: (count(*))
+         Hash Cond: (t1.a = (count(*)))
+         ->  Seq Scan on rpt.t1
+               Output: t1.a
+         ->  Hash
+               Output: (count(*))
+               ->  Redistribute Motion 1:3  (slice1; segments: 1)
+                     Output: (count(*))
+                     Hash Key: (count(*))
+                     ->  Aggregate
+                           Output: count(*)
+                           ->  Table Function Scan on pg_catalog.anytable_out
+                                 Output: anytable_out
+                                 ->  Seq Scan on rpt.t2
+                                       Output: (random())::integer
+ Optimizer: Postgres query optimizer
+ Settings: enable_bitmapscan=off, enable_seqscan=off
+(20 rows)
+
+-- if there is a volatile function in the target list of a plan with the locus type
+-- General or Segment General, then such a plan should be executed on single
+-- segment, since it is assumed that nodes with such locus types will give the same
+-- result on all segments, which is impossible for a volatile function.
+-- start_ignore
+drop table if exists d;
+NOTICE:  table "d" does not exist, skipping
+drop table if exists r;
+NOTICE:  table "r" does not exist, skipping
+-- end_ignore
+create table r (a int, b int) distributed replicated;
+create table d (b int, a int default 1) distributed by (b);
+insert into d select * from generate_series(0, 20) j;
+-- change distribution without reorganize
+alter table d set distributed randomly;
+insert into r values (1, 1), (2, 2), (3, 3);
+with cte as (
+    select a, b * random() as rand from r
+)
+select count(distinct(rand)) from cte join d on cte.a = d.a;
+ count 
+-------
+     1
+(1 row)
+
+drop table r;
+drop table d;
 drop table if exists t;
 drop table if exists t1;
 drop table if exists t2;
diff --git a/src/test/regress/sql/bfv_planner.sql b/src/test/regress/sql/bfv_planner.sql
index c0a34800a9b8..c0fbdd03d84f 100644
--- a/src/test/regress/sql/bfv_planner.sql
+++ b/src/test/regress/sql/bfv_planner.sql
@@ -316,6 +316,56 @@ explain (costs off) select * from t_hashdist cross join (select a, count(1) as s
 -- limit
 explain (costs off) select * from t_hashdist cross join (select * from generate_series(1, 10) limit 1) x;
 
+set gp_cte_sharing = on;
+
+-- ensure that the volatile function is executed on one segment if it is in the CTE target list
+explain (costs off, verbose) with cte as (
+    select a * random() as a from generate_series(1, 5) a
+)
+select * from cte join (select * from t_hashdist join cte using(a)) b using(a);
+
+set gp_cte_sharing = off;
+
+explain (costs off, verbose) with cte as (
+    select a, a * random() from generate_series(1, 5) a
+)
+select * from cte join t_hashdist using(a);
+
+reset gp_cte_sharing;
+
+-- ensure that the volatile function is executed on one segment if it is in the union target list
+explain (costs off, verbose) select * from (
+    select random() as a from generate_series(1, 5)
+    union
+    select random() as a from generate_series(1, 5)
+)
+a join t_hashdist on a.a = t_hashdist.a;
+
+-- ensure that the volatile function is executed on one segment if it is in target list of subplan of multiset function
+explain (costs off, verbose) select * from (
+    SELECT count(*) as a FROM anytable_out( TABLE( SELECT random()::int from generate_series(1, 5) a ) )
+) a join t_hashdist using(a);
+
+-- if there is a volatile function in the target list of a plan with the locus type
+-- General or Segment General, then such a plan should be executed on single
+-- segment, since it is assumed that nodes with such locus types will give the same
+-- result on all segments, which is impossible for a volatile function.
+-- start_ignore
+drop table if exists d;
+-- end_ignore
+create table d (b int, a int default 1) distributed by (b);
+
+insert into d select * from generate_series(0, 20) j;
+-- change distribution without reorganize
+alter table d set distributed randomly;
+
+with cte as (
+    select a as a, a * random() as rand from generate_series(0, 3)a
+)
+select count(distinct(rand)) from cte join d on cte.a = d.a;
+
+drop table d;
+
 -- CTAS on general locus into replicated table
 create temp SEQUENCE test_seq;
 explain (costs off) create table t_rep as select nextval('test_seq') from (select generate_series(1,10)) t1 distributed replicated;
diff --git a/src/test/regress/sql/rpt.sql b/src/test/regress/sql/rpt.sql
index 1e1b479d286c..adc1aa4ece6f 100644
--- a/src/test/regress/sql/rpt.sql
+++ b/src/test/regress/sql/rpt.sql
@@ -562,6 +562,54 @@ explain (costs off, verbose) insert into t2 (a, b) select i, random() from t;
 explain (costs off, verbose) select * from t1 where a in (select f(i) from t where i=a and f(i) > 0);
 -- ensure we do not break broadcast motion
 explain (costs off, verbose) select * from t1 where 1 <= ALL (select i from t group by i having random() > 0);
+
+set gp_cte_sharing = on;
+
+-- ensure that the volatile function is executed on one segment if it is in the CTE target list
+explain (costs off, verbose) with cte as (
+    select a * random() as a from t2
+)
+select * from cte join (select * from t1 join cte using(a)) b using(a);
+
+set gp_cte_sharing = off;
+
+explain (costs off, verbose) with cte as (
+    select a, a * random() from t2
+)
+select * from cte join t1 using(a);
+
+reset gp_cte_sharing;
+
+-- ensure that the volatile function is executed on one segment if it is in target list of subplan of multiset function
+explain (costs off, verbose) select * from (
+    SELECT count(*) as a FROM anytable_out( TABLE( SELECT random()::int from t2 ) )
+) a join t1 using(a);
+
+-- if there is a volatile function in the target list of a plan with the locus type
+-- General or Segment General, then such a plan should be executed on single
+-- segment, since it is assumed that nodes with such locus types will give the same
+-- result on all segments, which is impossible for a volatile function.
+-- start_ignore
+drop table if exists d;
+drop table if exists r;
+-- end_ignore
+create table r (a int, b int) distributed replicated;
+create table d (b int, a int default 1) distributed by (b);
+
+insert into d select * from generate_series(0, 20) j;
+-- change distribution without reorganize
+alter table d set distributed randomly;
+
+insert into r values (1, 1), (2, 2), (3, 3);
+
+with cte as (
+    select a, b * random() as rand from r
+)
+select count(distinct(rand)) from cte join d on cte.a = d.a;
+
+drop table r;
+drop table d;
+
 drop table if exists t;
 drop table if exists t1;
 drop table if exists t2;

From f5215ad206d5328ff94a27376490a1abe62677bd Mon Sep 17 00:00:00 2001
From: Alexey Gordeev <goa@arenadata.io>
Date: Tue, 28 Nov 2023 17:49:24 +0500
Subject: [PATCH 19/22] Fix ORCA's triggers on debug build (#650)

An attempt to call DML over a table with trigger may give an assertion error in
`CFunctionProp` constructor. `func_stability` passed to the constructor may be
more than max value (`IMDFunction::EfsSentinel`). This happens, because
`CLogicalRowTrigger` class has no default value for `m_efs` in its constructor.
This means that `m_efs` may contain any value (for example 2139062143). Later,
when `InitFunctionProperties()` tries to calculate less strict
stability level, `m_efs` is not overwritten, because it already has greater
value. The patch fixes the error by adding default `m_efs` value to constructor.
The planing may fall on any type of trigger on any DML operaion, so you may
test it with any trigger and `optimizer_enable_dml_triggers` set to enabled.
---
 .../gporca/libgpopt/src/operators/CLogicalRowTrigger.cpp    | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/backend/gporca/libgpopt/src/operators/CLogicalRowTrigger.cpp b/src/backend/gporca/libgpopt/src/operators/CLogicalRowTrigger.cpp
index 01cb44d1a59b..7793a9816527 100644
--- a/src/backend/gporca/libgpopt/src/operators/CLogicalRowTrigger.cpp
+++ b/src/backend/gporca/libgpopt/src/operators/CLogicalRowTrigger.cpp
@@ -33,7 +33,8 @@ CLogicalRowTrigger::CLogicalRowTrigger(CMemoryPool *mp)
 	  m_rel_mdid(NULL),
 	  m_type(0),
 	  m_pdrgpcrOld(NULL),
-	  m_pdrgpcrNew(NULL)
+	  m_pdrgpcrNew(NULL),
+	  m_efs(IMDFunction::EfsImmutable)
 {
 	m_fPattern = true;
 }
@@ -53,7 +54,8 @@ CLogicalRowTrigger::CLogicalRowTrigger(CMemoryPool *mp, IMDId *rel_mdid,
 	  m_rel_mdid(rel_mdid),
 	  m_type(type),
 	  m_pdrgpcrOld(pdrgpcrOld),
-	  m_pdrgpcrNew(pdrgpcrNew)
+	  m_pdrgpcrNew(pdrgpcrNew),
+	  m_efs(IMDFunction::EfsImmutable)
 {
 	GPOS_ASSERT(rel_mdid->IsValid());
 	GPOS_ASSERT(0 != type);

From 32ad64effda0e108ad07254c6dc7f0361965e6a0 Mon Sep 17 00:00:00 2001
From: Xing Guo <higuoxing@gmail.com>
Date: Thu, 28 Oct 2021 12:11:13 +0800
Subject: [PATCH 20/22] Fix 'DROP OWNED BY' failure when some protocol is
 accessible by the user.

Cherry picked from 3f71222

This PR helps resolve #12748. When the access privilege
is granted to some user, the 'DROP OWNED BY' clause
cannot be executed with an error message saying:
'ERROR: unexpected object class XXXX (aclchk.c:XXX)'.

Simple SQL to reproduce:

```sql
-- Create read, write functions.
CREATE OR REPLACE FUNCTION dummy_read() RETURNS INTEGER
  AS $$ SELECT 0 $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION dummy_write() RETURNS INTEGER
  AS $$ SELECT 0 $$ LANGUAGE SQL;
-- Create protocol.
CREATE TRUSTED PROTOCOL dummy_proto (
  readfunc = dummy_read,
  writefunc=dummy_write
);
-- Create a user.
CREATE ROLE test_role1;
-- Grant access privilege.
GRANT ALL ON PROTOCOL dummy_proto TO test_role1;
DROP OWNED BY test_role1;
```
---
 src/backend/catalog/aclchk.c                  |  3 +++
 src/test/regress/input/external_table.source  | 10 ++++++++++
 src/test/regress/output/external_table.source | 10 ++++++++++
 3 files changed, 23 insertions(+)

diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c
index 6a3c8b20a4a1..736e379d04ec 100644
--- a/src/backend/catalog/aclchk.c
+++ b/src/backend/catalog/aclchk.c
@@ -1580,6 +1580,9 @@ RemoveRoleFromObjectACL(Oid roleid, Oid classid, Oid objid)
 			case ForeignDataWrapperRelationId:
 				istmt.objtype = ACL_OBJECT_FDW;
 				break;
+			case ExtprotocolRelationId:
+				istmt.objtype = ACL_OBJECT_EXTPROTOCOL;
+				break;
 			default:
 				elog(ERROR, "unexpected object class %u", classid);
 				break;
diff --git a/src/test/regress/input/external_table.source b/src/test/regress/input/external_table.source
index 757be9c1ef4d..3724d4d899f8 100644
--- a/src/test/regress/input/external_table.source
+++ b/src/test/regress/input/external_table.source
@@ -293,6 +293,16 @@ SELECT encoding from gp_dist_random('pg_exttable') where urilocation='{gpfdist:/
 DROP EXTERNAL TABLE issue_9727;
 RESET client_encoding;
 
+-- Test "DROP OWNED BY" when everything of the protocol is granted to some user.
+-- GitHub Issue #12748: https://github.com/greenplum-db/gpdb/issues/12748
+CREATE TRUSTED PROTOCOL dummy_protocol_issue_12748 (readfunc = 'read_from_file', writefunc = 'write_to_file');
+CREATE ROLE test_role_issue_12748;
+GRANT ALL ON PROTOCOL dummy_protocol_issue_12748 TO test_role_issue_12748;
+DROP OWNED BY test_role_issue_12748;
+-- Clean up.
+DROP ROLE test_role_issue_12748;
+DROP PROTOCOL dummy_protocol_issue_12748;
+
 --
 -- WET tests
 --
diff --git a/src/test/regress/output/external_table.source b/src/test/regress/output/external_table.source
index 9d78d6a30468..71b91bcf95f0 100644
--- a/src/test/regress/output/external_table.source
+++ b/src/test/regress/output/external_table.source
@@ -394,6 +394,16 @@ SELECT encoding from gp_dist_random('pg_exttable') where urilocation='{gpfdist:/
 
 DROP EXTERNAL TABLE issue_9727;
 RESET client_encoding;
+-- Test "DROP OWNED BY" when everything of the protocol is granted to some user.
+-- GitHub Issue #12748: https://github.com/greenplum-db/gpdb/issues/12748
+CREATE TRUSTED PROTOCOL dummy_protocol_issue_12748 (readfunc = 'read_from_file', writefunc = 'write_to_file');
+CREATE ROLE test_role_issue_12748;
+NOTICE:  resource queue required -- using default resource queue "pg_default"
+GRANT ALL ON PROTOCOL dummy_protocol_issue_12748 TO test_role_issue_12748;
+DROP OWNED BY test_role_issue_12748;
+-- Clean up.
+DROP ROLE test_role_issue_12748;
+DROP PROTOCOL dummy_protocol_issue_12748;
 --
 -- WET tests
 --

From fd5939d4f491238bbd28be88b98949cd0e2d6fe0 Mon Sep 17 00:00:00 2001
From: Alexander Kondakov <a.kondakov@arenadata.io>
Date: Mon, 4 Dec 2023 22:13:36 +0300
Subject: [PATCH 21/22] Fix partition selection during DML execution when
 dropped columns are present (#634)

Current partitioning design faced a problem, which is connected with the
differences in physical attribute layouts of the child partition and the parent
relation in case when the parent relation has dropped columns and the newly
added child partition has not, and vice versa.

When executing modifying DML operations on a leaf partition of a partitioned
table, the executor anyway performs the partition selection in case of INSERT,
UPDATE for legacy planner and in case of INSERT, UPDATE, DELETE for ORCA
optimizer. This is done in selectPartition function, which is called from
slot_get_partition function (in case of modifying DML commands). This procedure
is done based on 1) attribute values of the tuple, which have been retrieved
from the respective subplan of ModifyTable (DML) node and whose attribute
structure corresponds the leaf partition's. 2) the root partition's attribute
numbers and partition rules, which are based on the parent (root) relation's
tuple descriptor. Thus, if the parent relation's tuple descriptor contained
dropped columns and leaf partition's did not (or visa versa, the leaf partition
had dropped columns and parent had not), the partition selection could go wrong
and lead to various execution errors.

Let's consider the following case. The partitioned table was created, and at
one moment it was decided to drop several irrelevant columns from it. After that
some new partitions were added or some were exchanged with new relations. In
this situation these newly added (exchanged) partitions don't have dropped
columns in it's structure, but the original parent relation has such dropped
attributes. Then the INSERT command into the new leaf partition is executed. In
this case for both planners the ExecInsert function is called, which then calls
slot_get_partition function in order to validate that the tuple values
correspond to specified leaf partition. And here the tuple descriptor does not
have dropped attributes, but the partition selection is performed from parent's
view, which have those attributes, and the parent's partitioning attribute
numbers are used to validate the tuple. Because of that the partition selection
procedure could either select wrong target partition (the wrong attribute was
taken from the slot values to check the partition rule) or fail to find the
partition at all, becasue none of the partition rules were satisfied. The same
issue occured when we didn't drop anything from parent relation, however we
exhanged a partition to the one with dropped columns. When inserting into
exchanged leaf partition the partition selection could also go wrong by the same
reasons (selection is performed from parent's view).

Similar issue occured for both planners in other commands, when partition
selection was performed. And in order to prevent the potentially wrong partition
selection, when modifying the leaf partition, this patch proposes the
following solution.

The legacy planner have checkPartitionUpdate function, which is called in UPDATE
cases and which checks that the tuple does not switch its partition at
update. And to our astonishment this function is able to handle the case when
the partition being modified has physically-different attribute numbers from
root partition's due to dropped columns. In this case the function creates the
ri_PartCheckMap map in target (child) ResultRelInfo, which stores correspondance
between target partition attributes and parent's. And because of that map, the
partition selection goes smoothly inside the function.

The proposed solution is to build ri_PartCheckMap for all the cases when the
leaf partition is modified and parent relation has dropped columns (or child
has and parent doesn't), and when the partition selection is expected. The
logic, which checks the matching of leaf's and parent's relation descriptors and
builds the ri_PartCheckMap is moved to a separate function
makePartitionCheckMap. This new function is called inside the ExecModifyTable
and ExecDML functions under different conditions.

For legacy planner this function is called for any command, except DELETE, no
matter which relation is initially specified as target (can be either root or
leaf). For example, when executing UPDATE (either split or common update) on
root relation, the planner builds the plan via inheritance_planner, and,
therefore, the each subplan of ModifyTable node will return the tuple slot with
attributes structure of the specific partition (some subplans will contain
dropped attributes in targetList, some won't). Here call of
makePartitionCheckMap is also required. For INSERT command it will be always
called as well, because makePartitionCheckMap validates whether oid of result
relation is equal to parent't partition oid, and this check allows us to call
the function on root relation too (if it's true, the map is not built, because
it's safe to perform operation through the root relation).

For ORCA optimizer the makePartitionCheckMap is called inside the ExecDML
function only in the case if the leaf partition is being modified. Otherwise, if
the command is called on root relation, the tuple will always have the
parent's structure, which does not break the partition selection procedure.

This patch also changes the slot_get_partition function, which performs the
partition selection. This function is extended with the alternative variant of
the attribute values extraction from the given slot. When the
makePartitionCheckMap function have created the ri_PartCheckMap of the child
ResultRelInfo, the attributes values array is built via that map
(inside reconstructTupleValues), what allows to perform the partition selection
from parent's view.

Finally, this patch additionally solves one more issue, that is not directly
related partition selection problem described above. Let's consider the
case when the parent relation has two partitions, and one of them has
incompatible attribute structure with parent's due to dropped columns. The
issue occured when the split UPDATE on parent partition was executed, and its
plan is built by legacy planner. That means that ModifyTable node contains
several sublans and several result relations inside the
estate->es_result_relations (inheritance planner creates them and the update is
executed for each of them). And during execution of this plan, when update is
executed on the partition, which has the same relation descriptor with parent's,
the invalid behaviour could occur when preparing the tuple for insertion (see
the last test case in tests section). In this case the partition selection at
insert stage works correct, because the partition does not differ from parent
relation. However, inside the get_part function, after the partition was
selected correctly from selectPartition function, the targetid_get_partition
function could wrongly form the final ResultRelInfo by creating unnecessary
ri_partInsertMap map, which is used in reconstructMatchingTupleSlot function
(inside the ExecInsert) to adjust the tuple to the selected partition descriptor
if the tuple does not fit. targetid_get_partition function makes the desicion on
building that map based on check, that compares two relation's descriptors:
one, which is considered to be parent's
(parentInfo = estate->es_result_relations), and one, which corresponds to
selected child partition (childInfo). But in case when UPDATE is formed by
inheritance planner, the parentInfo does not correspond the true parent
relation. It corresponds to one of other partitions. And in the case, when
selected partition is valid (it has the same relation descriptor with parent's),
and parentInfo corresponds to invalid partition (it does not match with parent
descriptor), the ri_partInsertMap could be built by mistake, what led to
unnecessary tuple reformatting and invalid results.

This patch solves this last issue by adding a check inside the
targetid_get_partition function, which ensures that the
estate->es_result_relations corresponds to the true root relation. That
would be true for all the cases when the DML is executed on parent relation,
except the UPDATE by legacy planner. And if the check is passed, the
ri_partInsertMap is built, otherwise it's not. Moreover, during such UPDATE
there is completely no need to reconstruct the tuple, because each ModifyTable's
subplan will give already valid tuple.
---
 src/backend/executor/execMain.c               |  78 ++++-
 src/backend/executor/nodeDML.c                |  32 ++
 src/backend/executor/nodeModifyTable.c        | 177 ++++++----
 src/include/executor/execDML.h                |   3 +
 src/include/nodes/execnodes.h                 |   6 +-
 src/test/regress/expected/qp_dropped_cols.out | 299 ++++++++++++++++
 .../expected/qp_dropped_cols_optimizer.out    | 326 ++++++++++++++++++
 src/test/regress/sql/qp_dropped_cols.sql      | 137 ++++++++
 8 files changed, 969 insertions(+), 89 deletions(-)

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 3dcdbb6f9578..ea4b672e8352 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -4591,6 +4591,7 @@ targetid_get_partition(Oid targetid, EState *estate, bool openIndices)
 	{
 		int			natts;
 		Relation	resultRelation;
+		Oid			parentRelid = estate->es_result_partitions->part->parrelid;
 
 		natts = parentInfo->ri_RelationDesc->rd_att->natts; /* in base relation */
 
@@ -4603,10 +4604,27 @@ targetid_get_partition(Oid targetid, EState *estate, bool openIndices)
 		if (openIndices)
 			ExecOpenIndices(childInfo);
 
-		map_part_attrs(parentInfo->ri_RelationDesc,
-					   childInfo->ri_RelationDesc,
-					   &(childInfo->ri_partInsertMap),
-					   TRUE); /* throw on error, so result not needed */
+		/*
+		 * es_result_relations does not always represent the parent relation.
+		 * E.g. planner's UPDATE command on parent partition leads to multiple
+		 * subplans and result relations due to preceding inheritance planning.
+		 * In this case es_result_relations points to one of the partitions, not
+		 * to the parent. Thus, the descriptor mapping should be performed only
+		 * for the case if es_result_relations really corresponds to the parent.
+		 * Otherwise, there is a chance to reconstruct already valid tuple and
+		 * get the wrong results (e.g. target partition relation descriptor is
+		 * different from parentInfo's, but it's UPDATE (legacy planner) and
+		 * parentInfo represents another partition, which is not the true
+		 * parent). Moreover, if we are initially modify a leaf partition,
+		 * i.e we called a DML command straight on child partition, or it's
+		 * inheritance plan execution, the tuple descriptor already matches
+		 * the partition's, and the extra mapping is unnecessary.
+		 */
+		if (RelationGetRelid(parentInfo->ri_RelationDesc) == parentRelid)
+			map_part_attrs(parentInfo->ri_RelationDesc,
+						   childInfo->ri_RelationDesc,
+						   &(childInfo->ri_partInsertMap),
+						   TRUE); /* throw on error, so result not needed */
 	}
 	return childInfo;
 }
@@ -4631,22 +4649,60 @@ values_get_partition(Datum *values, bool *nulls, TupleDesc tupdesc,
 ResultRelInfo *
 slot_get_partition(TupleTableSlot *slot, EState *estate)
 {
-	ResultRelInfo *resultRelInfo;
-	AttrNumber max_attr;
+	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+	TupleDesc	tupdesc;
 	Datum *values;
 	bool *nulls;
 
 	Assert(PointerIsValid(estate->es_result_partitions));
 
-	max_attr = estate->es_partition_state->max_partition_attr;
+	/*
+	 * If we previously found out that we need to map attribute numbers
+	 * (in case if child part has physically-different attribute numbers from
+	 * parent's), we must extract slot values according to that mapping.
+	 */
+	if (resultRelInfo->ri_PartCheckMap != NULL)
+	{
+		Datum	   *slot_values;
+		bool	   *slot_nulls;
+		Relation	parentRel = resultRelInfo->ri_PartitionParent;
+		AttrMap	   *map;
+
+		Assert(parentRel != NULL);
+		tupdesc = RelationGetDescr(parentRel);
+
+		slot_getallattrs(slot);
+		slot_values = slot_get_values(slot);
+		slot_nulls = slot_get_isnull(slot);
+		values = palloc(tupdesc->natts * sizeof(Datum));
+		nulls = palloc0(tupdesc->natts * sizeof(bool));
+
+		/* Now we have values/nulls in parent's view. */
+		map = resultRelInfo->ri_PartCheckMap;
+		reconstructTupleValues(map, slot_values, slot_nulls, slot->tts_tupleDescriptor->natts,
+							   values, nulls, tupdesc->natts);
+	}
+	else
+	{
+		AttrNumber	max_attr = estate->es_partition_state->max_partition_attr;
 
-	slot_getsomeattrs(slot, max_attr);
-	values = slot_get_values(slot);
-	nulls = slot_get_isnull(slot);
+		slot_getsomeattrs(slot, max_attr);
+		/* values/nulls pointing to partslot's array. */
+		values = slot_get_values(slot);
+		nulls = slot_get_isnull(slot);
+		tupdesc = slot->tts_tupleDescriptor;
+	}
 
-	resultRelInfo = get_part(estate, values, nulls, slot->tts_tupleDescriptor,
+	resultRelInfo = get_part(estate, values, nulls, tupdesc,
 							 true);
 
+	/* Free up if we allocated mapped attributes. */
+	if (values != slot_get_values(slot))
+		pfree(values);
+
+	if (nulls != slot_get_isnull(slot))
+		pfree(nulls);
+
 	return resultRelInfo;
 }
 
diff --git a/src/backend/executor/nodeDML.c b/src/backend/executor/nodeDML.c
index 33b2edf5387f..d5dc775273ad 100644
--- a/src/backend/executor/nodeDML.c
+++ b/src/backend/executor/nodeDML.c
@@ -85,6 +85,38 @@ ExecDML(DMLState *node)
 	/* remove 'junk' columns from tuple */
 	node->cleanedUpSlot = ExecFilterJunk(node->junkfilter, projectedSlot);
 
+	/*
+	 * If we are modifying a leaf partition we have to ensure that partition
+	 * selection operation will consider leaf partition's attributes as
+	 * coherent with root partition's attribute numbers, because partition
+	 * selection is performed using root's attribute numbers (all partition
+	 * rules are based on the parent relation's tuple descriptor). In case
+	 * when child partition has different attribute numbers from root's due to
+	 * dropped columns, the partition selection may go wrong without extra
+	 * validation.
+	 */
+	if (node->ps.state->es_result_partitions)
+	{
+		ResultRelInfo *relInfo = node->ps.state->es_result_relations;
+
+		/*
+		 * The DML is done on a leaf partition. In order to reuse the map,
+		 * it will be allocated at es_result_relations.
+		 */
+		if (RelationGetRelid(relInfo->ri_RelationDesc) !=
+			node->ps.state->es_result_partitions->part->parrelid)
+			makePartitionCheckMap(node->ps.state, relInfo);
+
+		/*
+		 * DML node always performs partition selection, and if we want to
+		 * reuse the map built in makePartitionCheckMap, we are allowed to
+		 * reassign es_result_relation_info, because ExecInsert, ExecDelete
+		 * changes it with target partition anyway. Moreover, without
+		 * inheritance plan (ORCA never builds such plans) the
+		 * es_result_relations will contain the only relation.
+		 */
+		node->ps.state->es_result_relation_info = relInfo;
+	}
 	/* GPDB_91_MERGE_FIXME:
 	 * This kind of node is used by ORCA only. If in the future ORCA still uses
 	 * DML node, canSetTag should be saved in DML plan node and init-ed by
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 3cba0ee49db4..8d8572fdea84 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1132,7 +1132,6 @@ checkPartitionUpdate(EState *estate, TupleTableSlot *partslot,
 	Datum	   *values = NULL;
 	bool	   *nulls = NULL;
 	TupleDesc	tupdesc = NULL;
-	Oid			parentRelid;
 	Oid			targetid;
 
 	Assert(estate->es_partition_state != NULL &&
@@ -1144,81 +1143,12 @@ checkPartitionUpdate(EState *estate, TupleTableSlot *partslot,
 	Assert(PointerIsValid(estate->es_result_partitions));
 
 	/*
-	 * As opposed to INSERT, resultRelation here is the same child part
-	 * as scan origin.  However, the partition selection is done with the
-	 * parent partition's attribute numbers, so if this result (child) part
-	 * has physically-different attribute numbers due to dropped columns,
-	 * we should map the child attribute numbers to the parent's attribute
-	 * numbers to perform the partition selection.
-	 * EState doesn't have the parent relation information at the moment,
-	 * so we have to do a hard job here by opening it and compare the
-	 * tuple descriptors.  If we find we need to map attribute numbers,
-	 * max_partition_attr could also be bogus for this child part,
-	 * so we end up materializing the whole columns using slot_getallattrs().
-	 * The purpose of this code is just to prevent the tuple from
-	 * incorrectly staying in default partition that has no constraint
-	 * (parts with constraint will throw an error if the tuple is changing
-	 * partition keys to out of part value anyway.)  It's a bit overkill
-	 * to do this complicated logic just for this purpose, which is necessary
-	 * with our current partitioning design, but I hope some day we can
-	 * change this so that we disallow phyisically-different tuple descriptor
-	 * across partition.
-	 */
-	parentRelid = estate->es_result_partitions->part->parrelid;
-
-	/*
-	 * I don't believe this is the case currently, but we check the parent relid
-	 * in case the updating partition has changed since the last time we opened it.
-	 */
-	if (resultRelInfo->ri_PartitionParent &&
-		parentRelid != RelationGetRelid(resultRelInfo->ri_PartitionParent))
-	{
-		resultRelInfo->ri_PartCheckTupDescMatch = 0;
-		if (resultRelInfo->ri_PartCheckMap != NULL)
-			pfree(resultRelInfo->ri_PartCheckMap);
-		if (resultRelInfo->ri_PartitionParent)
-			relation_close(resultRelInfo->ri_PartitionParent, AccessShareLock);
-	}
-
-	/*
-	 * Check this at the first pass only to avoid repeated catalog access.
+	 * If we find we need to map attribute numbers (in case if child part has
+	 * physically-different attribute numbers from parent's, the mapping is
+	 * performed inside the makePartitionCheckMap function)
+	 * max_partition_attr could also be bogus for this child part, so we end
+	 * up materializing the whole columns using slot_getallattrs().
 	 */
-	if (resultRelInfo->ri_PartCheckTupDescMatch == 0 &&
-		parentRelid != RelationGetRelid(resultRelInfo->ri_RelationDesc))
-	{
-		Relation	parentRel;
-		TupleDesc	resultTupdesc, parentTupdesc;
-
-		/*
-		 * We are on a child part, let's see the tuple descriptor looks like
-		 * the parent's one.  Probably this won't cause deadlock because
-		 * DML should have opened the parent table with appropriate lock.
-		 */
-		parentRel = relation_open(parentRelid, AccessShareLock);
-		resultTupdesc = RelationGetDescr(resultRelationDesc);
-		parentTupdesc = RelationGetDescr(parentRel);
-		if (!equalTupleDescs(resultTupdesc, parentTupdesc, false))
-		{
-			AttrMap		   *map;
-			MemoryContext	oldcontext;
-
-			/* Tuple looks different.  Construct attribute mapping. */
-			oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
-			map_part_attrs(resultRelationDesc, parentRel, &map, true);
-			MemoryContextSwitchTo(oldcontext);
-
-			/* And save it for later use. */
-			resultRelInfo->ri_PartCheckMap = map;
-
-			resultRelInfo->ri_PartCheckTupDescMatch = -1;
-		}
-		else
-			resultRelInfo->ri_PartCheckTupDescMatch = 1;
-
-		resultRelInfo->ri_PartitionParent = parentRel;
-		/* parentRel will be closed as part of ResultRelInfo cleanup */
-	}
-
 	if (resultRelInfo->ri_PartCheckMap != NULL)
 	{
 		Datum	   *parent_values;
@@ -1927,6 +1857,19 @@ ExecModifyTable(ModifyTableState *node)
 				slot = ExecFilterJunk(junkfilter, slot);
 		}
 
+		/*
+		 * We have to ensure that partition selection in INSERT or UPDATE will
+		 * consider leaf partition's attributes as coherent with root
+		 * partition's attribute numbers, because partition selection is
+		 * performed using root's attribute numbers (all partition rules are
+		 * based on the parent relation's tuple descriptor). In case when
+		 * child partition has different attribute numbers from parent's
+		 * due to dropped columns, the partition selection may go wrong without
+		 * extra validation.
+		 */
+		if (operation != CMD_DELETE && estate->es_result_partitions)
+			makePartitionCheckMap(estate, estate->es_result_relation_info);
+
 		switch (operation)
 		{
 			case CMD_INSERT:
@@ -2506,3 +2449,87 @@ ExecSquelchModifyTable(ModifyTableState *node)
 			break;
 	}
 }
+
+/*
+ * Build a attribute mapping between child partition and the root partition in
+ * case if child partition has physically-different attribute numbers from
+ * root's due to dropped columns.
+ */
+void
+makePartitionCheckMap(EState *estate, ResultRelInfo *resultRelInfo)
+{
+	Relation	resultRelationDesc = resultRelInfo->ri_RelationDesc;
+	Oid			parentRelid;
+
+	Assert(PointerIsValid(estate->es_result_partitions));
+
+	/*
+	 * The partition selection operation is done with the parent partition's
+	 * attribute numbers, so if child partition has physically-different
+	 * attribute numbers due to dropped columns, we should map the child
+	 * attribute numbers to the parent's attribute numbers to perform the
+	 * partition selection. EState may not have the parent relation
+	 * information at the moment, so we have to do a hard job here by opening
+	 * it and compare the tuple descriptors. The purpose of this code is to
+	 * prevent the tuple from being incorrectly interpreted during partition
+	 * selection, that can be performed in ExecInsert, ExecDelete and
+	 * checkPartitionUpdate functions when we work with the leaf partition as
+	 * result relation.
+	 */
+	parentRelid = estate->es_result_partitions->part->parrelid;
+
+	/*
+	 * I don't believe this is the case currently, but we check the parent
+	 * relid in case the updating partition has changed since the last time we
+	 * opened it.
+	 */
+	if (resultRelInfo->ri_PartitionParent &&
+		parentRelid != RelationGetRelid(resultRelInfo->ri_PartitionParent))
+	{
+		resultRelInfo->ri_PartCheckTupDescMatch = 0;
+		if (resultRelInfo->ri_PartCheckMap != NULL)
+			pfree(resultRelInfo->ri_PartCheckMap);
+		if (resultRelInfo->ri_PartitionParent)
+			relation_close(resultRelInfo->ri_PartitionParent, AccessShareLock);
+	}
+
+	/*
+	 * Check this at the first pass only to avoid repeated catalog access.
+	 */
+	if (resultRelInfo->ri_PartCheckTupDescMatch == 0 &&
+		parentRelid != RelationGetRelid(resultRelInfo->ri_RelationDesc))
+	{
+		Relation	parentRel;
+		TupleDesc	resultTupdesc,
+					parentTupdesc;
+
+		/*
+		 * We are on a child part, let's see the tuple descriptor looks like
+		 * the parent's one.  Probably this won't cause deadlock because DML
+		 * should have opened the parent table with appropriate lock.
+		 */
+		parentRel = relation_open(parentRelid, AccessShareLock);
+		resultTupdesc = RelationGetDescr(resultRelationDesc);
+		parentTupdesc = RelationGetDescr(parentRel);
+		if (!equalTupleDescs(resultTupdesc, parentTupdesc, false))
+		{
+			AttrMap    *map;
+			MemoryContext oldcontext;
+
+			/* Tuple looks different. Construct attribute mapping. */
+			oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
+			map_part_attrs(resultRelationDesc, parentRel, &map, true);
+			MemoryContextSwitchTo(oldcontext);
+
+			/* And save it for later use. */
+			resultRelInfo->ri_PartCheckMap = map;
+
+			resultRelInfo->ri_PartCheckTupDescMatch = -1;
+		}
+		else
+			resultRelInfo->ri_PartCheckTupDescMatch = 1;
+
+		resultRelInfo->ri_PartitionParent = parentRel;
+		/* parentRel will be closed as part of ResultRelInfo cleanup */
+	}
+}
diff --git a/src/include/executor/execDML.h b/src/include/executor/execDML.h
index 2d0124897bab..ff66c9e4cc4a 100644
--- a/src/include/executor/execDML.h
+++ b/src/include/executor/execDML.h
@@ -24,6 +24,9 @@ reconstructTupleValues(AttrMap *map,
 extern TupleTableSlot *
 reconstructMatchingTupleSlot(TupleTableSlot *slot, ResultRelInfo *resultRelInfo);
 
+extern void
+makePartitionCheckMap(EState *estate, ResultRelInfo *resultRelInfo);
+
 /*
  * In PostgreSQL, ExecInsert, ExecDelete and ExecUpdate are static in nodeModifyTable.c.
  * In GPDB, they're exported.
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 0c6692e9eac9..2ff11d3f587b 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -382,11 +382,11 @@ typedef struct ResultRelInfo
 	uint64		ri_aoprocessed; /* tuples added/deleted for AO */
 	struct AttrMap *ri_partInsertMap;
 	TupleTableSlot *ri_resultSlot;
-	/* Parent relation in checkPartitionUpdate */
+	/* Parent relation in makePartitionCheckMap */
 	Relation	ri_PartitionParent;
-	/* tupdesc_match for checkPartitionUpdate */
+	/* tupdesc_match for makePartitionCheckMap */
 	int			ri_PartCheckTupDescMatch;
-	/* Attribute map in checkPartitionUpdate */
+	/* Attribute map in makePartitionCheckMap */
 	struct AttrMap *ri_PartCheckMap;
 
 	/*
diff --git a/src/test/regress/expected/qp_dropped_cols.out b/src/test/regress/expected/qp_dropped_cols.out
index c0aa54e30f20..bdfc308ae2db 100644
--- a/src/test/regress/expected/qp_dropped_cols.out
+++ b/src/test/regress/expected/qp_dropped_cols.out
@@ -16360,3 +16360,302 @@ DELETE FROM dist_key_dropped_pt WHERE b=6;
 -- the tables, or the pg_upgrade test fails.
 set client_min_messages='warning';
 drop schema qp_dropped_cols cascade;
+-- Test modifying DML on leaf partition when parent has dropped columns and
+-- the partition has not. Ensure that DML commands pass without execution
+-- errors and produce valid results.
+RESET search_path;
+-- start_ignore
+DROP TABLE IF EXISTS t_part_dropped;
+-- end_ignore
+CREATE TABLE t_part_dropped (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+ALTER TABLE t_part_dropped DROP c2;
+ALTER TABLE t_part_dropped ADD PARTITION p2 VALUES (2);
+-- Partition selection should go smoothly when inserting into leaf
+-- partition with different attribute structure.
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped VALUES (1, 2, 4);
+               QUERY PLAN               
+----------------------------------------
+ Insert on public.t_part_dropped
+   ->  Result
+         Output: 1, NULL::integer, 2, 4
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+INSERT INTO t_part_dropped VALUES (1, 2, 4);
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+                QUERY PLAN                
+------------------------------------------
+ Insert on public.t_part_dropped_1_prt_p2
+   ->  Result
+         Output: 1, 2, 4
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 0);
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+                             QUERY PLAN                              
+---------------------------------------------------------------------
+ Update on public.t_part_dropped_1_prt_p2
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 2, c3, c4, c1, ctid, gp_segment_id, (DMLAction)
+         Hash Key: c1
+         ->  Split
+               Output: 2, c3, c4, c1, ctid, gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_dropped_1_prt_p2
+                     Output: 2, c3, c4, c1, ctid, gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(10 rows)
+
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3;
+                                                                                                 QUERY PLAN                                                                                                 
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update on public.t_part_dropped_1_prt_p0
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_dropped_1_prt_p0
+                     Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id
+   ->  Redistribute Motion 3:3  (slice2; segments: 3)
+         Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_dropped_1_prt_p2
+                     Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(17 rows)
+
+UPDATE t_part_dropped SET c1 = 3;
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part_dropped VALUES (1, 2, 0);
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+ count 
+-------
+     4
+(1 row)
+
+-- Split update on root relation should choose the correct partition
+-- at insert (executor doesn't put the tuple to wrong partition for legacy
+-- planner case).
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+                                                                                                 QUERY PLAN                                                                                                 
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update on public.t_part_dropped_1_prt_p0
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_dropped_1_prt_p0
+                     Output: 3, NULL::integer, t_part_dropped_1_prt_p0.c3, t_part_dropped_1_prt_p0.c4, t_part_dropped_1_prt_p0.c1, t_part_dropped_1_prt_p0.ctid, t_part_dropped_1_prt_p0.gp_segment_id
+                     Filter: (t_part_dropped_1_prt_p0.c4 = 0)
+   ->  Redistribute Motion 3:3  (slice2; segments: 3)
+         Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_dropped_1_prt_p2
+                     Output: 3, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id
+                     Filter: (t_part_dropped_1_prt_p2.c4 = 0)
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(19 rows)
+
+UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT * FROM t_part_dropped_1_prt_p0;
+ c1 | c3 | c4 
+----+----+----
+(0 rows)
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_dropped_1_prt_p2;
+                    QUERY PLAN                    
+--------------------------------------------------
+ Delete on public.t_part_dropped_1_prt_p2
+   ->  Seq Scan on public.t_part_dropped_1_prt_p2
+         Output: ctid, gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+DELETE FROM t_part_dropped_1_prt_p2;
+DROP TABLE t_part_dropped;
+-- Test modifying DML on leaf partition after it was exchanged with a relation,
+-- that contained dropped columns. Ensure that DML commands pass without
+-- execution errors and produce valid results.
+-- start_ignore
+DROP TABLE IF EXISTS t_part;
+DROP TABLE IF EXISTS t_new_part;
+-- end_ignore
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part DROP c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part;
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part VALUES (1, 5, 2, 5);
+             QUERY PLAN              
+-------------------------------------
+ Insert on public.t_part
+   ->  Result
+         Output: 1, 5, 2, 5
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+INSERT INTO t_part VALUES (1, 5, 2, 5);
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+                QUERY PLAN                 
+-------------------------------------------
+ Insert on public.t_part_1_prt_p2
+   ->  Result
+         Output: 1, NULL::integer, 5, 2, 5
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_1_prt_p2 SET c1 = 2;
+                                       QUERY PLAN                                       
+----------------------------------------------------------------------------------------
+ Update on public.t_part_1_prt_p2
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 2, NULL::integer, c2, c3, c4, c1, ctid, gp_segment_id, (DMLAction)
+         Hash Key: c1
+         ->  Split
+               Output: 2, NULL::integer, c2, c3, c4, c1, ctid, gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_1_prt_p2
+                     Output: 2, NULL::integer, c2, c3, c4, c1, ctid, gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(10 rows)
+
+UPDATE t_part_1_prt_p2 SET c1 = 2;
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+                                                                                       QUERY PLAN                                                                                       
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update on public.t_part_1_prt_p0
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 3, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_1_prt_p0
+                     Output: 3, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id
+   ->  Redistribute Motion 3:3  (slice2; segments: 3)
+         Output: 3, NULL::integer, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, NULL::integer, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_1_prt_p2
+                     Output: 3, NULL::integer, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(17 rows)
+
+UPDATE t_part SET c1 = 3;
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part VALUES (1, 0, 2, 0);
+UPDATE t_part_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+SELECT count(*) FROM t_part_1_prt_p2;
+ count 
+-------
+     3
+(1 row)
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_1_prt_p2;
+                QUERY PLAN                
+------------------------------------------
+ Delete on public.t_part_1_prt_p2
+   ->  Seq Scan on public.t_part_1_prt_p2
+         Output: ctid, gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(5 rows)
+
+DELETE FROM t_part_1_prt_p2;
+DROP TABLE t_part;
+DROP TABLE t_new_part;
+-- Test split update execution of a plan from legacy planner in case
+-- when parent relation has several partitions, and one of them has
+-- physically-different attribute structure from parent's due to
+-- dropped columns. Ensure that split update does not reconstruct tuple
+-- of correct (without dropped attributes) partition.
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+-- Legacy planner UPDATE's plan consists of several subplans (partitioned
+-- relations are considered in inheritance planner), and their execution
+-- order varies depending on the order the partitions have been added.
+-- Therefore, we add each partition through EXCHANGE to get UPDATE's
+-- test plan in a form such that the t_new_part0 update comes first, and the
+-- t_new_part2 comes second. This aspect is crucial because executor's
+-- partitions related logic depended on that fact, what led to the
+-- issue this test demonstrates.
+-- This paritition is not compatible with the parent due to dropped columns
+CREATE TABLE t_new_part0 (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part0 drop c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (0) WITH TABLE t_new_part0;
+-- This partition is compatible with the parent.
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part2 (c1 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part2;
+-- Insert into correct partition, and perform split update on root,
+-- that will execute split update on each subplan in case of inheritance
+-- plan (legacy planner). Ensure that split update does not reconstruct the
+-- tuple at insert.
+INSERT INTO t_part VALUES (1, 4, 2, 2);
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+                                                                                       QUERY PLAN                                                                                       
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update on public.t_part_1_prt_p0
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: 3, NULL::integer, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, NULL::integer, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_1_prt_p0
+                     Output: 3, NULL::integer, t_part_1_prt_p0.c2, t_part_1_prt_p0.c3, t_part_1_prt_p0.c4, t_part_1_prt_p0.c1, t_part_1_prt_p0.ctid, t_part_1_prt_p0.gp_segment_id
+   ->  Redistribute Motion 3:3  (slice2; segments: 3)
+         Output: 3, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: "outer".c1
+         ->  Split
+               Output: 3, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, DMLAction
+               ->  Seq Scan on public.t_part_1_prt_p2
+                     Output: 3, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.c1, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id
+ Optimizer: Postgres query optimizer
+ Settings: optimizer=off
+(17 rows)
+
+UPDATE t_part SET c1 = 3;
+SELECT * FROM t_part_1_prt_p2;
+ c1 | c2 | c3 | c4 
+----+----+----+----
+  3 |  4 |  2 |  2
+(1 row)
+
+DROP TABLE t_part;
+DROP TABLE t_new_part0;
+DROP TABLE t_new_part2;
diff --git a/src/test/regress/expected/qp_dropped_cols_optimizer.out b/src/test/regress/expected/qp_dropped_cols_optimizer.out
index 6ee68fc7f4a6..ff72f0edf2b6 100644
--- a/src/test/regress/expected/qp_dropped_cols_optimizer.out
+++ b/src/test/regress/expected/qp_dropped_cols_optimizer.out
@@ -16273,3 +16273,329 @@ DELETE FROM dist_key_dropped_pt WHERE b=6;
 -- the tables, or the pg_upgrade test fails.
 set client_min_messages='warning';
 drop schema qp_dropped_cols cascade;
+-- Test modifying DML on leaf partition when parent has dropped columns and
+-- the partition has not. Ensure that DML commands pass without execution
+-- errors and produce valid results.
+RESET search_path;
+-- start_ignore
+DROP TABLE IF EXISTS t_part_dropped;
+-- end_ignore
+CREATE TABLE t_part_dropped (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+ALTER TABLE t_part_dropped DROP c2;
+ALTER TABLE t_part_dropped ADD PARTITION p2 VALUES (2);
+-- Partition selection should go smoothly when inserting into leaf
+-- partition with different attribute structure.
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped VALUES (1, 2, 4);
+                    QUERY PLAN                    
+--------------------------------------------------
+ Insert
+   Output: c1, NULL::integer, c3, c4, ColRef_0004
+   ->  Result
+         Output: c1, c3, c4, 1
+         ->  Result
+               Output: c1, c3, c4
+               ->  Result
+                     Output: 1, 2, 4
+                     ->  Result
+                           Output: true
+ Optimizer: Pivotal Optimizer (GPORCA)
+(11 rows)
+
+INSERT INTO t_part_dropped VALUES (1, 2, 4);
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+               QUERY PLAN               
+----------------------------------------
+ Insert
+   Output: c1, c3, c4, ColRef_0004
+   ->  Result
+         Output: c1, c3, c4, 1
+         ->  Result
+               Output: c1, c3, c4
+               ->  Result
+                     Output: 1, 2, 4
+                     ->  Result
+                           Output: true
+ Optimizer: Pivotal Optimizer (GPORCA)
+(11 rows)
+
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 0);
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+                                                                                        QUERY PLAN                                                                                         
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, (DMLAction), t_part_dropped_1_prt_p2.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: t_part_dropped_1_prt_p2.c1
+         ->  Split
+               Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, 2, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id
+                     ->  Seq Scan on public.t_part_dropped_1_prt_p2
+                           Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(12 rows)
+
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3;
+                                                                     QUERY PLAN                                                                     
+----------------------------------------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part_dropped.c1, NULL::integer, t_part_dropped.c3, t_part_dropped.c4, (DMLAction), t_part_dropped.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id, (DMLAction)
+         Hash Key: t_part_dropped.c1
+         ->  Split
+               Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, 3, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+                     ->  Sequence
+                           Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+                           ->  Partition Selector for t_part_dropped (dynamic scan id: 1)
+                                 Partitions selected: 2 (out of 2)
+                           ->  Dynamic Seq Scan on public.t_part_dropped (dynamic scan id: 1)
+                                 Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(16 rows)
+
+UPDATE t_part_dropped SET c1 = 3;
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part_dropped VALUES (1, 2, 0);
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+ count 
+-------
+     4
+(1 row)
+
+-- Split update on root relation should choose the correct partition
+-- at insert (executor doesn't put the tuple to wrong partition for legacy
+-- planner case).
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+                                                                     QUERY PLAN                                                                     
+----------------------------------------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part_dropped.c1, NULL::integer, t_part_dropped.c3, t_part_dropped.c4, (DMLAction), t_part_dropped.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id, (DMLAction)
+         Hash Key: t_part_dropped.c1
+         ->  Split
+               Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, 3, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+                     ->  Sequence
+                           Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+                           ->  Partition Selector for t_part_dropped (dynamic scan id: 1)
+                                 Partitions selected: 2 (out of 2)
+                           ->  Dynamic Seq Scan on public.t_part_dropped (dynamic scan id: 1)
+                                 Output: t_part_dropped.c1, t_part_dropped.c3, t_part_dropped.c4, t_part_dropped.ctid, t_part_dropped.gp_segment_id
+                                 Filter: (t_part_dropped.c4 = 0)
+ Optimizer: Pivotal Optimizer (GPORCA)
+(17 rows)
+
+UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT * FROM t_part_dropped_1_prt_p0;
+ c1 | c3 | c4 
+----+----+----
+(0 rows)
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_dropped_1_prt_p2;
+                                                                                  QUERY PLAN                                                                                   
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Delete
+   Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, "outer".ColRef_0010, t_part_dropped_1_prt_p2.ctid
+   ->  Result
+         Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id, 0
+         ->  Seq Scan on public.t_part_dropped_1_prt_p2
+               Output: t_part_dropped_1_prt_p2.c1, t_part_dropped_1_prt_p2.c3, t_part_dropped_1_prt_p2.c4, t_part_dropped_1_prt_p2.ctid, t_part_dropped_1_prt_p2.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(7 rows)
+
+DELETE FROM t_part_dropped_1_prt_p2;
+DROP TABLE t_part_dropped;
+-- Test modifying DML on leaf partition after it was exchanged with a relation,
+-- that contained dropped columns. Ensure that DML commands pass without
+-- execution errors and produce valid results.
+-- start_ignore
+DROP TABLE IF EXISTS t_part;
+DROP TABLE IF EXISTS t_new_part;
+-- end_ignore
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part DROP c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part;
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part VALUES (1, 5, 2, 5);
+               QUERY PLAN               
+----------------------------------------
+ Insert
+   Output: c1, c2, c3, c4, ColRef_0005
+   ->  Result
+         Output: c1, c2, c3, c4, 1
+         ->  Result
+               Output: c1, c2, c3, c4
+               ->  Result
+                     Output: 1, 5, 2, 5
+                     ->  Result
+                           Output: true
+ Optimizer: Pivotal Optimizer (GPORCA)
+(11 rows)
+
+INSERT INTO t_part VALUES (1, 5, 2, 5);
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+                      QUERY PLAN                      
+------------------------------------------------------
+ Insert
+   Output: c1, NULL::integer, c2, c3, c4, ColRef_0005
+   ->  Result
+         Output: c1, c2, c3, c4, 1
+         ->  Result
+               Output: c1, c2, c3, c4
+               ->  Result
+                     Output: 1, 5, 2, 5
+                     ->  Result
+                           Output: true
+ Optimizer: Pivotal Optimizer (GPORCA)
+(11 rows)
+
+INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_1_prt_p2 SET c1 = 2;
+                                                                              QUERY PLAN                                                                               
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part_1_prt_p2.c1, NULL::integer, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, (DMLAction), t_part_1_prt_p2.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, (DMLAction)
+         Hash Key: t_part_1_prt_p2.c1
+         ->  Split
+               Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, 2, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id
+                     ->  Seq Scan on public.t_part_1_prt_p2
+                           Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(12 rows)
+
+UPDATE t_part_1_prt_p2 SET c1 = 2;
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+                                                      QUERY PLAN                                                       
+-----------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, (DMLAction), t_part.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id, (DMLAction)
+         Hash Key: t_part.c1
+         ->  Split
+               Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, 3, t_part.ctid, t_part.gp_segment_id
+                     ->  Sequence
+                           Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id
+                           ->  Partition Selector for t_part (dynamic scan id: 1)
+                                 Partitions selected: 2 (out of 2)
+                           ->  Dynamic Seq Scan on public.t_part (dynamic scan id: 1)
+                                 Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(16 rows)
+
+UPDATE t_part SET c1 = 3;
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part VALUES (1, 0, 2, 0);
+UPDATE t_part_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+SELECT count(*) FROM t_part_1_prt_p2;
+ count 
+-------
+     3
+(1 row)
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_1_prt_p2;
+                                                                        QUERY PLAN                                                                         
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ Delete
+   Output: t_part_1_prt_p2.c1, NULL::integer, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, "outer".ColRef_0011, t_part_1_prt_p2.ctid
+   ->  Result
+         Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id, 0
+         ->  Seq Scan on public.t_part_1_prt_p2
+               Output: t_part_1_prt_p2.c1, t_part_1_prt_p2.c2, t_part_1_prt_p2.c3, t_part_1_prt_p2.c4, t_part_1_prt_p2.ctid, t_part_1_prt_p2.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(7 rows)
+
+DELETE FROM t_part_1_prt_p2;
+DROP TABLE t_part;
+DROP TABLE t_new_part;
+-- Test split update execution of a plan from legacy planner in case
+-- when parent relation has several partitions, and one of them has
+-- physically-different attribute structure from parent's due to
+-- dropped columns. Ensure that split update does not reconstruct tuple
+-- of correct (without dropped attributes) partition.
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+-- Legacy planner UPDATE's plan consists of several subplans (partitioned
+-- relations are considered in inheritance planner), and their execution
+-- order varies depending on the order the partitions have been added.
+-- Therefore, we add each partition through EXCHANGE to get UPDATE's
+-- test plan in a form such that the t_new_part0 update comes first, and the
+-- t_new_part2 comes second. This aspect is crucial because executor's
+-- partitions related logic depended on that fact, what led to the
+-- issue this test demonstrates.
+-- This paritition is not compatible with the parent due to dropped columns
+CREATE TABLE t_new_part0 (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part0 drop c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (0) WITH TABLE t_new_part0;
+-- This partition is compatible with the parent.
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part2 (c1 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part2;
+-- Insert into correct partition, and perform split update on root,
+-- that will execute split update on each subplan in case of inheritance
+-- plan (legacy planner). Ensure that split update does not reconstruct the
+-- tuple at insert.
+INSERT INTO t_part VALUES (1, 4, 2, 2);
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+                                                      QUERY PLAN                                                       
+-----------------------------------------------------------------------------------------------------------------------
+ Update
+   Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, (DMLAction), t_part.ctid
+   ->  Redistribute Motion 3:3  (slice1; segments: 3)
+         Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id, (DMLAction)
+         Hash Key: t_part.c1
+         ->  Split
+               Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id, DMLAction
+               ->  Result
+                     Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, 3, t_part.ctid, t_part.gp_segment_id
+                     ->  Sequence
+                           Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id
+                           ->  Partition Selector for t_part (dynamic scan id: 1)
+                                 Partitions selected: 2 (out of 2)
+                           ->  Dynamic Seq Scan on public.t_part (dynamic scan id: 1)
+                                 Output: t_part.c1, t_part.c2, t_part.c3, t_part.c4, t_part.ctid, t_part.gp_segment_id
+ Optimizer: Pivotal Optimizer (GPORCA)
+(16 rows)
+
+UPDATE t_part SET c1 = 3;
+SELECT * FROM t_part_1_prt_p2;
+ c1 | c2 | c3 | c4 
+----+----+----+----
+  3 |  4 |  2 |  2
+(1 row)
+
+DROP TABLE t_part;
+DROP TABLE t_new_part0;
+DROP TABLE t_new_part2;
diff --git a/src/test/regress/sql/qp_dropped_cols.sql b/src/test/regress/sql/qp_dropped_cols.sql
index 6823131c0993..5a93bd5aec72 100644
--- a/src/test/regress/sql/qp_dropped_cols.sql
+++ b/src/test/regress/sql/qp_dropped_cols.sql
@@ -8687,3 +8687,140 @@ DELETE FROM dist_key_dropped_pt WHERE b=6;
 -- the tables, or the pg_upgrade test fails.
 set client_min_messages='warning';
 drop schema qp_dropped_cols cascade;
+
+-- Test modifying DML on leaf partition when parent has dropped columns and
+-- the partition has not. Ensure that DML commands pass without execution
+-- errors and produce valid results.
+RESET search_path;
+-- start_ignore
+DROP TABLE IF EXISTS t_part_dropped;
+-- end_ignore
+CREATE TABLE t_part_dropped (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+
+ALTER TABLE t_part_dropped DROP c2;
+ALTER TABLE t_part_dropped ADD PARTITION p2 VALUES (2);
+
+-- Partition selection should go smoothly when inserting into leaf
+-- partition with different attribute structure.
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped VALUES (1, 2, 4);
+INSERT INTO t_part_dropped VALUES (1, 2, 4);
+
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 4);
+
+INSERT INTO t_part_dropped_1_prt_p2 VALUES (1, 2, 0);
+
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2;
+
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3;
+UPDATE t_part_dropped SET c1 = 3;
+
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part_dropped VALUES (1, 2, 0);
+UPDATE t_part_dropped_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+
+-- Split update on root relation should choose the correct partition
+-- at insert (executor doesn't put the tuple to wrong partition for legacy
+-- planner case).
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+UPDATE t_part_dropped SET c1 = 3 WHERE c4 = 0;
+
+SELECT count(*) FROM t_part_dropped_1_prt_p2;
+SELECT * FROM t_part_dropped_1_prt_p0;
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_dropped_1_prt_p2;
+DELETE FROM t_part_dropped_1_prt_p2;
+
+DROP TABLE t_part_dropped;
+
+-- Test modifying DML on leaf partition after it was exchanged with a relation,
+-- that contained dropped columns. Ensure that DML commands pass without
+-- execution errors and produce valid results.
+-- start_ignore
+DROP TABLE IF EXISTS t_part;
+DROP TABLE IF EXISTS t_new_part;
+-- end_ignore
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part DROP c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part;
+
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part VALUES (1, 5, 2, 5);
+INSERT INTO t_part VALUES (1, 5, 2, 5);
+
+EXPLAIN (COSTS OFF, VERBOSE) INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+INSERT INTO t_part_1_prt_p2 VALUES (1, 5, 2, 5);
+
+-- Ensure that split update on leaf and root partitions does not
+-- throw partition selection error in both planners.
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part_1_prt_p2 SET c1 = 2;
+UPDATE t_part_1_prt_p2 SET c1 = 2;
+
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+UPDATE t_part SET c1 = 3;
+
+-- Ensure that split update on leaf partition does not throw constraint error
+-- (executor does not choose the wrong partition at insert stage of update).
+INSERT INTO t_part VALUES (1, 0, 2, 0);
+UPDATE t_part_1_prt_p2 SET c1 = 2 WHERE c4 = 0;
+
+SELECT count(*) FROM t_part_1_prt_p2;
+
+-- For ORCA the partition selection error should not occur.
+EXPLAIN (COSTS OFF, VERBOSE) DELETE FROM t_part_1_prt_p2;
+DELETE FROM t_part_1_prt_p2;
+
+DROP TABLE t_part;
+DROP TABLE t_new_part;
+
+-- Test split update execution of a plan from legacy planner in case
+-- when parent relation has several partitions, and one of them has
+-- physically-different attribute structure from parent's due to
+-- dropped columns. Ensure that split update does not reconstruct tuple
+-- of correct (without dropped attributes) partition.
+CREATE TABLE t_part (c1 int, c2 int, c3 int, c4 int) DISTRIBUTED BY (c1)
+PARTITION BY LIST (c3) (PARTITION p0 VALUES (0));
+
+-- Legacy planner UPDATE's plan consists of several subplans (partitioned
+-- relations are considered in inheritance planner), and their execution
+-- order varies depending on the order the partitions have been added.
+-- Therefore, we add each partition through EXCHANGE to get UPDATE's
+-- test plan in a form such that the t_new_part0 update comes first, and the
+-- t_new_part2 comes second. This aspect is crucial because executor's
+-- partitions related logic depended on that fact, what led to the
+-- issue this test demonstrates.
+-- This paritition is not compatible with the parent due to dropped columns
+CREATE TABLE t_new_part0 (c1 int, c11 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_new_part0 drop c11;
+ALTER TABLE t_part EXCHANGE PARTITION FOR (0) WITH TABLE t_new_part0;
+
+-- This partition is compatible with the parent.
+ALTER TABLE t_part ADD PARTITION p2 VALUES (2);
+CREATE TABLE t_new_part2 (c1 int, c2 int, c3 int, c4 int);
+ALTER TABLE t_part EXCHANGE PARTITION FOR (2) WITH TABLE t_new_part2;
+
+-- Insert into correct partition, and perform split update on root,
+-- that will execute split update on each subplan in case of inheritance
+-- plan (legacy planner). Ensure that split update does not reconstruct the
+-- tuple at insert.
+INSERT INTO t_part VALUES (1, 4, 2, 2);
+
+EXPLAIN (COSTS OFF, VERBOSE) UPDATE t_part SET c1 = 3;
+UPDATE t_part SET c1 = 3;
+
+SELECT * FROM t_part_1_prt_p2;
+
+DROP TABLE t_part;
+DROP TABLE t_new_part0;
+DROP TABLE t_new_part2;

From 6f87a842ca88b1c3e39639fbaa5ec2215a1d3b48 Mon Sep 17 00:00:00 2001
From: Vasiliy Ivanov <ivi@arenadata.io>
Date: Wed, 6 Dec 2023 17:06:17 +0200
Subject: [PATCH 22/22] alter precedence in favor of ipv4 during resolving
 (#657)

gpdb test suite requires enabled ipv6 since 7f3c91f. But there is at
least one src/test/ssl test that expects resolving to ipv4 address and
fails in the ipv6 environment with:

```
psql: FATAL:  no pg_hba.conf entry for host "2001:db8:1::242:ac11:2",
user "ssltestuser", database "postgres", SSL on
pg_regress: cannot read the result
(using postmaster on 9f17c91f4c76, port 6000)
```

so we at least temporary try to change precedence of name resolution in
favor of ipv4
---
 arenadata/Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/arenadata/Dockerfile b/arenadata/Dockerfile
index ee0fb40d6a8c..eab478296971 100644
--- a/arenadata/Dockerfile
+++ b/arenadata/Dockerfile
@@ -57,7 +57,8 @@ RUN yum -y install centos-release-scl && \
     echo -e 'source /opt/rh/devtoolset-7/enable' >> /opt/gcc_env.sh && \
     echo -e '#!/bin/sh' >> /etc/profile.d/jdk_home.sh && \
     echo -e 'export JAVA_HOME=/etc/alternatives/java_sdk' >> /etc/profile.d/jdk_home.sh && \
-    echo -e 'export PATH=$JAVA_HOME/bin:$PATH' >> /etc/profile.d/jdk_home.sh
+    echo -e 'export PATH=$JAVA_HOME/bin:$PATH' >> /etc/profile.d/jdk_home.sh && \
+    echo -e 'precedence ::ffff:0:0/96  100' >> /etc/gai.conf
 
 RUN rpm -i $sigar && rpm -i $sigar_headers