Pluggable Storage - Andres's take

From e96746d07b8dfcdb17082b54524505163f5e237a Mon Sep 17 00:00:00 2001
From: Hari Babu <haribabuk@fast.au.fujitsu.com>
Date: Tue, 24 Jul 2018 23:18:15 +1000
Subject: [PATCH 2/2] New API to get heap page tuples

This API is used in bitmap scan to get all the visible tuples
from the page.
---
 src/backend/access/heap/heapam_handler.c  | 105 ++++++++++++++++++++++
 src/backend/executor/nodeBitmapHeapscan.c | 100 ++-------------------
 src/include/access/tableam.h              |  20 +++++
 3 files changed, 131 insertions(+), 94 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 42eec2a2ab..a3fe110efe 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -33,9 +33,13 @@
 
 #include "storage/bufpage.h"
 #include "storage/bufmgr.h"
+#include "storage/predicate.h"
 #include "access/xact.h"
 
 
+static bool heapam_fetch_tuple_from_offset(TableScanDesc sscan, BlockNumber blkno,
+										   OffsetNumber offset, TupleTableSlot *slot);
+
 /* ----------------------------------------------------------------
  *				storage AM support routines for heapam
  * ----------------------------------------------------------------
@@ -462,6 +466,106 @@ heapam_get_heappagescandesc(TableScanDesc sscan)
 	return &scan->rs_pagescan;
 }
 
+static void
+heapam_scan_get_page_tuples(TableScanDesc scan,
+						   HeapPageScanDesc pagescan,
+						   TupleTableSlot *slot,
+						   BlockNumber page,
+						   int ntuples,
+						   OffsetNumber *offsets)
+{
+	Buffer		buffer;
+	Snapshot	snapshot;
+	int			ntup;
+
+	/*
+	 * Acquire pin on the target heap page, trading in any pin we held before.
+	 */
+	Assert(page < pagescan->rs_nblocks);
+
+	scan->rs_cbuf = ReleaseAndReadBuffer(scan->rs_cbuf,
+										 scan->rs_rd,
+										 page);
+	buffer = scan->rs_cbuf;
+	snapshot = scan->rs_snapshot;
+
+	ntup = 0;
+
+	/*
+	 * Prune and repair fragmentation for the whole page, if possible.
+	 */
+	heap_page_prune_opt(scan->rs_rd, buffer);
+
+	/*
+	 * We must hold share lock on the buffer content while examining tuple
+	 * visibility.  Afterwards, however, the tuples we have found to be
+	 * visible are guaranteed good as long as we hold the buffer pin.
+	 */
+	LockBuffer(buffer, BUFFER_LOCK_SHARE);
+
+	/*
+	 * We need two separate strategies for lossy and non-lossy cases.
+	 */
+	if (ntuples >= 0)
+	{
+		/*
+		 * Bitmap is non-lossy, so we just look through the offsets listed in
+		 * tbmres; but we have to follow any HOT chain starting at each such
+		 * offset.
+		 */
+		int			curslot;
+
+		for (curslot = 0; curslot < ntuples; curslot++)
+		{
+			OffsetNumber offnum = offsets[curslot];
+			ItemPointerData tid;
+			HeapTupleData heapTuple;
+
+			ItemPointerSet(&tid, page, offnum);
+			if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
+									   &heapTuple, NULL, true))
+				pagescan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
+		}
+	}
+	else
+	{
+		/*
+		 * Bitmap is lossy, so we must examine each item pointer on the page.
+		 * But we can ignore HOT chains, since we'll check each tuple anyway.
+		 */
+		Page		dp = (Page) BufferGetPage(buffer);
+		OffsetNumber maxoff = PageGetMaxOffsetNumber(dp);
+		OffsetNumber offnum;
+
+		for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
+		{
+			ItemId		lp;
+			bool		valid;
+			BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
+
+			lp = PageGetItemId(dp, offnum);
+			if (!ItemIdIsNormal(lp))
+				continue;
+
+			/* FIXME: unnecessarily pins */
+			heapam_fetch_tuple_from_offset(scan, page, offnum, slot);
+			valid = HeapTupleSatisfies(bslot->base.tuple, snapshot, bslot->buffer);
+			if (valid)
+			{
+				pagescan->rs_vistuples[ntup++] = offnum;
+				PredicateLockTuple(scan->rs_rd, bslot->base.tuple, snapshot);
+			}
+			CheckForSerializableConflictOut(valid, scan->rs_rd, bslot->base.tuple,
+											buffer, snapshot);
+		}
+	}
+
+	LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
+
+	Assert(ntup <= MaxHeapTuplesPerPage);
+	pagescan->rs_ntuples = ntup;
+}
+
 static bool
 heapam_fetch_tuple_from_offset(TableScanDesc sscan, BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot)
 {
@@ -683,6 +787,7 @@ heap_tableam_handler(PG_FUNCTION_ARGS)
 	 * BitmapHeap and Sample Scans
 	 */
 	amroutine->scan_get_heappagescandesc = heapam_get_heappagescandesc;
+	amroutine->scan_get_page_tuples = heapam_scan_get_page_tuples;
 	amroutine->sync_scan_report_location = ss_report_location;
 
 	amroutine->tuple_fetch_row_version = heapam_fetch_row_version;
diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index 8521e45132..be123728eb 100644
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -371,100 +371,12 @@ BitmapHeapNext(BitmapHeapScanState *node)
 static void
 bitgetpage(BitmapHeapScanState *node, TBMIterateResult *tbmres)
 {
-	TableScanDesc scan = node->ss.ss_currentScanDesc;
-	HeapPageScanDesc pagescan = node->pagescan;
-	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
-	BlockNumber page = tbmres->blockno;
-	Buffer		buffer;
-	Snapshot	snapshot;
-	int			ntup;
-
-	/*
-	 * Acquire pin on the target heap page, trading in any pin we held before.
-	 */
-	Assert(page < pagescan->rs_nblocks);
-
-	scan->rs_cbuf = ReleaseAndReadBuffer(scan->rs_cbuf,
-										 scan->rs_rd,
-										 page);
-	buffer = scan->rs_cbuf;
-	snapshot = scan->rs_snapshot;
-
-	ntup = 0;
-
-	/*
-	 * Prune and repair fragmentation for the whole page, if possible.
-	 */
-	heap_page_prune_opt(scan->rs_rd, buffer);
-
-	/*
-	 * We must hold share lock on the buffer content while examining tuple
-	 * visibility.  Afterwards, however, the tuples we have found to be
-	 * visible are guaranteed good as long as we hold the buffer pin.
-	 */
-	LockBuffer(buffer, BUFFER_LOCK_SHARE);
-
-	/*
-	 * We need two separate strategies for lossy and non-lossy cases.
-	 */
-	if (tbmres->ntuples >= 0)
-	{
-		/*
-		 * Bitmap is non-lossy, so we just look through the offsets listed in
-		 * tbmres; but we have to follow any HOT chain starting at each such
-		 * offset.
-		 */
-		int			curslot;
-
-		for (curslot = 0; curslot < tbmres->ntuples; curslot++)
-		{
-			OffsetNumber offnum = tbmres->offsets[curslot];
-			ItemPointerData tid;
-			HeapTupleData heapTuple;
-
-			ItemPointerSet(&tid, page, offnum);
-			if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
-									   &heapTuple, NULL, true))
-				pagescan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
-		}
-	}
-	else
-	{
-		/*
-		 * Bitmap is lossy, so we must examine each item pointer on the page.
-		 * But we can ignore HOT chains, since we'll check each tuple anyway.
-		 */
-		Page		dp = (Page) BufferGetPage(buffer);
-		OffsetNumber maxoff = PageGetMaxOffsetNumber(dp);
-		OffsetNumber offnum;
-
-		for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
-		{
-			ItemId		lp;
-			bool		valid;
-			BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-
-			lp = PageGetItemId(dp, offnum);
-			if (!ItemIdIsNormal(lp))
-				continue;
-
-			/* FIXME: unnecessarily pins */
-			table_tuple_fetch_from_offset(scan, page, offnum, slot);
-			valid = HeapTupleSatisfies(bslot->base.tuple, snapshot, bslot->buffer);
-			if (valid)
-			{
-				pagescan->rs_vistuples[ntup++] = offnum;
-				PredicateLockTuple(scan->rs_rd, bslot->base.tuple, snapshot);
-			}
-			CheckForSerializableConflictOut(valid, scan->rs_rd, bslot->base.tuple,
-											buffer, snapshot);
-		}
-	}
-
-	LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
-
-	Assert(ntup <= MaxHeapTuplesPerPage);
-	pagescan->rs_ntuples = ntup;
+	table_scan_get_page_tuples(node->ss.ss_currentScanDesc,
+			node->pagescan,
+			node->ss.ss_ScanTupleSlot,
+			tbmres->blockno,
+			tbmres->ntuples,
+			tbmres->offsets);
 }
 
 /*
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index bf675ff881..df60ba3316 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -172,6 +172,13 @@ typedef bool (*TupleFetchFollow_function)(struct IndexFetchTableData *scan,
 										  TupleTableSlot *slot,
 										  bool *call_again, bool *all_dead);
 
+typedef void (*ScanGetPageTuples_function)(TableScanDesc scan,
+										   HeapPageScanDesc pagescan,
+										   TupleTableSlot *slot,
+										   BlockNumber page,
+										   int ntuples,
+										   OffsetNumber *offsets);
+
 /*
  * API struct for a table AM.  Note this must be stored in a single palloc'd
  * chunk of memory.
@@ -224,6 +231,7 @@ typedef struct TableAmRoutine
 	ScanGetpage_function scan_getpage;
 	ScanRescan_function scan_rescan;
 	ScanUpdateSnapshot_function scan_update_snapshot;
+	ScanGetPageTuples_function scan_get_page_tuples;
 
 	BeginIndexFetchTable_function begin_index_fetch;
 	EndIndexFetchTable_function reset_index_fetch;
@@ -472,6 +480,18 @@ table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
 	scan->rs_rd->rd_tableamroutine->scan_update_snapshot(scan, snapshot);
 }
 
+static inline void
+table_scan_get_page_tuples(TableScanDesc scan,
+		   HeapPageScanDesc pagescan,
+		   TupleTableSlot *slot,
+		   BlockNumber page,
+		   int ntuples,
+		   OffsetNumber *offsets)
+{
+	scan->rs_rd->rd_tableamroutine->scan_get_page_tuples(scan, pagescan, slot, page, ntuples, offsets);
+}
+
+
 static inline TupleTableSlot *
 table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 {
-- 
2.18.0.windows.1

From 4bb12ad1e73927ee31683d728d5cdaebca6a53a6 Mon Sep 17 00:00:00 2001
From: Hari Babu <haribabuk@fast.au.fujitsu.com>
Date: Mon, 23 Jul 2018 14:44:35 +1000
Subject: [PATCH 1/2] Merge tableam.h and tableamapi.h

And also most tableam.c functions small inline functions.
Having one-line tableam.c wrappers makes this more expensive
than necessary.

The above change may added some internal headers also exposed
via tableam.h, may need another check.
---
 contrib/pgrowlocks/pgrowlocks.c          |   2 +-
 src/backend/access/heap/heapam.c         |   2 +-
 src/backend/access/heap/heapam_handler.c |   2 +-
 src/backend/access/heap/rewriteheap.c    |   1 +
 src/backend/access/nbtree/nbtsort.c      |   1 +
 src/backend/access/table/Makefile        |   2 +-
 src/backend/access/table/tableam.c       | 472 ---------------
 src/backend/access/table/tableamapi.c    |   2 +-
 src/backend/commands/cluster.c           |   2 +-
 src/backend/executor/execIndexing.c      |   1 +
 src/backend/executor/nodeSamplescan.c    |   1 +
 src/backend/optimizer/util/plancat.c     |   2 +-
 src/backend/postmaster/autovacuum.c      |   1 +
 src/backend/storage/lmgr/predicate.c     |   1 +
 src/backend/utils/adt/ri_triggers.c      |   1 +
 src/backend/utils/adt/selfuncs.c         |   1 +
 src/backend/utils/cache/relcache.c       |   2 +-
 src/include/access/relscan.h             |   1 -
 src/include/access/tableam.h             | 738 ++++++++++++++++++++---
 src/include/access/tableamapi.h          | 212 -------
 src/include/nodes/nodes.h                |   2 +-
 src/include/utils/tqual.h                |  15 -
 22 files changed, 669 insertions(+), 795 deletions(-)
 delete mode 100644 src/backend/access/table/tableam.c
 delete mode 100644 src/include/access/tableamapi.h

diff --git a/contrib/pgrowlocks/pgrowlocks.c b/contrib/pgrowlocks/pgrowlocks.c
index 3995a88397..959f5e7dc8 100644
--- a/contrib/pgrowlocks/pgrowlocks.c
+++ b/contrib/pgrowlocks/pgrowlocks.c
@@ -26,7 +26,7 @@
 
 #include "access/multixact.h"
 #include "access/relscan.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "access/xact.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_authid.h"
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 5b8155c911..40c1a5432d 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -45,7 +45,7 @@
 #include "access/multixact.h"
 #include "access/parallel.h"
 #include "access/relscan.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "access/sysattr.h"
 #include "access/transam.h"
 #include "access/tuptoaster.h"
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 94c64d8387..42eec2a2ab 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -23,7 +23,7 @@
 #include "access/heapam.h"
 #include "access/relscan.h"
 #include "access/rewriteheap.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "catalog/pg_am_d.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 2ddb421eb0..5dad191ab2 100644
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -110,6 +110,7 @@
 #include "access/heapam.h"
 #include "access/heapam_xlog.h"
 #include "access/rewriteheap.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/tuptoaster.h"
 #include "access/xact.h"
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 74f8e1bbeb..be74041df4 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -60,6 +60,7 @@
 #include "access/nbtree.h"
 #include "access/parallel.h"
 #include "access/relscan.h"
+#include "access/tableam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
 #include "access/xloginsert.h"
diff --git a/src/backend/access/table/Makefile b/src/backend/access/table/Makefile
index fe22bf9208..ff0989ed24 100644
--- a/src/backend/access/table/Makefile
+++ b/src/backend/access/table/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/access/table
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = tableam.o tableamapi.o tableam_common.o
+OBJS = tableamapi.o tableam_common.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
deleted file mode 100644
index 77c04aaa27..0000000000
--- a/src/backend/access/table/tableam.c
+++ /dev/null
@@ -1,472 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tableam.c
- *	  table access method code
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/access/table/tableam.c
- *
- *-------------------------------------------------------------------------
- */
-#include "postgres.h"
-
-#include "access/tableam.h"
-#include "access/tableamapi.h"
-#include "access/relscan.h"
-#include "storage/bufmgr.h"
-#include "utils/rel.h"
-#include "utils/tqual.h"
-
-TupleTableSlot*
-table_gimmegimmeslot(Relation relation, List **reglist)
-{
-	TupleTableSlot *slot;
-
-	slot = relation->rd_tableamroutine->gimmegimmeslot(relation);
-
-	if (reglist)
-		*reglist = lappend(*reglist, slot);
-
-	return slot;
-}
-
-/*
- *	table_fetch_row_version		- retrieve tuple with given tid
- *
- *  XXX: This shouldn't just take a tid, but tid + additional information
- */
-bool
-table_fetch_row_version(Relation r,
-						ItemPointer tid,
-						Snapshot snapshot,
-						TupleTableSlot *slot,
-						Relation stats_relation)
-{
-	return r->rd_tableamroutine->tuple_fetch_row_version(r, tid,
-														 snapshot, slot,
-														 stats_relation);
-}
-
-
-/*
- *	table_lock_tuple - lock a tuple in shared or exclusive mode
- *
- *  XXX: This shouldn't just take a tid, but tid + additional information
- */
-HTSU_Result
-table_lock_tuple(Relation relation, ItemPointer tid, Snapshot snapshot,
-				 TupleTableSlot *slot, CommandId cid, LockTupleMode mode,
-				 LockWaitPolicy wait_policy, uint8 flags,
-				 HeapUpdateFailureData *hufd)
-{
-	return relation->rd_tableamroutine->tuple_lock(relation, tid, snapshot, slot,
-												cid, mode, wait_policy,
-												flags, hufd);
-}
-
-/* ----------------
- *		heap_beginscan_parallel - join a parallel scan
- *
- *		Caller must hold a suitable lock on the correct relation.
- * ----------------
- */
-TableScanDesc
-table_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan)
-{
-	Snapshot	snapshot;
-
-	Assert(RelationGetRelid(relation) == parallel_scan->phs_relid);
-
-	if (!parallel_scan->phs_snapshot_any)
-	{
-		/* Snapshot was serialized -- restore it */
-		snapshot = RestoreSnapshot(parallel_scan->phs_snapshot_data);
-		RegisterSnapshot(snapshot);
-	}
-	else
-	{
-		/* SnapshotAny passed by caller (not serialized) */
-		snapshot = SnapshotAny;
-	}
-
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, 0, NULL, parallel_scan,
-												true, true, true, false, false, !parallel_scan->phs_snapshot_any);
-}
-
-ParallelHeapScanDesc
-tableam_get_parallelheapscandesc(TableScanDesc sscan)
-{
-	return sscan->rs_rd->rd_tableamroutine->scan_get_parallelheapscandesc(sscan);
-}
-
-HeapPageScanDesc
-tableam_get_heappagescandesc(TableScanDesc sscan)
-{
-	/*
-	 * Planner should have already validated whether the current storage
-	 * supports Page scans are not? This function will be called only from
-	 * Bitmap Heap scan and sample scan
-	 */
-	Assert(sscan->rs_rd->rd_tableamroutine->scan_get_heappagescandesc != NULL);
-
-	return sscan->rs_rd->rd_tableamroutine->scan_get_heappagescandesc(sscan);
-}
-
-void
-table_syncscan_report_location(Relation rel, BlockNumber location)
-{
-	return rel->rd_tableamroutine->sync_scan_report_location(rel, location);
-}
-
-/*
- * heap_setscanlimits - restrict range of a heapscan
- *
- * startBlk is the page to start at
- * numBlks is number of pages to scan (InvalidBlockNumber means "all")
- */
-void
-table_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
-{
-	sscan->rs_rd->rd_tableamroutine->scansetlimits(sscan, startBlk, numBlks);
-}
-
-
-/* ----------------
- *		heap_beginscan	- begin relation scan
- *
- * heap_beginscan is the "standard" case.
- *
- * heap_beginscan_catalog differs in setting up its own temporary snapshot.
- *
- * heap_beginscan_strat offers an extended API that lets the caller control
- * whether a nondefault buffer access strategy can be used, and whether
- * syncscan can be chosen (possibly resulting in the scan not starting from
- * block zero).  Both of these default to true with plain heap_beginscan.
- *
- * heap_beginscan_bm is an alternative entry point for setting up a
- * TableScanDesc for a bitmap heap scan.  Although that scan technology is
- * really quite unlike a standard seqscan, there is just enough commonality
- * to make it worth using the same data structure.
- *
- * heap_beginscan_sampling is an alternative entry point for setting up a
- * TableScanDesc for a TABLESAMPLE scan.  As with bitmap scans, it's worth
- * using the same data structure although the behavior is rather different.
- * In addition to the options offered by heap_beginscan_strat, this call
- * also allows control of whether page-mode visibility checking is used.
- * ----------------
- */
-TableScanDesc
-table_beginscan(Relation relation, Snapshot snapshot,
-				  int nkeys, ScanKey key)
-{
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
-												true, true, true, false, false, false);
-}
-
-TableScanDesc
-table_beginscan_catalog(Relation relation, int nkeys, ScanKey key)
-{
-	Oid			relid = RelationGetRelid(relation);
-	Snapshot	snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
-
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
-												true, true, true, false, false, true);
-}
-
-TableScanDesc
-table_beginscan_strat(Relation relation, Snapshot snapshot,
-						int nkeys, ScanKey key,
-						bool allow_strat, bool allow_sync)
-{
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
-												allow_strat, allow_sync, true,
-												false, false, false);
-}
-
-TableScanDesc
-table_beginscan_bm(Relation relation, Snapshot snapshot,
-					 int nkeys, ScanKey key)
-{
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
-												false, false, true, true, false, false);
-}
-
-TableScanDesc
-table_beginscan_sampling(Relation relation, Snapshot snapshot,
-						   int nkeys, ScanKey key,
-						   bool allow_strat, bool allow_sync, bool allow_pagemode)
-{
-	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
-												allow_strat, allow_sync, allow_pagemode,
-												false, true, false);
-}
-
-/* ----------------
- *		heap_rescan		- restart a relation scan
- * ----------------
- */
-void
-table_rescan(TableScanDesc scan,
-			   ScanKey key)
-{
-	scan->rs_rd->rd_tableamroutine->scan_rescan(scan, key, false, false, false, false);
-}
-
-/* ----------------
- *		heap_rescan_set_params	- restart a relation scan after changing params
- *
- * This call allows changing the buffer strategy, syncscan, and pagemode
- * options before starting a fresh scan.  Note that although the actual use
- * of syncscan might change (effectively, enabling or disabling reporting),
- * the previously selected startblock will be kept.
- * ----------------
- */
-void
-table_rescan_set_params(TableScanDesc scan, ScanKey key,
-						  bool allow_strat, bool allow_sync, bool allow_pagemode)
-{
-	scan->rs_rd->rd_tableamroutine->scan_rescan(scan, key, true,
-											 allow_strat, allow_sync, (allow_pagemode && IsMVCCSnapshot(scan->rs_snapshot)));
-}
-
-/* ----------------
- *		heap_endscan	- end relation scan
- *
- *		See how to integrate with index scans.
- *		Check handling if reldesc caching.
- * ----------------
- */
-void
-table_endscan(TableScanDesc scan)
-{
-	scan->rs_rd->rd_tableamroutine->scan_end(scan);
-}
-
-
-/* ----------------
- *		heap_update_snapshot
- *
- *		Update snapshot info in heap scan descriptor.
- * ----------------
- */
-void
-table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
-{
-	scan->rs_rd->rd_tableamroutine->scan_update_snapshot(scan, snapshot);
-}
-
-TupleTableSlot *
-table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
-{
-	return sscan->rs_rd->rd_tableamroutine->scan_getnextslot(sscan, direction, slot);
-}
-
-bool
-table_tuple_fetch_from_offset(TableScanDesc sscan, BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot)
-{
-	return sscan->rs_rd->rd_tableamroutine->scan_fetch_tuple_from_offset(sscan, blkno, offset, slot);
-}
-
-
-IndexFetchTableData*
-table_begin_index_fetch_table(Relation rel)
-{
-	return rel->rd_tableamroutine->begin_index_fetch(rel);
-}
-
-void
-table_reset_index_fetch_table(IndexFetchTableData* scan)
-{
-	scan->rel->rd_tableamroutine->reset_index_fetch(scan);
-}
-
-void
-table_end_index_fetch_table(IndexFetchTableData* scan)
-{
-	scan->rel->rd_tableamroutine->end_index_fetch(scan);
-}
-
-/*
- * Insert a tuple from a slot into table AM routine
- */
-Oid
-table_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
-			   int options, BulkInsertState bistate)
-{
-	return relation->rd_tableamroutine->tuple_insert(relation, slot, cid, options,
-													 bistate);
-}
-
-Oid
-table_insert_speculative(Relation relation, TupleTableSlot *slot, CommandId cid,
-						 int options, BulkInsertState bistate, uint32 specToken)
-{
-	return relation->rd_tableamroutine->tuple_insert_speculative(relation, slot, cid, options,
-																 bistate, specToken);
-}
-
-void table_complete_speculative(Relation relation, TupleTableSlot *slot, uint32 specToken,
-								bool succeeded)
-{
-	return relation->rd_tableamroutine->tuple_complete_speculative(relation, slot, specToken, succeeded);
-}
-
-/*
- * Delete a tuple from tid using table AM routine
- */
-HTSU_Result
-table_delete(Relation relation, ItemPointer tid, CommandId cid,
-			 Snapshot crosscheck, bool wait,
-			 HeapUpdateFailureData *hufd, bool changingPart)
-{
-	return relation->rd_tableamroutine->tuple_delete(relation, tid, cid,
-												  crosscheck, wait, hufd, changingPart);
-}
-
-/*
- * update a tuple from tid using table AM routine
- */
-HTSU_Result
-table_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
-			 CommandId cid, Snapshot crosscheck, bool wait,
-			 HeapUpdateFailureData *hufd, LockTupleMode *lockmode,
-			 bool *update_indexes)
-{
-	return relation->rd_tableamroutine->tuple_update(relation, otid, slot,
-												  cid, crosscheck, wait, hufd,
-												  lockmode, update_indexes);
-}
-
-bool
-table_fetch_follow(struct IndexFetchTableData *scan,
-				   ItemPointer tid,
-				   Snapshot snapshot,
-				   TupleTableSlot *slot,
-				   bool *call_again, bool *all_dead)
-{
-
-	return scan->rel->rd_tableamroutine->tuple_fetch_follow(scan, tid, snapshot,
-														   slot, call_again,
-														   all_dead);
-}
-
-bool
-table_fetch_follow_check(Relation rel,
-						 ItemPointer tid,
-						 Snapshot snapshot,
-						 bool *all_dead)
-{
-	IndexFetchTableData *scan = table_begin_index_fetch_table(rel);
-	TupleTableSlot *slot = table_gimmegimmeslot(rel, NULL);
-	bool call_again = false;
-	bool found;
-
-	found = table_fetch_follow(scan, tid, snapshot, slot, &call_again, all_dead);
-
-	table_end_index_fetch_table(scan);
-	ExecDropSingleTupleTableSlot(slot);
-
-	return found;
-}
-
-/*
- *	table_multi_insert	- insert multiple tuple into a table
- */
-void
-table_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
-					 CommandId cid, int options, BulkInsertState bistate)
-{
-	relation->rd_tableamroutine->multi_insert(relation, tuples, ntuples,
-										   cid, options, bistate);
-}
-
-tuple_data
-table_tuple_get_data(Relation relation, TupleTableSlot *slot, tuple_data_flags flags)
-{
-	return relation->rd_tableamroutine->get_tuple_data(slot, flags);
-}
-
-void
-table_get_latest_tid(Relation relation,
-					   Snapshot snapshot,
-					   ItemPointer tid)
-{
-	relation->rd_tableamroutine->tuple_get_latest_tid(relation, snapshot, tid);
-}
-
-
-void
-table_vacuum_rel(Relation rel, int options,
-			 struct VacuumParams *params, BufferAccessStrategy bstrategy)
-{
-	rel->rd_tableamroutine->relation_vacuum(rel, options, params, bstrategy);
-}
-
-/*
- *	table_sync		- sync a heap, for use when no WAL has been written
- */
-void
-table_sync(Relation rel)
-{
-	rel->rd_tableamroutine->relation_sync(rel);
-}
-
-/*
- * -------------------
- * storage Bulk Insert functions
- * -------------------
- */
-BulkInsertState
-table_getbulkinsertstate(Relation rel)
-{
-	return rel->rd_tableamroutine->getbulkinsertstate();
-}
-
-void
-table_freebulkinsertstate(Relation rel, BulkInsertState bistate)
-{
-	rel->rd_tableamroutine->freebulkinsertstate(bistate);
-}
-
-void
-table_releasebulkinsertstate(Relation rel, BulkInsertState bistate)
-{
-	rel->rd_tableamroutine->releasebulkinsertstate(bistate);
-}
-
-/*
- * -------------------
- * storage tuple rewrite functions
- * -------------------
- */
-RewriteState
-table_begin_rewrite(Relation OldHeap, Relation NewHeap,
-				   TransactionId OldestXmin, TransactionId FreezeXid,
-				   MultiXactId MultiXactCutoff, bool use_wal)
-{
-	return NewHeap->rd_tableamroutine->begin_heap_rewrite(OldHeap, NewHeap,
-			OldestXmin, FreezeXid, MultiXactCutoff, use_wal);
-}
-
-void
-table_end_rewrite(Relation rel, RewriteState state)
-{
-	rel->rd_tableamroutine->end_heap_rewrite(state);
-}
-
-void
-table_rewrite_tuple(Relation rel, RewriteState state, HeapTuple oldTuple,
-				   HeapTuple newTuple)
-{
-	rel->rd_tableamroutine->rewrite_heap_tuple(state, oldTuple, newTuple);
-}
-
-bool
-table_rewrite_dead_tuple(Relation rel, RewriteState state, HeapTuple oldTuple)
-{
-	return rel->rd_tableamroutine->rewrite_heap_dead_tuple(state, oldTuple);
-}
diff --git a/src/backend/access/table/tableamapi.c b/src/backend/access/table/tableamapi.c
index f94660e306..91e5774a6e 100644
--- a/src/backend/access/table/tableamapi.c
+++ b/src/backend/access/table/tableamapi.c
@@ -13,7 +13,7 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_proc.h"
 #include "utils/syscache.h"
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 14ed2aa393..34f815c28f 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -21,7 +21,7 @@
 #include "access/multixact.h"
 #include "access/relscan.h"
 #include "access/rewriteheap.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/tuptoaster.h"
 #include "access/xact.h"
diff --git a/src/backend/executor/execIndexing.c b/src/backend/executor/execIndexing.c
index 542210b29f..80b604821b 100644
--- a/src/backend/executor/execIndexing.c
+++ b/src/backend/executor/execIndexing.c
@@ -107,6 +107,7 @@
 #include "postgres.h"
 
 #include "access/relscan.h"
+#include "access/tableam.h"
 #include "access/xact.h"
 #include "catalog/index.h"
 #include "executor/executor.h"
diff --git a/src/backend/executor/nodeSamplescan.c b/src/backend/executor/nodeSamplescan.c
index 566dabaa00..b5d02983c5 100644
--- a/src/backend/executor/nodeSamplescan.c
+++ b/src/backend/executor/nodeSamplescan.c
@@ -16,6 +16,7 @@
 
 #include "access/hash.h"
 #include "access/relscan.h"
+#include "access/tableam.h"
 #include "access/tsmapi.h"
 #include "executor/executor.h"
 #include "executor/nodeSamplescan.h"
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index f3cd64cf62..8fe8312f29 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -21,7 +21,7 @@
 #include "access/heapam.h"
 #include "access/htup_details.h"
 #include "access/nbtree.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "access/sysattr.h"
 #include "access/transam.h"
 #include "access/xlog.h"
diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 4455b42875..7142a54ce9 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -69,6 +69,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/reloptions.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/dependency.h"
diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
index e8390311d0..2960e21340 100644
--- a/src/backend/storage/lmgr/predicate.c
+++ b/src/backend/storage/lmgr/predicate.c
@@ -188,6 +188,7 @@
 #include "access/htup_details.h"
 #include "access/slru.h"
 #include "access/subtrans.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/twophase.h"
 #include "access/twophase_rmgr.h"
diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index a661f4b047..254041cea7 100644
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -31,6 +31,7 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
+#include "access/tableam.h"
 #include "access/sysattr.h"
 #include "access/xact.h"
 #include "catalog/pg_collation.h"
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 203b83ad06..7fcf077426 100644
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -103,6 +103,7 @@
 #include "access/brin.h"
 #include "access/gin.h"
 #include "access/htup_details.h"
+#include "access/tableam.h"
 #include "access/sysattr.h"
 #include "catalog/index.h"
 #include "catalog/pg_am.h"
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 6360371493..ece332bd44 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -36,7 +36,7 @@
 #include "access/nbtree.h"
 #include "access/reloptions.h"
 #include "access/sysattr.h"
-#include "access/tableamapi.h"
+#include "access/tableam.h"
 #include "access/tupdesc_details.h"
 #include "access/xact.h"
 #include "access/xlog.h"
diff --git a/src/include/access/relscan.h b/src/include/access/relscan.h
index e9d8eed541..97208d4c44 100644
--- a/src/include/access/relscan.h
+++ b/src/include/access/relscan.h
@@ -16,7 +16,6 @@
 
 #include "access/genam.h"
 #include "access/heapam.h"
-#include "access/tableam.h"
 #include "access/htup_details.h"
 #include "access/itup.h"
 #include "access/tupdesc.h"
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index fd05018ee8..bf675ff881 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -14,10 +14,18 @@
 #ifndef TABLEAM_H
 #define TABLEAM_H
 
+#include "postgres.h"
+
 #include "access/heapam.h"
+#include "access/relscan.h"
 #include "executor/tuptable.h"
 #include "nodes/execnodes.h"
+#include "nodes/nodes.h"
+#include "fmgr.h"
 #include "utils/rel.h"
+#include "utils/snapmgr.h"
+#include "utils/snapshot.h"
+#include "utils/tqual.h"
 
 #define DEFAULT_TABLE_ACCESS_METHOD	"heap_tableam"
 
@@ -37,103 +45,661 @@ typedef enum tuple_data_flags
 	CTID
 }			tuple_data_flags;
 
-extern TupleTableSlot* table_gimmegimmeslot(Relation relation, List **reglist);
-extern TableScanDesc table_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan);
-extern ParallelHeapScanDesc tableam_get_parallelheapscandesc(TableScanDesc sscan);
-extern HeapPageScanDesc tableam_get_heappagescandesc(TableScanDesc sscan);
-extern void table_syncscan_report_location(Relation rel, BlockNumber location);
-extern void table_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks);
-extern TableScanDesc table_beginscan(Relation relation, Snapshot snapshot,
-				  int nkeys, ScanKey key);
-extern TableScanDesc table_beginscan_catalog(Relation relation, int nkeys, ScanKey key);
-extern TableScanDesc table_beginscan_strat(Relation relation, Snapshot snapshot,
-						int nkeys, ScanKey key,
-						bool allow_strat, bool allow_sync);
-extern TableScanDesc table_beginscan_bm(Relation relation, Snapshot snapshot,
-					 int nkeys, ScanKey key);
-extern TableScanDesc table_beginscan_sampling(Relation relation, Snapshot snapshot,
-						   int nkeys, ScanKey key,
-						   bool allow_strat, bool allow_sync, bool allow_pagemode);
 
-extern struct IndexFetchTableData* table_begin_index_fetch_table(Relation rel);
-extern void table_reset_index_fetch_table(struct IndexFetchTableData* scan);
-extern void table_end_index_fetch_table(struct IndexFetchTableData* scan);
+/*
+ * Storage routine function hooks
+ */
+typedef bool (*SnapshotSatisfies_function) (TupleTableSlot *slot, Snapshot snapshot);
+typedef HTSU_Result (*SnapshotSatisfiesUpdate_function) (TupleTableSlot *slot, CommandId curcid);
+typedef HTSV_Result (*SnapshotSatisfiesVacuum_function) (TupleTableSlot *slot, TransactionId OldestXmin);
 
-extern void table_endscan(TableScanDesc scan);
-extern void table_rescan(TableScanDesc scan, ScanKey key);
-extern void table_rescan_set_params(TableScanDesc scan, ScanKey key,
-						  bool allow_strat, bool allow_sync, bool allow_pagemode);
-extern void table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot);
+typedef Oid (*TupleInsert_function) (Relation rel, TupleTableSlot *slot, CommandId cid,
+									 int options, BulkInsertState bistate);
 
-extern TupleTableSlot *table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot);
-extern bool table_tuple_fetch_from_offset(TableScanDesc sscan, BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot);
+typedef Oid (*TupleInsertSpeculative_function) (Relation rel,
+												 TupleTableSlot *slot,
+												 CommandId cid,
+												 int options,
+												 BulkInsertState bistate,
+												 uint32 specToken);
 
-extern void storage_get_latest_tid(Relation relation,
-					   Snapshot snapshot,
-					   ItemPointer tid);
-
-extern bool table_fetch_row_version(Relation relation,
-			  ItemPointer tid,
-			  Snapshot snapshot,
-			  TupleTableSlot *slot,
-			  Relation stats_relation);
-
-extern bool table_fetch_follow(struct IndexFetchTableData *scan,
-							   ItemPointer tid,
-							   Snapshot snapshot,
-							   TupleTableSlot *slot,
-							   bool *call_again, bool *all_dead);
-
-extern bool table_fetch_follow_check(Relation rel,
-									 ItemPointer tid,
-									 Snapshot snapshot,
-									 bool *all_dead);
-
-extern HTSU_Result table_lock_tuple(Relation relation, ItemPointer tid, Snapshot snapshot,
-				   TupleTableSlot *slot, CommandId cid, LockTupleMode mode,
-				   LockWaitPolicy wait_policy, uint8 flags,
-				   HeapUpdateFailureData *hufd);
-
-extern Oid table_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
-			   int options, BulkInsertState bistate);
-extern Oid table_insert_speculative(Relation relation, TupleTableSlot *slot, CommandId cid,
-									int options, BulkInsertState bistate, uint32 specToken);
-extern void table_complete_speculative(Relation relation, TupleTableSlot *slot, uint32 specToken,
-									   bool succeeded);
-
-extern HTSU_Result table_delete(Relation relation, ItemPointer tid, CommandId cid,
-			   Snapshot crosscheck, bool wait, HeapUpdateFailureData *hufd,
-			   bool changingPart);
-
-extern HTSU_Result table_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
-			   CommandId cid, Snapshot crosscheck, bool wait,
-			   HeapUpdateFailureData *hufd, LockTupleMode *lockmode,
-			   bool *upddate_indexes);
-
-extern void table_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
-					 CommandId cid, int options, BulkInsertState bistate);
-
-extern tuple_data table_tuple_get_data(Relation relation, TupleTableSlot *slot, tuple_data_flags flags);
-
-extern void table_get_latest_tid(Relation relation,
-					   Snapshot snapshot,
-					   ItemPointer tid);
 
-extern void table_sync(Relation rel);
+typedef void (*TupleCompleteSpeculative_function) (Relation rel,
+												  TupleTableSlot *slot,
+												  uint32 specToken,
+												  bool succeeded);
+
+typedef HTSU_Result (*TupleDelete_function) (Relation relation,
+											 ItemPointer tid,
+											 CommandId cid,
+											 Snapshot crosscheck,
+											 bool wait,
+											 HeapUpdateFailureData *hufd,
+											 bool changingPart);
+
+typedef HTSU_Result (*TupleUpdate_function) (Relation relation,
+											 ItemPointer otid,
+											 TupleTableSlot *slot,
+											 CommandId cid,
+											 Snapshot crosscheck,
+											 bool wait,
+											 HeapUpdateFailureData *hufd,
+											 LockTupleMode *lockmode,
+											 bool *update_indexes);
+
+typedef bool (*TupleFetchRowVersion_function) (Relation relation,
+											   ItemPointer tid,
+											   Snapshot snapshot,
+											   TupleTableSlot *slot,
+											   Relation stats_relation);
+
+typedef HTSU_Result (*TupleLock_function) (Relation relation,
+										   ItemPointer tid,
+										   Snapshot snapshot,
+										   TupleTableSlot *slot,
+										   CommandId cid,
+										   LockTupleMode mode,
+										   LockWaitPolicy wait_policy,
+										   uint8 flags,
+										   HeapUpdateFailureData *hufd);
+
+typedef void (*MultiInsert_function) (Relation relation, HeapTuple *tuples, int ntuples,
+									  CommandId cid, int options, BulkInsertState bistate);
+
+typedef void (*TupleGetLatestTid_function) (Relation relation,
+											Snapshot snapshot,
+											ItemPointer tid);
+
+typedef tuple_data(*GetTupleData_function) (TupleTableSlot *slot, tuple_data_flags flags);
+
 struct VacuumParams;
-extern void table_vacuum_rel(Relation onerel, int options,
+typedef void (*RelationVacuum_function)(Relation onerel, int options,
 				struct VacuumParams *params, BufferAccessStrategy bstrategy);
 
-extern BulkInsertState table_getbulkinsertstate(Relation rel);
-extern void table_freebulkinsertstate(Relation rel, BulkInsertState bistate);
-extern void table_releasebulkinsertstate(Relation rel, BulkInsertState bistate);
+typedef void (*RelationSync_function) (Relation relation);
 
-extern RewriteState table_begin_rewrite(Relation OldHeap, Relation NewHeap,
+typedef BulkInsertState (*GetBulkInsertState_function) (void);
+typedef void (*FreeBulkInsertState_function) (BulkInsertState bistate);
+typedef void (*ReleaseBulkInsertState_function) (BulkInsertState bistate);
+
+typedef RewriteState (*BeginHeapRewrite_function) (Relation OldHeap, Relation NewHeap,
 				   TransactionId OldestXmin, TransactionId FreezeXid,
 				   MultiXactId MultiXactCutoff, bool use_wal);
-extern void table_end_rewrite(Relation rel, RewriteState state);
-extern void table_rewrite_tuple(Relation rel, RewriteState state, HeapTuple oldTuple,
+typedef void (*EndHeapRewrite_function) (RewriteState state);
+typedef void (*RewriteHeapTuple_function) (RewriteState state, HeapTuple oldTuple,
 				   HeapTuple newTuple);
-extern bool table_rewrite_dead_tuple(Relation rel, RewriteState state, HeapTuple oldTuple);
+typedef bool (*RewriteHeapDeadTuple_function) (RewriteState state, HeapTuple oldTuple);
+
+typedef TupleTableSlot* (*Slot_function) (Relation relation);
+
+typedef TableScanDesc (*ScanBegin_function) (Relation relation,
+											Snapshot snapshot,
+											int nkeys, ScanKey key,
+											ParallelHeapScanDesc parallel_scan,
+											bool allow_strat,
+											bool allow_sync,
+											bool allow_pagemode,
+											bool is_bitmapscan,
+											bool is_samplescan,
+											bool temp_snap);
+
+typedef struct IndexFetchTableData* (*BeginIndexFetchTable_function) (Relation relation);
+typedef void (*ResetIndexFetchTable_function) (struct IndexFetchTableData* data);
+typedef void (*EndIndexFetchTable_function) (struct IndexFetchTableData* data);
+
+typedef ParallelHeapScanDesc (*ScanGetParallelheapscandesc_function) (TableScanDesc scan);
+typedef HeapPageScanDesc(*ScanGetHeappagescandesc_function) (TableScanDesc scan);
+typedef void (*SyncScanReportLocation_function) (Relation rel, BlockNumber location);
+typedef void (*ScanSetlimits_function) (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks);
+
+typedef TupleTableSlot *(*ScanGetnextSlot_function) (TableScanDesc scan,
+													 ScanDirection direction, TupleTableSlot *slot);
+
+typedef bool (*ScanFetchTupleFromOffset_function) (TableScanDesc scan,
+												   BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot);
+
+typedef void (*ScanEnd_function) (TableScanDesc scan);
+
+
+typedef void (*ScanGetpage_function) (TableScanDesc scan, BlockNumber page);
+typedef void (*ScanRescan_function) (TableScanDesc scan, ScanKey key, bool set_params,
+									 bool allow_strat, bool allow_sync, bool allow_pagemode);
+typedef void (*ScanUpdateSnapshot_function) (TableScanDesc scan, Snapshot snapshot);
+
+typedef bool (*TupleFetchFollow_function)(struct IndexFetchTableData *scan,
+										  ItemPointer tid,
+										  Snapshot snapshot,
+										  TupleTableSlot *slot,
+										  bool *call_again, bool *all_dead);
+
+/*
+ * API struct for a table AM.  Note this must be stored in a single palloc'd
+ * chunk of memory.
+ */
+typedef struct TableAmRoutine
+{
+	NodeTag		type;
+
+	Slot_function gimmegimmeslot;
+
+	SnapshotSatisfies_function snapshot_satisfies;
+	SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
+	SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
+
+	/* Operations on physical tuples */
+	TupleInsert_function tuple_insert;
+	TupleInsertSpeculative_function tuple_insert_speculative;
+	TupleCompleteSpeculative_function tuple_complete_speculative;
+	TupleUpdate_function tuple_update;
+	TupleDelete_function tuple_delete;
+	TupleFetchRowVersion_function tuple_fetch_row_version;
+	TupleLock_function tuple_lock;
+	MultiInsert_function multi_insert;
+	TupleGetLatestTid_function tuple_get_latest_tid;
+	TupleFetchFollow_function tuple_fetch_follow;
+
+	GetTupleData_function get_tuple_data;
+
+	RelationVacuum_function relation_vacuum;
+	RelationSync_function relation_sync;
+
+	GetBulkInsertState_function getbulkinsertstate;
+	FreeBulkInsertState_function freebulkinsertstate;
+	ReleaseBulkInsertState_function releasebulkinsertstate;
+
+	BeginHeapRewrite_function begin_heap_rewrite;
+	EndHeapRewrite_function end_heap_rewrite;
+	RewriteHeapTuple_function rewrite_heap_tuple;
+	RewriteHeapDeadTuple_function rewrite_heap_dead_tuple;
+
+	/* Operations on relation scans */
+	ScanBegin_function scan_begin;
+	ScanGetParallelheapscandesc_function scan_get_parallelheapscandesc;
+	ScanGetHeappagescandesc_function scan_get_heappagescandesc;
+	SyncScanReportLocation_function sync_scan_report_location;
+	ScanSetlimits_function scansetlimits;
+	ScanGetnextSlot_function scan_getnextslot;
+	ScanFetchTupleFromOffset_function scan_fetch_tuple_from_offset;
+	ScanEnd_function scan_end;
+	ScanGetpage_function scan_getpage;
+	ScanRescan_function scan_rescan;
+	ScanUpdateSnapshot_function scan_update_snapshot;
+
+	BeginIndexFetchTable_function begin_index_fetch;
+	EndIndexFetchTable_function reset_index_fetch;
+	EndIndexFetchTable_function end_index_fetch;
+
+}			TableAmRoutine;
+
+/*
+ * INLINE functions
+ */
+static inline TupleTableSlot*
+table_gimmegimmeslot(Relation relation, List **reglist)
+{
+	TupleTableSlot *slot;
+
+	slot = relation->rd_tableamroutine->gimmegimmeslot(relation);
+
+	if (reglist)
+		*reglist = lappend(*reglist, slot);
+
+	return slot;
+}
+
+/*
+ *	table_fetch_row_version		- retrieve tuple with given tid
+ *
+ *  XXX: This shouldn't just take a tid, but tid + additional information
+ */
+static inline bool
+table_fetch_row_version(Relation r,
+						ItemPointer tid,
+						Snapshot snapshot,
+						TupleTableSlot *slot,
+						Relation stats_relation)
+{
+	return r->rd_tableamroutine->tuple_fetch_row_version(r, tid,
+														 snapshot, slot,
+														 stats_relation);
+}
+
+
+/*
+ *	table_lock_tuple - lock a tuple in shared or exclusive mode
+ *
+ *  XXX: This shouldn't just take a tid, but tid + additional information
+ */
+static inline HTSU_Result
+table_lock_tuple(Relation relation, ItemPointer tid, Snapshot snapshot,
+				 TupleTableSlot *slot, CommandId cid, LockTupleMode mode,
+				 LockWaitPolicy wait_policy, uint8 flags,
+				 HeapUpdateFailureData *hufd)
+{
+	return relation->rd_tableamroutine->tuple_lock(relation, tid, snapshot, slot,
+												cid, mode, wait_policy,
+												flags, hufd);
+}
+
+/* ----------------
+ *		heap_beginscan_parallel - join a parallel scan
+ *
+ *		Caller must hold a suitable lock on the correct relation.
+ * ----------------
+ */
+static inline TableScanDesc
+table_beginscan_parallel(Relation relation, ParallelHeapScanDesc parallel_scan)
+{
+	Snapshot	snapshot;
+
+	Assert(RelationGetRelid(relation) == parallel_scan->phs_relid);
+
+	if (!parallel_scan->phs_snapshot_any)
+	{
+		/* Snapshot was serialized -- restore it */
+		snapshot = RestoreSnapshot(parallel_scan->phs_snapshot_data);
+		RegisterSnapshot(snapshot);
+	}
+	else
+	{
+		/* SnapshotAny passed by caller (not serialized) */
+		snapshot = SnapshotAny;
+	}
+
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, 0, NULL, parallel_scan,
+												true, true, true, false, false, !parallel_scan->phs_snapshot_any);
+}
+
+static inline ParallelHeapScanDesc
+tableam_get_parallelheapscandesc(TableScanDesc sscan)
+{
+	return sscan->rs_rd->rd_tableamroutine->scan_get_parallelheapscandesc(sscan);
+}
+
+static inline HeapPageScanDesc
+tableam_get_heappagescandesc(TableScanDesc sscan)
+{
+	/*
+	 * Planner should have already validated whether the current storage
+	 * supports Page scans are not? This function will be called only from
+	 * Bitmap Heap scan and sample scan
+	 */
+	Assert(sscan->rs_rd->rd_tableamroutine->scan_get_heappagescandesc != NULL);
+
+	return sscan->rs_rd->rd_tableamroutine->scan_get_heappagescandesc(sscan);
+}
+
+static inline void
+table_syncscan_report_location(Relation rel, BlockNumber location)
+{
+	return rel->rd_tableamroutine->sync_scan_report_location(rel, location);
+}
+
+/*
+ * heap_setscanlimits - restrict range of a heapscan
+ *
+ * startBlk is the page to start at
+ * numBlks is number of pages to scan (InvalidBlockNumber means "all")
+ */
+static inline void
+table_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
+{
+	sscan->rs_rd->rd_tableamroutine->scansetlimits(sscan, startBlk, numBlks);
+}
+
+
+/* ----------------
+ *		heap_beginscan	- begin relation scan
+ *
+ * heap_beginscan is the "standard" case.
+ *
+ * heap_beginscan_catalog differs in setting up its own temporary snapshot.
+ *
+ * heap_beginscan_strat offers an extended API that lets the caller control
+ * whether a nondefault buffer access strategy can be used, and whether
+ * syncscan can be chosen (possibly resulting in the scan not starting from
+ * block zero).  Both of these default to true with plain heap_beginscan.
+ *
+ * heap_beginscan_bm is an alternative entry point for setting up a
+ * TableScanDesc for a bitmap heap scan.  Although that scan technology is
+ * really quite unlike a standard seqscan, there is just enough commonality
+ * to make it worth using the same data structure.
+ *
+ * heap_beginscan_sampling is an alternative entry point for setting up a
+ * TableScanDesc for a TABLESAMPLE scan.  As with bitmap scans, it's worth
+ * using the same data structure although the behavior is rather different.
+ * In addition to the options offered by heap_beginscan_strat, this call
+ * also allows control of whether page-mode visibility checking is used.
+ * ----------------
+ */
+static inline TableScanDesc
+table_beginscan(Relation relation, Snapshot snapshot,
+				  int nkeys, ScanKey key)
+{
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
+												true, true, true, false, false, false);
+}
+
+static inline TableScanDesc
+table_beginscan_catalog(Relation relation, int nkeys, ScanKey key)
+{
+	Oid			relid = RelationGetRelid(relation);
+	Snapshot	snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
+
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
+												true, true, true, false, false, true);
+}
+
+static inline TableScanDesc
+table_beginscan_strat(Relation relation, Snapshot snapshot,
+						int nkeys, ScanKey key,
+						bool allow_strat, bool allow_sync)
+{
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
+												allow_strat, allow_sync, true,
+												false, false, false);
+}
+
+static inline TableScanDesc
+table_beginscan_bm(Relation relation, Snapshot snapshot,
+					 int nkeys, ScanKey key)
+{
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
+												false, false, true, true, false, false);
+}
+
+static inline TableScanDesc
+table_beginscan_sampling(Relation relation, Snapshot snapshot,
+						   int nkeys, ScanKey key,
+						   bool allow_strat, bool allow_sync, bool allow_pagemode)
+{
+	return relation->rd_tableamroutine->scan_begin(relation, snapshot, nkeys, key, NULL,
+												allow_strat, allow_sync, allow_pagemode,
+												false, true, false);
+}
+
+/* ----------------
+ *		heap_rescan		- restart a relation scan
+ * ----------------
+ */
+static inline void
+table_rescan(TableScanDesc scan,
+			   ScanKey key)
+{
+	scan->rs_rd->rd_tableamroutine->scan_rescan(scan, key, false, false, false, false);
+}
+
+/* ----------------
+ *		heap_rescan_set_params	- restart a relation scan after changing params
+ *
+ * This call allows changing the buffer strategy, syncscan, and pagemode
+ * options before starting a fresh scan.  Note that although the actual use
+ * of syncscan might change (effectively, enabling or disabling reporting),
+ * the previously selected startblock will be kept.
+ * ----------------
+ */
+static inline void
+table_rescan_set_params(TableScanDesc scan, ScanKey key,
+						  bool allow_strat, bool allow_sync, bool allow_pagemode)
+{
+	scan->rs_rd->rd_tableamroutine->scan_rescan(scan, key, true,
+											 allow_strat, allow_sync, (allow_pagemode && IsMVCCSnapshot(scan->rs_snapshot)));
+}
+
+/* ----------------
+ *		heap_endscan	- end relation scan
+ *
+ *		See how to integrate with index scans.
+ *		Check handling if reldesc caching.
+ * ----------------
+ */
+static inline void
+table_endscan(TableScanDesc scan)
+{
+	scan->rs_rd->rd_tableamroutine->scan_end(scan);
+}
+
+
+/* ----------------
+ *		heap_update_snapshot
+ *
+ *		Update snapshot info in heap scan descriptor.
+ * ----------------
+ */
+static inline void
+table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
+{
+	scan->rs_rd->rd_tableamroutine->scan_update_snapshot(scan, snapshot);
+}
+
+static inline TupleTableSlot *
+table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
+{
+	return sscan->rs_rd->rd_tableamroutine->scan_getnextslot(sscan, direction, slot);
+}
+
+static inline bool
+table_tuple_fetch_from_offset(TableScanDesc sscan, BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot)
+{
+	return sscan->rs_rd->rd_tableamroutine->scan_fetch_tuple_from_offset(sscan, blkno, offset, slot);
+}
+
+
+static inline IndexFetchTableData*
+table_begin_index_fetch_table(Relation rel)
+{
+	return rel->rd_tableamroutine->begin_index_fetch(rel);
+}
+
+static inline void
+table_reset_index_fetch_table(struct IndexFetchTableData* scan)
+{
+	scan->rel->rd_tableamroutine->reset_index_fetch(scan);
+}
+
+static inline void
+table_end_index_fetch_table(struct IndexFetchTableData* scan)
+{
+	scan->rel->rd_tableamroutine->end_index_fetch(scan);
+}
+
+/*
+ * Insert a tuple from a slot into table AM routine
+ */
+static inline Oid
+table_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
+			   int options, BulkInsertState bistate)
+{
+	return relation->rd_tableamroutine->tuple_insert(relation, slot, cid, options,
+													 bistate);
+}
+
+static inline Oid
+table_insert_speculative(Relation relation, TupleTableSlot *slot, CommandId cid,
+						 int options, BulkInsertState bistate, uint32 specToken)
+{
+	return relation->rd_tableamroutine->tuple_insert_speculative(relation, slot, cid, options,
+																 bistate, specToken);
+}
+
+static inline void
+table_complete_speculative(Relation relation, TupleTableSlot *slot, uint32 specToken,
+								bool succeeded)
+{
+	return relation->rd_tableamroutine->tuple_complete_speculative(relation, slot, specToken, succeeded);
+}
+
+/*
+ * Delete a tuple from tid using table AM routine
+ */
+static inline HTSU_Result
+table_delete(Relation relation, ItemPointer tid, CommandId cid,
+			 Snapshot crosscheck, bool wait,
+			 HeapUpdateFailureData *hufd, bool changingPart)
+{
+	return relation->rd_tableamroutine->tuple_delete(relation, tid, cid,
+												  crosscheck, wait, hufd, changingPart);
+}
+
+/*
+ * update a tuple from tid using table AM routine
+ */
+static inline HTSU_Result
+table_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
+			 CommandId cid, Snapshot crosscheck, bool wait,
+			 HeapUpdateFailureData *hufd, LockTupleMode *lockmode,
+			 bool *update_indexes)
+{
+	return relation->rd_tableamroutine->tuple_update(relation, otid, slot,
+												  cid, crosscheck, wait, hufd,
+												  lockmode, update_indexes);
+}
+
+static inline bool
+table_fetch_follow(struct IndexFetchTableData *scan,
+				   ItemPointer tid,
+				   Snapshot snapshot,
+				   TupleTableSlot *slot,
+				   bool *call_again, bool *all_dead)
+{
+
+	return scan->rel->rd_tableamroutine->tuple_fetch_follow(scan, tid, snapshot,
+														   slot, call_again,
+														   all_dead);
+}
+
+static inline bool
+table_fetch_follow_check(Relation rel,
+						 ItemPointer tid,
+						 Snapshot snapshot,
+						 bool *all_dead)
+{
+	IndexFetchTableData *scan = table_begin_index_fetch_table(rel);
+	TupleTableSlot *slot = table_gimmegimmeslot(rel, NULL);
+	bool call_again = false;
+	bool found;
+
+	found = table_fetch_follow(scan, tid, snapshot, slot, &call_again, all_dead);
+
+	table_end_index_fetch_table(scan);
+	ExecDropSingleTupleTableSlot(slot);
+
+	return found;
+}
+
+/*
+ *	table_multi_insert	- insert multiple tuple into a table
+ */
+static inline void
+table_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
+					 CommandId cid, int options, BulkInsertState bistate)
+{
+	relation->rd_tableamroutine->multi_insert(relation, tuples, ntuples,
+										   cid, options, bistate);
+}
+
+static inline tuple_data
+table_tuple_get_data(Relation relation, TupleTableSlot *slot, tuple_data_flags flags)
+{
+	return relation->rd_tableamroutine->get_tuple_data(slot, flags);
+}
+
+static inline void
+table_get_latest_tid(Relation relation,
+					   Snapshot snapshot,
+					   ItemPointer tid)
+{
+	relation->rd_tableamroutine->tuple_get_latest_tid(relation, snapshot, tid);
+}
+
+
+static inline void
+table_vacuum_rel(Relation rel, int options,
+			 struct VacuumParams *params, BufferAccessStrategy bstrategy)
+{
+	rel->rd_tableamroutine->relation_vacuum(rel, options, params, bstrategy);
+}
+
+/*
+ *	table_sync		- sync a heap, for use when no WAL has been written
+ */
+static inline void
+table_sync(Relation rel)
+{
+	rel->rd_tableamroutine->relation_sync(rel);
+}
+
+/*
+ * -------------------
+ * storage Bulk Insert functions
+ * -------------------
+ */
+static inline BulkInsertState
+table_getbulkinsertstate(Relation rel)
+{
+	return rel->rd_tableamroutine->getbulkinsertstate();
+}
+
+static inline void
+table_freebulkinsertstate(Relation rel, BulkInsertState bistate)
+{
+	rel->rd_tableamroutine->freebulkinsertstate(bistate);
+}
+
+static inline void
+table_releasebulkinsertstate(Relation rel, BulkInsertState bistate)
+{
+	rel->rd_tableamroutine->releasebulkinsertstate(bistate);
+}
+
+/*
+ * -------------------
+ * storage tuple rewrite functions
+ * -------------------
+ */
+static inline RewriteState
+table_begin_rewrite(Relation OldHeap, Relation NewHeap,
+				   TransactionId OldestXmin, TransactionId FreezeXid,
+				   MultiXactId MultiXactCutoff, bool use_wal)
+{
+	return NewHeap->rd_tableamroutine->begin_heap_rewrite(OldHeap, NewHeap,
+			OldestXmin, FreezeXid, MultiXactCutoff, use_wal);
+}
+
+static inline void
+table_end_rewrite(Relation rel, RewriteState state)
+{
+	rel->rd_tableamroutine->end_heap_rewrite(state);
+}
+
+static inline void
+table_rewrite_tuple(Relation rel, RewriteState state, HeapTuple oldTuple,
+				   HeapTuple newTuple)
+{
+	rel->rd_tableamroutine->rewrite_heap_tuple(state, oldTuple, newTuple);
+}
+
+static inline bool
+table_rewrite_dead_tuple(Relation rel, RewriteState state, HeapTuple oldTuple)
+{
+	return rel->rd_tableamroutine->rewrite_heap_dead_tuple(state, oldTuple);
+}
+
+/*
+ * HeapTupleSatisfiesVisibility
+ *		True iff heap tuple satisfies a time qual.
+ *
+ * Notes:
+ *	Assumes heap tuple is valid.
+ *	Beware of multiple evaluations of snapshot argument.
+ *	Hint bits in the HeapTuple's t_infomask may be updated as a side effect;
+ *	if so, the indicated buffer is marked dirty.
+ */
+#define HeapTupleSatisfiesVisibility(method, slot, snapshot) \
+	(((method)->snapshot_satisfies) (slot, snapshot))
+
+extern TableAmRoutine * GetTableAmRoutine(Oid amhandler);
+extern TableAmRoutine * GetTableAmRoutineByAmId(Oid amoid);
+extern TableAmRoutine * GetHeapamTableAmRoutine(void);
 
 #endif		/* TABLEAM_H */
diff --git a/src/include/access/tableamapi.h b/src/include/access/tableamapi.h
deleted file mode 100644
index a4a6e7fd23..0000000000
--- a/src/include/access/tableamapi.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*---------------------------------------------------------------------
- *
- * tableamapi.h
- *		API for Postgres table access methods
- *
- * Copyright (c) 2017, PostgreSQL Global Development Group
- *
- * src/include/access/tableamapi.h
- *---------------------------------------------------------------------
- */
-#ifndef TABLEEAMAPI_H
-#define TABLEEAMAPI_H
-
-#include "access/heapam.h"
-#include "access/tableam.h"
-#include "nodes/execnodes.h"
-#include "nodes/nodes.h"
-#include "fmgr.h"
-#include "utils/snapshot.h"
-
-struct IndexFetchTableData;
-
-/*
- * Storage routine function hooks
- */
-typedef bool (*SnapshotSatisfies_function) (TupleTableSlot *slot, Snapshot snapshot);
-typedef HTSU_Result (*SnapshotSatisfiesUpdate_function) (TupleTableSlot *slot, CommandId curcid);
-typedef HTSV_Result (*SnapshotSatisfiesVacuum_function) (TupleTableSlot *slot, TransactionId OldestXmin);
-
-typedef Oid (*TupleInsert_function) (Relation rel, TupleTableSlot *slot, CommandId cid,
-									 int options, BulkInsertState bistate);
-
-typedef Oid (*TupleInsertSpeculative_function) (Relation rel,
-												 TupleTableSlot *slot,
-												 CommandId cid,
-												 int options,
-												 BulkInsertState bistate,
-												 uint32 specToken);
-
-
-typedef void (*TupleCompleteSpeculative_function) (Relation rel,
-												  TupleTableSlot *slot,
-												  uint32 specToken,
-												  bool succeeded);
-
-typedef HTSU_Result (*TupleDelete_function) (Relation relation,
-											 ItemPointer tid,
-											 CommandId cid,
-											 Snapshot crosscheck,
-											 bool wait,
-											 HeapUpdateFailureData *hufd,
-											 bool changingPart);
-
-typedef HTSU_Result (*TupleUpdate_function) (Relation relation,
-											 ItemPointer otid,
-											 TupleTableSlot *slot,
-											 CommandId cid,
-											 Snapshot crosscheck,
-											 bool wait,
-											 HeapUpdateFailureData *hufd,
-											 LockTupleMode *lockmode,
-											 bool *update_indexes);
-
-typedef bool (*TupleFetchRowVersion_function) (Relation relation,
-											   ItemPointer tid,
-											   Snapshot snapshot,
-											   TupleTableSlot *slot,
-											   Relation stats_relation);
-
-typedef HTSU_Result (*TupleLock_function) (Relation relation,
-										   ItemPointer tid,
-										   Snapshot snapshot,
-										   TupleTableSlot *slot,
-										   CommandId cid,
-										   LockTupleMode mode,
-										   LockWaitPolicy wait_policy,
-										   uint8 flags,
-										   HeapUpdateFailureData *hufd);
-
-typedef void (*MultiInsert_function) (Relation relation, HeapTuple *tuples, int ntuples,
-									  CommandId cid, int options, BulkInsertState bistate);
-
-typedef void (*TupleGetLatestTid_function) (Relation relation,
-											Snapshot snapshot,
-											ItemPointer tid);
-
-typedef tuple_data(*GetTupleData_function) (TupleTableSlot *slot, tuple_data_flags flags);
-
-struct VacuumParams;
-typedef void (*RelationVacuum_function)(Relation onerel, int options,
-				struct VacuumParams *params, BufferAccessStrategy bstrategy);
-
-typedef void (*RelationSync_function) (Relation relation);
-
-typedef BulkInsertState (*GetBulkInsertState_function) (void);
-typedef void (*FreeBulkInsertState_function) (BulkInsertState bistate);
-typedef void (*ReleaseBulkInsertState_function) (BulkInsertState bistate);
-
-typedef RewriteState (*BeginHeapRewrite_function) (Relation OldHeap, Relation NewHeap,
-				   TransactionId OldestXmin, TransactionId FreezeXid,
-				   MultiXactId MultiXactCutoff, bool use_wal);
-typedef void (*EndHeapRewrite_function) (RewriteState state);
-typedef void (*RewriteHeapTuple_function) (RewriteState state, HeapTuple oldTuple,
-				   HeapTuple newTuple);
-typedef bool (*RewriteHeapDeadTuple_function) (RewriteState state, HeapTuple oldTuple);
-
-typedef TupleTableSlot* (*Slot_function) (Relation relation);
-
-typedef TableScanDesc (*ScanBegin_function) (Relation relation,
-											Snapshot snapshot,
-											int nkeys, ScanKey key,
-											ParallelHeapScanDesc parallel_scan,
-											bool allow_strat,
-											bool allow_sync,
-											bool allow_pagemode,
-											bool is_bitmapscan,
-											bool is_samplescan,
-											bool temp_snap);
-
-typedef struct IndexFetchTableData* (*BeginIndexFetchTable_function) (Relation relation);
-typedef void (*ResetIndexFetchTable_function) (struct IndexFetchTableData* data);
-typedef void (*EndIndexFetchTable_function) (struct IndexFetchTableData* data);
-
-typedef ParallelHeapScanDesc (*ScanGetParallelheapscandesc_function) (TableScanDesc scan);
-typedef HeapPageScanDesc(*ScanGetHeappagescandesc_function) (TableScanDesc scan);
-typedef void (*SyncScanReportLocation_function) (Relation rel, BlockNumber location);
-typedef void (*ScanSetlimits_function) (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks);
-
-typedef TupleTableSlot *(*ScanGetnextSlot_function) (TableScanDesc scan,
-													 ScanDirection direction, TupleTableSlot *slot);
-
-typedef bool (*ScanFetchTupleFromOffset_function) (TableScanDesc scan,
-												   BlockNumber blkno, OffsetNumber offset, TupleTableSlot *slot);
-
-typedef void (*ScanEnd_function) (TableScanDesc scan);
-
-
-typedef void (*ScanGetpage_function) (TableScanDesc scan, BlockNumber page);
-typedef void (*ScanRescan_function) (TableScanDesc scan, ScanKey key, bool set_params,
-									 bool allow_strat, bool allow_sync, bool allow_pagemode);
-typedef void (*ScanUpdateSnapshot_function) (TableScanDesc scan, Snapshot snapshot);
-
-typedef bool (*TupleFetchFollow_function)(struct IndexFetchTableData *scan,
-										  ItemPointer tid,
-										  Snapshot snapshot,
-										  TupleTableSlot *slot,
-										  bool *call_again, bool *all_dead);
-
-/*
- * API struct for a table AM.  Note this must be stored in a single palloc'd
- * chunk of memory.
- */
-typedef struct TableAmRoutine
-{
-	NodeTag		type;
-
-	Slot_function gimmegimmeslot;
-
-	SnapshotSatisfies_function snapshot_satisfies;
-	SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
-	SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
-
-	/* Operations on physical tuples */
-	TupleInsert_function tuple_insert;
-	TupleInsertSpeculative_function tuple_insert_speculative;
-	TupleCompleteSpeculative_function tuple_complete_speculative;
-	TupleUpdate_function tuple_update;
-	TupleDelete_function tuple_delete;
-	TupleFetchRowVersion_function tuple_fetch_row_version;
-	TupleLock_function tuple_lock;
-	MultiInsert_function multi_insert;
-	TupleGetLatestTid_function tuple_get_latest_tid;
-	TupleFetchFollow_function tuple_fetch_follow;
-
-	GetTupleData_function get_tuple_data;
-
-	RelationVacuum_function relation_vacuum;
-	RelationSync_function relation_sync;
-
-	GetBulkInsertState_function getbulkinsertstate;
-	FreeBulkInsertState_function freebulkinsertstate;
-	ReleaseBulkInsertState_function releasebulkinsertstate;
-
-	BeginHeapRewrite_function begin_heap_rewrite;
-	EndHeapRewrite_function end_heap_rewrite;
-	RewriteHeapTuple_function rewrite_heap_tuple;
-	RewriteHeapDeadTuple_function rewrite_heap_dead_tuple;
-
-	/* Operations on relation scans */
-	ScanBegin_function scan_begin;
-	ScanGetParallelheapscandesc_function scan_get_parallelheapscandesc;
-	ScanGetHeappagescandesc_function scan_get_heappagescandesc;
-	SyncScanReportLocation_function sync_scan_report_location;
-	ScanSetlimits_function scansetlimits;
-	ScanGetnextSlot_function scan_getnextslot;
-	ScanFetchTupleFromOffset_function scan_fetch_tuple_from_offset;
-	ScanEnd_function scan_end;
-	ScanGetpage_function scan_getpage;
-	ScanRescan_function scan_rescan;
-	ScanUpdateSnapshot_function scan_update_snapshot;
-
-	BeginIndexFetchTable_function begin_index_fetch;
-	EndIndexFetchTable_function reset_index_fetch;
-	EndIndexFetchTable_function end_index_fetch;
-
-}			TableAmRoutine;
-
-extern TableAmRoutine * GetTableAmRoutine(Oid amhandler);
-extern TableAmRoutine * GetTableAmRoutineByAmId(Oid amoid);
-extern TableAmRoutine * GetHeapamTableAmRoutine(void);
-
-#endif							/* TABLEEAMAPI_H */
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 945bbc3ddf..c69ca99435 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -502,7 +502,7 @@ typedef enum NodeTag
 	T_InlineCodeBlock,			/* in nodes/parsenodes.h */
 	T_FdwRoutine,				/* in foreign/fdwapi.h */
 	T_IndexAmRoutine,			/* in access/amapi.h */
-	T_TableAmRoutine,			/* in access/tableamapi.h */
+	T_TableAmRoutine,			/* in access/tableam.h */
 	T_TsmRoutine,				/* in access/tsmapi.h */
 	T_ForeignKeyCacheInfo,		/* in utils/rel.h */
 	T_CallContext				/* in nodes/parsenodes.h */
diff --git a/src/include/utils/tqual.h b/src/include/utils/tqual.h
index 9739bed9e0..1fe9cc6402 100644
--- a/src/include/utils/tqual.h
+++ b/src/include/utils/tqual.h
@@ -16,10 +16,8 @@
 #define TQUAL_H
 
 #include "utils/snapshot.h"
-#include "access/tableamapi.h"
 #include "access/xlogdefs.h"
 
-
 /* Static variables representing various special snapshot semantics */
 extern PGDLLIMPORT SnapshotData SnapshotSelfData;
 extern PGDLLIMPORT SnapshotData SnapshotAnyData;
@@ -33,19 +31,6 @@ extern PGDLLIMPORT SnapshotData CatalogSnapshotData;
 	((snapshot)->visibility_type == MVCC_VISIBILITY || \
 	 (snapshot)->visibility_type == HISTORIC_MVCC_VISIBILITY)
 
-/*
- * HeapTupleSatisfiesVisibility
- *		True iff heap tuple satisfies a time qual.
- *
- * Notes:
- *	Assumes heap tuple is valid.
- *	Beware of multiple evaluations of snapshot argument.
- *	Hint bits in the HeapTuple's t_infomask may be updated as a side effect;
- *	if so, the indicated buffer is marked dirty.
- */
-#define HeapTupleSatisfiesVisibility(method, slot, snapshot) \
-	(((method)->snapshot_satisfies) (slot, snapshot))
-
 /*
  * To avoid leaking too much knowledge about reorderbuffer implementation
  * details this is implemented in reorderbuffer.c not tqual.c.
-- 
2.18.0.windows.1

From 3e4d02fd2ade9b9b116b013899b4b81b435379a8 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Fri, 3 Aug 2018 11:29:05 +1000
Subject: [PATCH 2/2] Isolation test fixes -1

---
 src/backend/access/heap/heapam_handler.c | 9 ++++++---
 src/backend/executor/execMain.c          | 5 +++--
 src/backend/executor/nodeModifyTable.c   | 6 +++++-
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index a3fe110efe..cce2123416 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -317,7 +317,8 @@ retry:
 				if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
 										 priorXmax))
 				{
-					ReleaseBuffer(buffer);
+					if (BufferIsValid(buffer))
+							ReleaseBuffer(buffer);
 					return HeapTupleDeleted;
 				}
 
@@ -336,7 +337,8 @@ retry:
 				if (ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
 				{
 					/* deleted, so forget about it */
-					ReleaseBuffer(buffer);
+					if (BufferIsValid(buffer))
+							ReleaseBuffer(buffer);
 					return HeapTupleDeleted;
 				}
 
@@ -344,7 +346,8 @@ retry:
 				*tid = tuple->t_data->t_ctid;
 				/* updated row should have xmin matching this xmax */
 				priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
-				ReleaseBuffer(buffer);
+				if (BufferIsValid(buffer))
+						ReleaseBuffer(buffer);
 				/* loop back to fetch next in chain */
 			}
 		}
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index ea60e588a5..fd3e53d1ee 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2552,8 +2552,9 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
 	 * datums that may be present in copyTuple).  As with the next step, this
 	 * is to guard against early re-use of the EPQ query.
 	 */
-	if (!TupIsNull(slot))
-		ExecMaterializeSlot(slot);
+	/*if (!TupIsNull(slot))
+	 *	ExecMaterializeSlot(slot);
+	 */
 
 #if FIXME
 	/*
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 5ae0bab9f5..71150ad32e 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1177,7 +1177,11 @@ lreplace:;
 
 		if (result == HeapTupleUpdated && !IsolationUsesXactSnapshot())
 		{
-			TupleTableSlot *inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
+			TupleTableSlot *inputslot;
+
+			EvalPlanQualBegin(epqstate, estate);
+
+			inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
 
 			result = table_lock_tuple(resultRelationDesc, tupleid,
 									  estate->es_snapshot,
-- 
2.18.0.windows.1

From 2bcbe0ffc5df81b38e6c6f0093eb486669c7a3b2 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Fri, 3 Aug 2018 11:07:52 +1000
Subject: [PATCH 1/2] COPY's multi_insert path deal with bunch of slots

Support of passing slots instead of tuples when doing
multi insert.
---
 src/backend/access/heap/heapam.c |  31 ++++++----
 src/backend/commands/copy.c      | 100 +++++++++++++++----------------
 src/include/access/heapam.h      |   3 +-
 src/include/access/tableam.h     |   6 +-
 4 files changed, 74 insertions(+), 66 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 40c1a5432d..7d0d1dc234 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -2648,7 +2648,7 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
  * temporary context before calling this, if that's a problem.
  */
 void
-heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
+heap_multi_insert(Relation relation, TupleTableSlot **slots, int nslots,
 				  CommandId cid, int options, BulkInsertState bistate)
 {
 	TransactionId xid = GetCurrentTransactionId();
@@ -2666,11 +2666,18 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 	saveFreeSpace = RelationGetTargetPageFreeSpace(relation,
 												   HEAP_DEFAULT_FILLFACTOR);
 
-	/* Toast and set header data in all the tuples */
-	heaptuples = palloc(ntuples * sizeof(HeapTuple));
-	for (i = 0; i < ntuples; i++)
-		heaptuples[i] = heap_prepare_insert(relation, tuples[i],
+	/* Toast and set header data in all the slots */
+	heaptuples = palloc(nslots * sizeof(HeapTuple));
+	for (i = 0; i < nslots; i++)
+	{
+		heaptuples[i] = heap_prepare_insert(relation, ExecGetHeapTupleFromSlot(slots[i]),
 											xid, cid, options);
+		if (slots[i]->tts_tupleOid != InvalidOid)
+			HeapTupleSetOid(heaptuples[i], slots[i]->tts_tupleOid);
+
+		if (slots[i]->tts_tableOid != InvalidOid)
+			heaptuples[i]->t_tableOid = slots[i]->tts_tableOid;
+	}
 
 	/*
 	 * Allocate some memory to use for constructing the WAL record. Using
@@ -2706,7 +2713,7 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 	CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
 
 	ndone = 0;
-	while (ndone < ntuples)
+	while (ndone < nslots)
 	{
 		Buffer		buffer;
 		Buffer		vmbuffer = InvalidBuffer;
@@ -2732,7 +2739,7 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 		 * Put that on the page, and then as many other tuples as fit.
 		 */
 		RelationPutHeapTuple(relation, buffer, heaptuples[ndone], false);
-		for (nthispage = 1; ndone + nthispage < ntuples; nthispage++)
+		for (nthispage = 1; ndone + nthispage < nslots; nthispage++)
 		{
 			HeapTuple	heaptup = heaptuples[ndone + nthispage];
 
@@ -2841,7 +2848,7 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 			 * emitted by this call to heap_multi_insert(). Needed for logical
 			 * decoding so it knows when to cleanup temporary data.
 			 */
-			if (ndone + nthispage == ntuples)
+			if (ndone + nthispage == nslots)
 				xlrec->flags |= XLH_INSERT_LAST_IN_MULTI;
 
 			if (init)
@@ -2904,7 +2911,7 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 	 */
 	if (IsCatalogRelation(relation))
 	{
-		for (i = 0; i < ntuples; i++)
+		for (i = 0; i < nslots; i++)
 			CacheInvalidateHeapTuple(relation, heaptuples[i], NULL);
 	}
 
@@ -2913,10 +2920,10 @@ heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
 	 * nothing for untoasted tuples (tuples[i] == heaptuples[i)], but it's
 	 * probably faster to always copy than check.
 	 */
-	for (i = 0; i < ntuples; i++)
-		tuples[i]->t_self = heaptuples[i]->t_self;
+	for (i = 0; i < nslots; i++)
+		slots[i]->tts_tid = heaptuples[i]->t_self;
 
-	pgstat_count_heap_insert(relation, ntuples);
+	pgstat_count_heap_insert(relation, nslots);
 }
 
 /*
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index d49734ddab..62ee8cfea7 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -306,9 +306,9 @@ static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
 			 Datum *values, bool *nulls);
 static void CopyFromInsertBatch(CopyState cstate, EState *estate,
 					CommandId mycid, int hi_options,
-					ResultRelInfo *resultRelInfo, TupleTableSlot *myslot,
+					ResultRelInfo *resultRelInfo,
 					BulkInsertState bistate,
-					int nBufferedTuples, HeapTuple *bufferedTuples,
+					int nslots, TupleTableSlot **slots,
 					uint64 firstBufferedLineNo);
 static bool CopyReadLine(CopyState cstate);
 static bool CopyReadLineText(CopyState cstate);
@@ -2310,7 +2310,6 @@ CopyFrom(CopyState cstate)
 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
 	ModifyTableState *mtstate;
 	ExprContext *econtext;
-	TupleTableSlot *myslot;
 	MemoryContext oldcontext = CurrentMemoryContext;
 
 	ErrorContextCallback errcallback;
@@ -2319,12 +2318,11 @@ CopyFrom(CopyState cstate)
 	void       *bistate;
 	uint64		processed = 0;
 	bool		useHeapMultiInsert;
-	int			nBufferedTuples = 0;
+	int			nslots = 0;
 	int			prev_leaf_part_index = -1;
 
-#define MAX_BUFFERED_TUPLES 1000
-	HeapTuple  *bufferedTuples = NULL;	/* initialize to silence warning */
-	Size		bufferedTuplesSize = 0;
+#define MAX_BUFFERED_SLOTS 1000
+	TupleTableSlot  **slots = NULL;	/* initialize to silence warning */
 	uint64		firstBufferedLineNo = 0;
 
 	Assert(cstate->rel);
@@ -2467,10 +2465,6 @@ CopyFrom(CopyState cstate)
 	estate->es_result_relation_info = resultRelInfo;
 	estate->es_range_table = cstate->range_table;
 
-	/* Set up a tuple slot too */
-	myslot = ExecInitExtraTupleSlot(estate, tupDesc,
-									TTS_TYPE_HEAPTUPLE);
-
 	/*
 	 * Set up a ModifyTableState so we can let FDW(s) init themselves for
 	 * foreign-table result relation(s).
@@ -2541,7 +2535,7 @@ CopyFrom(CopyState cstate)
 	else
 	{
 		useHeapMultiInsert = true;
-		bufferedTuples = palloc(MAX_BUFFERED_TUPLES * sizeof(HeapTuple));
+		slots = palloc(MAX_BUFFERED_SLOTS * sizeof(TupleTableSlot *));
 	}
 
 	/*
@@ -2569,11 +2563,17 @@ CopyFrom(CopyState cstate)
 		TupleTableSlot *slot;
 		bool		skip_tuple;
 		Oid			loaded_oid = InvalidOid;
+		int			natts = resultRelInfo->ri_RelationDesc->rd_att->natts;
+		int			cnt;
 
 		CHECK_FOR_INTERRUPTS();
 
-		if (nBufferedTuples == 0)
+		if (nslots == 0)
 		{
+			/* Reset Tupletable slots if any */
+			ExecResetTupleTable(estate->es_tupleTable, false);
+			estate->es_tupleTable = NIL;
+
 			/*
 			 * Reset the per-tuple exprcontext. We can only do this if the
 			 * tuple buffer is empty. (Calling the context the per-tuple
@@ -2588,25 +2588,32 @@ CopyFrom(CopyState cstate)
 		if (!NextCopyFrom(cstate, econtext, values, nulls, &loaded_oid))
 			break;
 
-		/* And now we can form the input tuple. */
-		tuple = heap_form_tuple(tupDesc, values, nulls);
+		slot = ExecInitExtraTupleSlot(estate,
+						RelationGetDescr(resultRelInfo->ri_RelationDesc),
+						useHeapMultiInsert ? TTS_TYPE_VIRTUAL : TTS_TYPE_HEAPTUPLE);
+
+		/* Directly store the values/nulls array in the slot */
+		memcpy(slot->tts_isnull, nulls, sizeof(bool) * natts);
+		for (cnt = 0; cnt < natts; cnt++)
+		{
+			if (!slot->tts_isnull[cnt])
+				slot->tts_values[cnt] = values[cnt];
+		}
+
+		ExecStoreVirtualTuple(slot);
 
 		if (loaded_oid != InvalidOid)
-			HeapTupleSetOid(tuple, loaded_oid);
+			slot->tts_tupleOid = loaded_oid;
 
 		/*
 		 * Constraints might reference the tableoid column, so initialize
 		 * t_tableOid before evaluating them.
 		 */
-		tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+		slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
 
 		/* Triggers and stuff need to be invoked in query context. */
 		MemoryContextSwitchTo(oldcontext);
 
-		/* Place tuple in tuple slot --- but slot shouldn't free it */
-		slot = myslot;
-		ExecStoreTuple(tuple, slot, InvalidBuffer, false);
-
 		/* Determine the partition to heap_insert the tuple into */
 		if (cstate->partition_tuple_routing)
 		{
@@ -2659,6 +2666,9 @@ CopyFrom(CopyState cstate)
 			 */
 			estate->es_result_relation_info = resultRelInfo;
 
+			/* FIXME: Get the HeapTuple from slot */
+			tuple = ExecGetHeapTupleFromSlot(slot);
+
 			/*
 			 * If we're capturing transition tuples, we might need to convert
 			 * from the partition rowtype to parent rowtype.
@@ -2699,6 +2709,7 @@ CopyFrom(CopyState cstate)
 											  &slot);
 
 			tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+			slot->tts_tableOid = tuple->t_tableOid;
 		}
 
 		skip_tuple = false;
@@ -2709,8 +2720,6 @@ CopyFrom(CopyState cstate)
 		{
 			if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))
 				skip_tuple = true;	/* "do nothing" */
-			else				/* trigger might have changed tuple */
-				tuple = ExecGetHeapTupleFromSlot(slot);
 		}
 
 		if (!skip_tuple)
@@ -2746,10 +2755,9 @@ CopyFrom(CopyState cstate)
 				if (useHeapMultiInsert)
 				{
 					/* Add this tuple to the tuple buffer */
-					if (nBufferedTuples == 0)
+					if (nslots == 0)
 						firstBufferedLineNo = cstate->cur_lineno;
-					bufferedTuples[nBufferedTuples++] = tuple;
-					bufferedTuplesSize += tuple->t_len;
+					slots[nslots++] = slot;
 
 					/*
 					 * If the buffer filled up, flush it.  Also flush if the
@@ -2757,15 +2765,13 @@ CopyFrom(CopyState cstate)
 					 * large, to avoid using large amounts of memory for the
 					 * buffer when the tuples are exceptionally wide.
 					 */
-					if (nBufferedTuples == MAX_BUFFERED_TUPLES ||
-						bufferedTuplesSize > 65535)
+					if (nslots == MAX_BUFFERED_SLOTS)
 					{
 						CopyFromInsertBatch(cstate, estate, mycid, hi_options,
-											resultRelInfo, myslot, bistate,
-											nBufferedTuples, bufferedTuples,
+											resultRelInfo, bistate,
+											nslots, slots,
 											firstBufferedLineNo);
-						nBufferedTuples = 0;
-						bufferedTuplesSize = 0;
+						nslots = 0;
 					}
 				}
 				else
@@ -2783,15 +2789,12 @@ CopyFrom(CopyState cstate)
 						if (slot == NULL)	/* "do nothing" */
 							goto next_tuple;
 
-						/* FDW might have changed tuple */
-						tuple = ExecGetHeapTupleFromSlot(slot);
-
 						/*
 						 * AFTER ROW Triggers might reference the tableoid
 						 * column, so initialize t_tableOid before evaluating
 						 * them.
 						 */
-						tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+						slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
 					}
 					else
 					{
@@ -2834,10 +2837,10 @@ next_tuple:
 	}
 
 	/* Flush any remaining buffered tuples */
-	if (nBufferedTuples > 0)
+	if (nslots > 0)
 		CopyFromInsertBatch(cstate, estate, mycid, hi_options,
-							resultRelInfo, myslot, bistate,
-							nBufferedTuples, bufferedTuples,
+							resultRelInfo, bistate,
+							nslots, slots,
 							firstBufferedLineNo);
 
 	/* Done, clean up */
@@ -2900,8 +2903,7 @@ next_tuple:
 static void
 CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 					int hi_options, ResultRelInfo *resultRelInfo,
-					TupleTableSlot *myslot, BulkInsertState bistate,
-					int nBufferedTuples, HeapTuple *bufferedTuples,
+					BulkInsertState bistate, int nslots, TupleTableSlot **slots,
 					uint64 firstBufferedLineNo)
 {
 	MemoryContext oldcontext;
@@ -2921,8 +2923,8 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 	 */
 	oldcontext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 	table_multi_insert(cstate->rel,
-					   bufferedTuples,
-					   nBufferedTuples,
+					   slots,
+					   nslots,
 					   mycid,
 					   hi_options,
 					   bistate);
@@ -2934,16 +2936,15 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 	 */
 	if (resultRelInfo->ri_NumIndices > 0)
 	{
-		for (i = 0; i < nBufferedTuples; i++)
+		for (i = 0; i < nslots; i++)
 		{
 			List	   *recheckIndexes;
 
 			cstate->cur_lineno = firstBufferedLineNo + i;
-			ExecStoreTuple(bufferedTuples[i], myslot, InvalidBuffer, false);
 			recheckIndexes =
-				ExecInsertIndexTuples(myslot, estate, false, NULL, NIL);
+				ExecInsertIndexTuples(slots[i], estate, false, NULL, NIL);
 			ExecARInsertTriggers(estate, resultRelInfo,
-								 myslot,
+								 slots[i],
 								 recheckIndexes, cstate->transition_capture);
 			list_free(recheckIndexes);
 		}
@@ -2957,12 +2958,11 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 			 (resultRelInfo->ri_TrigDesc->trig_insert_after_row ||
 			  resultRelInfo->ri_TrigDesc->trig_insert_new_table))
 	{
-		for (i = 0; i < nBufferedTuples; i++)
+		for (i = 0; i < nslots; i++)
 		{
 			cstate->cur_lineno = firstBufferedLineNo + i;
-			ExecStoreTuple(bufferedTuples[i], myslot, InvalidBuffer, false);
 			ExecARInsertTriggers(estate, resultRelInfo,
-								 myslot,
+								 slots[i],
 								 NIL, cstate->transition_capture);
 		}
 	}
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 5f89b5b174..a36a0c49e9 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -16,6 +16,7 @@
 
 #include "access/sdir.h"
 #include "access/skey.h"
+#include "executor/tuptable.h"
 #include "nodes/lockoptions.h"
 #include "nodes/primnodes.h"
 #include "storage/bufpage.h"
@@ -168,7 +169,7 @@ extern void ReleaseBulkInsertStatePin(BulkInsertState bistate);
 
 extern Oid heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 			int options, BulkInsertState bistate);
-extern void heap_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
+extern void heap_multi_insert(Relation relation, TupleTableSlot **slots, int nslots,
 				  CommandId cid, int options, BulkInsertState bistate);
 extern HTSU_Result heap_delete(Relation relation, ItemPointer tid,
 			CommandId cid, Snapshot crosscheck, bool wait,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index df60ba3316..9912a171fb 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -103,7 +103,7 @@ typedef HTSU_Result (*TupleLock_function) (Relation relation,
 										   uint8 flags,
 										   HeapUpdateFailureData *hufd);
 
-typedef void (*MultiInsert_function) (Relation relation, HeapTuple *tuples, int ntuples,
+typedef void (*MultiInsert_function) (Relation relation, TupleTableSlot **slots, int nslots,
 									  CommandId cid, int options, BulkInsertState bistate);
 
 typedef void (*TupleGetLatestTid_function) (Relation relation,
@@ -611,10 +611,10 @@ table_fetch_follow_check(Relation rel,
  *	table_multi_insert	- insert multiple tuple into a table
  */
 static inline void
-table_multi_insert(Relation relation, HeapTuple *tuples, int ntuples,
+table_multi_insert(Relation relation, TupleTableSlot **slots, int nslots,
 					 CommandId cid, int options, BulkInsertState bistate)
 {
-	relation->rd_tableamroutine->multi_insert(relation, tuples, ntuples,
+	relation->rd_tableamroutine->multi_insert(relation, slots, nslots,
 										   cid, options, bistate);
 }
 
-- 
2.18.0.windows.1

From a064078f3cc917cd548f20cc7327516c3905b35b Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 21 Aug 2018 16:28:46 +1000
Subject: [PATCH] isolation test fixes -2

---
 src/backend/commands/trigger.c         | 6 +++++-
 src/backend/executor/execMain.c        | 9 +++++++--
 src/backend/executor/nodeModifyTable.c | 4 ++++
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index b2951a237e..801a3fee25 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -3326,7 +3326,11 @@ GetTupleForTrigger(EState *estate,
 					if (TupIsNull(epqslot))
 						return false;
 
-					ExecCopySlot(newslot, epqslot);
+					if (newslot)
+						ExecCopySlot(newslot, epqslot);
+					else
+						ExecCopySlot(oldslot, epqslot);
+
 					*is_epqtuple = true;
 				}
 				break;
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index fd3e53d1ee..dbbebca045 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2477,8 +2477,13 @@ EvalPlanQualSlot(EPQState *epqstate,
 		MemoryContext oldcontext;
 
 		oldcontext = MemoryContextSwitchTo(epqstate->estate->es_query_cxt);
-		*slot = table_gimmegimmeslot(relation,
-									 &epqstate->estate->es_tupleTable);
+
+		if (relation)
+			*slot = table_gimmegimmeslot(relation, &epqstate->estate->es_tupleTable);
+		else
+			*slot = MakeTupleTableSlot(epqstate->origslot->tts_tupleDescriptor, TTS_TYPE_BUFFER);
+
+		epqstate->estate->es_epqTupleSet[rti - 1] = true;
 		MemoryContextSwitchTo(oldcontext);
 	}
 
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 71150ad32e..14ca3b976e 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -702,6 +702,9 @@ ldelete:;
 
 		if (result == HeapTupleUpdated && !IsolationUsesXactSnapshot())
 		{
+			EvalPlanQualBegin(epqstate, estate);
+			slot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
+
 			result = table_lock_tuple(resultRelationDesc, tupleid,
 									  estate->es_snapshot,
 									  slot, estate->es_output_cid,
@@ -1182,6 +1185,7 @@ lreplace:;
 			EvalPlanQualBegin(epqstate, estate);
 
 			inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
+			ExecCopySlot(inputslot, slot);
 
 			result = table_lock_tuple(resultRelationDesc, tupleid,
 									  estate->es_snapshot,
-- 
2.18.0.windows.1

From 58b1bcd28991a1be04d13783e1c46a1ebf5de51c Mon Sep 17 00:00:00 2001
From: Kommi <haribabuk@fast.au.fujitsu.com>
Date: Fri, 24 Aug 2018 11:21:34 +1000
Subject: [PATCH 2/2] check-world fixes

---
 contrib/amcheck/verify_nbtree.c        |  1 +
 contrib/pg_visibility/pg_visibility.c  |  5 +++--
 contrib/pgstattuple/pgstatapprox.c     | 10 +++++++++-
 contrib/pgstattuple/pgstattuple.c      |  9 ++++++++-
 src/backend/executor/execMain.c        | 11 +----------
 src/backend/executor/execTuples.c      | 22 ++++++++++++++++++++++
 src/backend/executor/nodeModifyTable.c | 12 ++++++++++--
 src/include/executor/tuptable.h        |  1 +
 8 files changed, 55 insertions(+), 16 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 04102dd3df..cb4294af7d 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -25,6 +25,7 @@
 
 #include "access/htup_details.h"
 #include "access/nbtree.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "catalog/index.h"
diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index dce5262e34..88ca4fd2af 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -563,12 +563,13 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 
 	rel = relation_open(relid, AccessShareLock);
 
+	/* Only some relkinds have a visibility map */
+	check_relation_relkind(rel);
+
 	if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
 		ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						errmsg("only heap AM is supported")));
 
-	/* Only some relkinds have a visibility map */
-	check_relation_relkind(rel);
 
 	nblocks = RelationGetNumberOfBlocks(rel);
 
diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
index e805981bb9..6aee2ce8ac 100644
--- a/contrib/pgstattuple/pgstatapprox.c
+++ b/contrib/pgstattuple/pgstatapprox.c
@@ -12,6 +12,7 @@
  */
 #include "postgres.h"
 
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/visibilitymap.h"
 #include "access/xact.h"
@@ -69,6 +70,7 @@ statapprox_heap(Relation rel, output_type *stat)
 	Buffer		vmbuffer = InvalidBuffer;
 	BufferAccessStrategy bstrategy;
 	TransactionId OldestXmin;
+	TupleTableSlot *slot;
 
 	OldestXmin = GetOldestXmin(rel, PROCARRAY_FLAGS_VACUUM);
 	bstrategy = GetAccessStrategy(BAS_BULKREAD);
@@ -76,6 +78,8 @@ statapprox_heap(Relation rel, output_type *stat)
 	nblocks = RelationGetNumberOfBlocks(rel);
 	scanned = 0;
 
+	slot = MakeSingleTupleTableSlot(RelationGetDescr(rel), TTS_TYPE_BUFFER);
+
 	for (blkno = 0; blkno < nblocks; blkno++)
 	{
 		Buffer		buf;
@@ -153,13 +157,15 @@ statapprox_heap(Relation rel, output_type *stat)
 			tuple.t_len = ItemIdGetLength(itemid);
 			tuple.t_tableOid = RelationGetRelid(rel);
 
+			ExecStoreTuple(&tuple,slot,buf,false);
+
 			/*
 			 * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
 			 * as "dead" while DELETE_IN_PROGRESS tuples are "live".  We don't
 			 * bother distinguishing tuples inserted/deleted by our own
 			 * transaction.
 			 */
-			switch (rel->rd_tableamroutine->snapshot_satisfiesVacuum(&tuple, OldestXmin, buf))
+			switch (rel->rd_tableamroutine->snapshot_satisfiesVacuum(slot, OldestXmin))
 			{
 				case HEAPTUPLE_LIVE:
 				case HEAPTUPLE_DELETE_IN_PROGRESS:
@@ -210,6 +216,8 @@ statapprox_heap(Relation rel, output_type *stat)
 		ReleaseBuffer(vmbuffer);
 		vmbuffer = InvalidBuffer;
 	}
+
+	ExecDropSingleTupleTableSlot(slot);
 }
 
 /*
diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c
index 53fdff6c2c..5965ecbcf8 100644
--- a/contrib/pgstattuple/pgstattuple.c
+++ b/contrib/pgstattuple/pgstattuple.c
@@ -28,6 +28,7 @@
 #include "access/hash.h"
 #include "access/nbtree.h"
 #include "access/relscan.h"
+#include "access/tableam.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_am.h"
 #include "funcapi.h"
@@ -326,12 +327,14 @@ pgstat_heap(Relation rel, FunctionCallInfo fcinfo)
 	Buffer		buffer;
 	pgstattuple_type stat = {0};
 	SnapshotData SnapshotDirty;
+	TupleTableSlot *slot;
 	TableAmRoutine *method = rel->rd_tableamroutine;
 
 	/* Disable syncscan because we assume we scan from block zero upwards */
 	scan = table_beginscan_strat(rel, SnapshotAny, 0, NULL, true, false);
 	InitDirtySnapshot(SnapshotDirty);
 
+	slot = MakeSingleTupleTableSlot(RelationGetDescr(rel), TTS_TYPE_BUFFER);
 	pagescan = tableam_get_heappagescandesc(scan);
 	nblocks = pagescan->rs_nblocks; /* # blocks to be scanned */
 
@@ -343,7 +346,10 @@ pgstat_heap(Relation rel, FunctionCallInfo fcinfo)
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
 		LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
 
-		if (HeapTupleSatisfiesVisibility(method, tuple, &SnapshotDirty, scan->rs_cbuf))
+		/* FIXME: change to get the slot directly, instead of tuple */
+		ExecStoreTuple(tuple, slot, scan->rs_cbuf, false);
+
+		if (HeapTupleSatisfiesVisibility(method, slot, &SnapshotDirty))
 		{
 			stat.tuple_len += tuple->t_len;
 			stat.tuple_count++;
@@ -393,6 +399,7 @@ pgstat_heap(Relation rel, FunctionCallInfo fcinfo)
 	relation_close(rel, AccessShareLock);
 
 	stat.table_len = (uint64) nblocks * BLCKSZ;
+	ExecDropSingleTupleTableSlot(slot);
 
 	return build_pgstattuple_type(&stat, fcinfo);
 }
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 1237e809f3..e349a22e94 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2765,16 +2765,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			if (isNull)
 				continue;
 
-			elog(ERROR, "frak, need to implement ROW_MARK_COPY");
-#ifdef FIXME
-			// FIXME: this should just deform the tuple and store it as a
-			// virtual one.
-			tuple = table_tuple_by_datum(erm->relation, datum, erm->relid);
-
-			/* store tuple */
-			EvalPlanQualSetTuple(epqstate, erm->rti, tuple);
-#endif
-
+			ExecForceStoreHeapTupleDatum(datum, slot);
 		}
 	}
 }
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 59ccc1a626..046f7b23dc 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1385,6 +1385,28 @@ ExecForceStoreHeapTuple(HeapTuple tuple,
 
 }
 
+void
+ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
+{
+	HeapTuple	tuple;
+	HeapTupleHeader td;
+	MemoryContext oldContext;
+
+	td = DatumGetHeapTupleHeader(data);
+
+	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + HeapTupleHeaderGetDatumLength(td));
+	tuple->t_len = HeapTupleHeaderGetDatumLength(td);
+	tuple->t_self = td->t_ctid;
+	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+	memcpy((char *) tuple->t_data, (char *) td, tuple->t_len);
+
+	ExecClearTuple(slot);
+
+	heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
+					  slot->tts_values, slot->tts_isnull);
+	ExecStoreVirtualTuple(slot);
+}
+
 /* --------------------------------
  *		ExecStoreMinimalTuple
  *
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 14ca3b976e..d7d79f845c 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -609,7 +609,7 @@ ExecDelete(ModifyTableState *mtstate,
 		   bool canSetTag,
 		   bool changingPart,
 		   bool *tupleDeleted,
-		   TupleTableSlot **epqslot)
+		   TupleTableSlot **epqreturnslot)
 {
 	ResultRelInfo *resultRelInfo;
 	Relation	resultRelationDesc;
@@ -634,7 +634,7 @@ ExecDelete(ModifyTableState *mtstate,
 		bool		dodelete;
 
 		dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
-										tupleid, oldtuple, epqslot);
+										tupleid, oldtuple, epqreturnslot);
 
 		if (!dodelete)			/* "do nothing" */
 			return NULL;
@@ -727,6 +727,14 @@ ldelete:;
 					/* Tuple no more passing quals, exiting... */
 					return NULL;
 				}
+
+				/**/
+				if (epqreturnslot)
+				{
+					*epqreturnslot = epqslot;
+					return NULL;
+				}
+
 				goto ldelete;
 			}
 		}
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index dec3e87a1e..4e49304ba7 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -313,6 +313,7 @@ extern TupleTableSlot *ExecStoreMinimalTuple(MinimalTuple mtup,
 
 extern void ExecForceStoreHeapTuple(HeapTuple tuple,
 			   TupleTableSlot *slot);
+extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 
 extern TupleTableSlot *ExecStoreVirtualTuple(TupleTableSlot *slot);
 extern TupleTableSlot *ExecStoreAllNullTuple(TupleTableSlot *slot);
-- 
2.18.0.windows.1

From 71a9811c742dfe7ac8cfac053d02869540452f92 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 22 Aug 2018 16:45:02 +1000
Subject: [PATCH 1/2] FDW RefetchForeignRow API prototype change

With pluggable storage, the tuple usage is minimized
and all the extenal API's must deal with TupleTableSlot.
---
 doc/src/sgml/fdwhandler.sgml        | 10 ++++++----
 src/backend/executor/execMain.c     | 16 ++++++++--------
 src/backend/executor/nodeLockRows.c | 20 +++++++-------------
 src/include/foreign/fdwapi.h        |  9 +++++----
 4 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index 4ce88dd77c..12769f3288 100644
--- a/doc/src/sgml/fdwhandler.sgml
+++ b/doc/src/sgml/fdwhandler.sgml
@@ -988,23 +988,25 @@ GetForeignRowMarkType(RangeTblEntry *rte,
 
     <para>
 <programlisting>
-HeapTuple
+TupleTableSlot *
 RefetchForeignRow(EState *estate,
                   ExecRowMark *erm,
                   Datum rowid,
+                  TupleTableSlot *slot,
                   bool *updated);
 </programlisting>
 
-     Re-fetch one tuple from the foreign table, after locking it if required.
+     Re-fetch one tuple slot from the foreign table, after locking it if required.
      <literal>estate</literal> is global execution state for the query.
      <literal>erm</literal> is the <structname>ExecRowMark</structname> struct describing
      the target foreign table and the row lock type (if any) to acquire.
      <literal>rowid</literal> identifies the tuple to be fetched.
-     <literal>updated</literal> is an output parameter.
+     <literal>slot</literal> contains nothing useful upon call, but can be used to
+     hold the returned tuple. <literal>updated</literal> is an output parameter.
     </para>
 
     <para>
-     This function should return a palloc'ed copy of the fetched tuple,
+     This function should return a slot containing the fetched tuple
      or <literal>NULL</literal> if the row lock couldn't be obtained.  The row lock
      type to acquire is defined by <literal>erm-&gt;markType</literal>, which is the
      value previously returned by <function>GetForeignRowMarkType</function>.
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index dbbebca045..1237e809f3 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2704,23 +2704,24 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			/* fetch requests on foreign tables must be passed to their FDW */
 			if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
 			{
-				elog(ERROR, "frak, need to change fdw API");
-#ifdef FIXME
 				FdwRoutine *fdwroutine;
 				bool		updated = false;
 
 				fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
+
 				/* this should have been checked already, but let's be safe */
 				if (fdwroutine->RefetchForeignRow == NULL)
 					ereport(ERROR,
 							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 							 errmsg("cannot lock rows in foreign table \"%s\"",
 									RelationGetRelationName(erm->relation))));
-				tuple = fdwroutine->RefetchForeignRow(epqstate->estate,
-													  erm,
-													  datum,
-													  &updated);
-				if (tuple == NULL)
+
+				slot = fdwroutine->RefetchForeignRow(epqstate->estate,
+													 erm,
+													 datum,
+													 slot,
+													 &updated);
+				if (slot == NULL)
 					elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
 
 				/*
@@ -2728,7 +2729,6 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 				 * assumes that FDWs can track that exactly, which they might
 				 * not be able to.  So just ignore the flag.
 				 */
-#endif
 			}
 			else
 			{
diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c
index e58e0919d8..3a4071f2e3 100644
--- a/src/backend/executor/nodeLockRows.c
+++ b/src/backend/executor/nodeLockRows.c
@@ -128,33 +128,27 @@ lnext:
 		{
 			FdwRoutine *fdwroutine;
 			bool		updated = false;
-			HeapTuple	copyTuple;
-
-			elog(ERROR, "frak, tuple based API needs to be rewritten");
 
 			fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
+
 			/* this should have been checked already, but let's be safe */
 			if (fdwroutine->RefetchForeignRow == NULL)
 				ereport(ERROR,
 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						 errmsg("cannot lock rows in foreign table \"%s\"",
 								RelationGetRelationName(erm->relation))));
-			copyTuple = fdwroutine->RefetchForeignRow(estate,
-													  erm,
-													  datum,
-													  &updated);
 
-			if (copyTuple == NULL)
+			markSlot = fdwroutine->RefetchForeignRow(estate,
+													 erm,
+													 datum,
+													 markSlot,
+													 &updated);
+			if (markSlot == NULL)
 			{
 				/* couldn't get the lock, so skip this row */
 				goto lnext;
 			}
 
-			elog(ERROR, "frak: slotify");
-
-			/* save locked tuple for possible EvalPlanQual testing below */
-			//*testTuple = copyTuple;
-
 			/*
 			 * if FDW says tuple was updated before getting locked, we need to
 			 * perform EPQ testing to see if quals are still satisfied
diff --git a/src/include/foreign/fdwapi.h b/src/include/foreign/fdwapi.h
index c14eb546c6..508b0eece8 100644
--- a/src/include/foreign/fdwapi.h
+++ b/src/include/foreign/fdwapi.h
@@ -121,10 +121,11 @@ typedef void (*EndDirectModify_function) (ForeignScanState *node);
 typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
 													   LockClauseStrength strength);
 
-typedef HeapTuple (*RefetchForeignRow_function) (EState *estate,
-												 ExecRowMark *erm,
-												 Datum rowid,
-												 bool *updated);
+typedef TupleTableSlot *(*RefetchForeignRow_function) (EState *estate,
+													   ExecRowMark *erm,
+													   Datum rowid,
+													   TupleTableSlot *slot,
+													   bool *updated);
 
 typedef void (*ExplainForeignScan_function) (ForeignScanState *node,
 											 struct ExplainState *es);
-- 
2.18.0.windows.1

From fd6fb3028c1c9f7fcb41d651a324b1b1eb4ab2ce Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 29 Aug 2018 13:52:39 +1000
Subject: [PATCH 2/2] copy memory limit fix

To limit memory used by the COPY FROM because of slotification,
calculates the tuple size of the first tuple in the batch and
use that for remaining batch, so that it almost averages the
memory usage by the COPY command.
---
 src/backend/commands/copy.c | 61 ++++++++++++++++++++++++-------------
 1 file changed, 39 insertions(+), 22 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index c9272b344a..1e2d5ebb50 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -308,7 +308,7 @@ static void CopyFromInsertBatch(CopyState cstate, EState *estate,
 					CommandId mycid, int hi_options,
 					ResultRelInfo *resultRelInfo,
 					BulkInsertState bistate,
-					int nBufferedTuples, TupleTableSlot **bufferedSlots,
+					int nBufferedSlots, TupleTableSlot **bufferedSlots,
 					uint64 firstBufferedLineNo);
 static bool CopyReadLine(CopyState cstate);
 static bool CopyReadLineText(CopyState cstate);
@@ -2309,11 +2309,12 @@ CopyFrom(CopyState cstate)
 	void       *bistate;
 	uint64		processed = 0;
 	bool		useHeapMultiInsert;
-	int			nBufferedTuples = 0;
+	int			nBufferedSlots = 0;
 	int			prev_leaf_part_index = -1;
 
-#define MAX_BUFFERED_TUPLES 1000
+#define MAX_BUFFERED_SLOTS 1000
 	TupleTableSlot  **bufferedSlots = NULL;	/* initialize to silence warning */
+	Size		bufferedSlotsSize = 0;
 	uint64		firstBufferedLineNo = 0;
 
 	Assert(cstate->rel);
@@ -2524,7 +2525,7 @@ CopyFrom(CopyState cstate)
 	else
 	{
 		useHeapMultiInsert = true;
-		bufferedSlots = palloc0(MAX_BUFFERED_TUPLES * sizeof(TupleTableSlot *));
+		bufferedSlots = palloc0(MAX_BUFFERED_SLOTS * sizeof(TupleTableSlot *));
 	}
 
 	/*
@@ -2562,7 +2563,7 @@ CopyFrom(CopyState cstate)
 
 		CHECK_FOR_INTERRUPTS();
 
-		if (nBufferedTuples == 0)
+		if (nBufferedSlots == 0)
 		{
 			/*
 			 * Reset the per-tuple exprcontext. We can only do this if the
@@ -2577,14 +2578,14 @@ CopyFrom(CopyState cstate)
 			myslot = singleslot;
 			Assert(myslot != NULL);
 		}
-		else if (bufferedSlots[nBufferedTuples] == NULL)
+		else if (bufferedSlots[nBufferedSlots] == NULL)
 		{
 			myslot = table_gimmegimmeslot(resultRelInfo->ri_RelationDesc,
 										  &estate->es_tupleTable);
-			bufferedSlots[nBufferedTuples] = myslot;
+			bufferedSlots[nBufferedSlots] = myslot;
 		}
 		else
-			myslot = bufferedSlots[nBufferedTuples];
+			myslot = bufferedSlots[nBufferedSlots];
 
 		/* Switch into its memory context */
 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
@@ -2750,27 +2751,43 @@ CopyFrom(CopyState cstate)
 
 				if (useHeapMultiInsert)
 				{
+					int tup_size;
+
 					/* Add this tuple to the tuple buffer */
-					if (nBufferedTuples == 0)
+					if (nBufferedSlots == 0)
+					{
 						firstBufferedLineNo = cstate->cur_lineno;
-					Assert(bufferedSlots[nBufferedTuples] == myslot);
-					nBufferedTuples++;
+
+						/*
+						 * Find out the Tuple size of the first tuple in a batch and
+						 * use it for the rest tuples in a batch. There may be scenarios
+						 * where the first tuple is very small and rest can be large, but
+						 * that's rare and this should work for majority of the scenarios.
+						 */
+						tup_size = heap_compute_data_size(myslot->tts_tupleDescriptor,
+														  myslot->tts_values,
+														  myslot->tts_isnull);
+					}
+
+					Assert(bufferedSlots[nBufferedSlots] == myslot);
+					nBufferedSlots++;
+					bufferedSlotsSize += tup_size;
 
 					/*
 					 * If the buffer filled up, flush it.  Also flush if the
 					 * total size of all the tuples in the buffer becomes
 					 * large, to avoid using large amounts of memory for the
 					 * buffer when the tuples are exceptionally wide.
-					 *
-					 * PBORKED: Re-introduce size limit
 					 */
-					if (nBufferedTuples == MAX_BUFFERED_TUPLES)
+					if (nBufferedSlots == MAX_BUFFERED_SLOTS ||
+						bufferedSlotsSize > 65535)
 					{
 						CopyFromInsertBatch(cstate, estate, mycid, hi_options,
 											resultRelInfo, bistate,
-											nBufferedTuples, bufferedSlots,
+											nBufferedSlots, bufferedSlots,
 											firstBufferedLineNo);
-						nBufferedTuples = 0;
+						nBufferedSlots = 0;
+						bufferedSlotsSize = 0;
 					}
 				}
 				else
@@ -2836,10 +2853,10 @@ next_tuple:
 	}
 
 	/* Flush any remaining buffered tuples */
-	if (nBufferedTuples > 0)
+	if (nBufferedSlots > 0)
 		CopyFromInsertBatch(cstate, estate, mycid, hi_options,
 							resultRelInfo, bistate,
-							nBufferedTuples, bufferedSlots,
+							nBufferedSlots, bufferedSlots,
 							firstBufferedLineNo);
 
 	/* Done, clean up */
@@ -2899,7 +2916,7 @@ next_tuple:
 static void
 CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 					int hi_options, ResultRelInfo *resultRelInfo,
-					BulkInsertState bistate, int nBufferedTuples, TupleTableSlot **bufferedSlots,
+					BulkInsertState bistate, int nBufferedSlots, TupleTableSlot **bufferedSlots,
 					uint64 firstBufferedLineNo)
 {
 	MemoryContext oldcontext;
@@ -2920,7 +2937,7 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 	oldcontext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 	table_multi_insert(cstate->rel,
 					   bufferedSlots,
-					   nBufferedTuples,
+					   nBufferedSlots,
 					   mycid,
 					   hi_options,
 					   bistate);
@@ -2932,7 +2949,7 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 	 */
 	if (resultRelInfo->ri_NumIndices > 0)
 	{
-		for (i = 0; i < nBufferedTuples; i++)
+		for (i = 0; i < nBufferedSlots; i++)
 		{
 			List	   *recheckIndexes;
 
@@ -2954,7 +2971,7 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
 			 (resultRelInfo->ri_TrigDesc->trig_insert_after_row ||
 			  resultRelInfo->ri_TrigDesc->trig_insert_new_table))
 	{
-		for (i = 0; i < nBufferedTuples; i++)
+		for (i = 0; i < nBufferedSlots; i++)
 		{
 			cstate->cur_lineno = firstBufferedLineNo + i;
 			ExecARInsertTriggers(estate, resultRelInfo,
-- 
2.18.0.windows.1

From e64936a923fa2772fa9151a0e51bb4a042bbd36b Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 29 Aug 2018 14:22:07 +1000
Subject: [PATCH 1/2] check-world fixes

---
 contrib/pg_visibility/pg_visibility.c  |  5 +++--
 src/backend/access/heap/heapam.c       |  2 --
 src/backend/executor/execExprInterp.c  |  3 +++
 src/backend/executor/execMain.c        | 13 ++-----------
 src/backend/executor/execTuples.c      | 21 +++++++++++++++++++++
 src/backend/executor/nodeModifyTable.c | 12 ++++++++++--
 src/include/executor/tuptable.h        |  1 +
 7 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index dce5262e34..88ca4fd2af 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -563,12 +563,13 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 
 	rel = relation_open(relid, AccessShareLock);
 
+	/* Only some relkinds have a visibility map */
+	check_relation_relkind(rel);
+
 	if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
 		ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						errmsg("only heap AM is supported")));
 
-	/* Only some relkinds have a visibility map */
-	check_relation_relkind(rel);
 
 	nblocks = RelationGetNumberOfBlocks(rel);
 
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index b35dcea75e..6d516ccc0b 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -83,8 +83,6 @@
 /* GUC variable */
 bool		synchronize_seqscans = true;
 
-static void heap_parallelscan_startblock_init(HeapScanDesc scan);
-static BlockNumber heap_parallelscan_nextpage(HeapScanDesc scan);
 static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
 					TransactionId xid, CommandId cid, int options);
 static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index 5ed9273d32..d91d0f25a1 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -570,6 +570,9 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 				Assert(TTS_IS_HEAPTUPLE(scanslot) ||
 					   TTS_IS_BUFFERTUPLE(scanslot));
 
+				if (hslot->tuple == NULL)
+					ExecMaterializeSlot(scanslot);
+
 				d = heap_getsysattr(hslot->tuple, attnum,
 									scanslot->tts_tupleDescriptor,
 									op->resnull);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index f430733b69..faeb960e1d 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2559,7 +2559,7 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
 	 * datums that may be present in copyTuple).  As with the next step, this
 	 * is to guard against early re-use of the EPQ query.
 	 */
-	if (!TupIsNull(slot))
+	if (!TupIsNull(slot) && !TTS_IS_VIRTUAL(slot))
 		ExecMaterializeSlot(slot);
 
 #if FIXME
@@ -2766,16 +2766,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			if (isNull)
 				continue;
 
-			elog(ERROR, "frak, need to implement ROW_MARK_COPY");
-#ifdef FIXME
-			// FIXME: this should just deform the tuple and store it as a
-			// virtual one.
-			tuple = table_tuple_by_datum(erm->relation, datum, erm->relid);
-
-			/* store tuple */
-			EvalPlanQualSetTuple(epqstate, erm->rti, tuple);
-#endif
-
+			ExecForceStoreHeapTupleDatum(datum, slot);
 		}
 	}
 }
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 4921835c31..7628799d41 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1397,6 +1397,27 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 	return ExecFinishStoreSlotValues(slot);
 }
 
+void
+ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
+{
+	HeapTuple	tuple;
+	HeapTupleHeader td;
+
+	td = DatumGetHeapTupleHeader(data);
+
+	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + HeapTupleHeaderGetDatumLength(td));
+	tuple->t_len = HeapTupleHeaderGetDatumLength(td);
+	tuple->t_self = td->t_ctid;
+	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+	memcpy((char *) tuple->t_data, (char *) td, tuple->t_len);
+
+	ExecClearTuple(slot);
+
+	heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
+					  slot->tts_values, slot->tts_isnull);
+	ExecFinishStoreSlotValues(slot);
+}
+
 /* --------------------------------
  *		ExecFetchSlotTuple
  *			Fetch the slot's regular physical tuple.
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 226ba5fc21..0b38259387 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -607,7 +607,7 @@ ExecDelete(ModifyTableState *mtstate,
 		   bool canSetTag,
 		   bool changingPart,
 		   bool *tupleDeleted,
-		   TupleTableSlot **epqslot)
+		   TupleTableSlot **epqreturnslot)
 {
 	ResultRelInfo *resultRelInfo;
 	Relation	resultRelationDesc;
@@ -632,7 +632,7 @@ ExecDelete(ModifyTableState *mtstate,
 		bool		dodelete;
 
 		dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
-										tupleid, oldtuple, epqslot);
+										tupleid, oldtuple, epqreturnslot);
 
 		if (!dodelete)			/* "do nothing" */
 			return NULL;
@@ -724,6 +724,14 @@ ldelete:;
 					/* Tuple no more passing quals, exiting... */
 					return NULL;
 				}
+
+				/**/
+				if (epqreturnslot)
+				{
+					*epqreturnslot = epqslot;
+					return NULL;
+				}
+
 				goto ldelete;
 			}
 		}
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index 1d316deed3..97aa26f5e0 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -476,6 +476,7 @@ extern TupleTableSlot *ExecCopySlot(TupleTableSlot *dstslot,
 
 extern void ExecForceStoreHeapTuple(HeapTuple tuple,
 			   TupleTableSlot *slot);
+extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 
 extern void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum);
 extern Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull);
-- 
2.18.0.windows.1

From c1a1ca617f344b8e4d6094da50585783508de0c2 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 22 Aug 2018 16:45:02 +1000
Subject: [PATCH 3/3] FDW RefetchForeignRow API prototype change

With pluggable storage, the tuple usage is minimized
and all the extenal API's must deal with TupleTableSlot.
---
 doc/src/sgml/fdwhandler.sgml        | 10 ++++++----
 src/backend/executor/execMain.c     | 16 ++++++++--------
 src/backend/executor/nodeLockRows.c | 20 +++++++-------------
 src/include/foreign/fdwapi.h        |  9 +++++----
 4 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index 4ce88dd77c..12769f3288 100644
--- a/doc/src/sgml/fdwhandler.sgml
+++ b/doc/src/sgml/fdwhandler.sgml
@@ -988,23 +988,25 @@ GetForeignRowMarkType(RangeTblEntry *rte,
 
     <para>
 <programlisting>
-HeapTuple
+TupleTableSlot *
 RefetchForeignRow(EState *estate,
                   ExecRowMark *erm,
                   Datum rowid,
+                  TupleTableSlot *slot,
                   bool *updated);
 </programlisting>
 
-     Re-fetch one tuple from the foreign table, after locking it if required.
+     Re-fetch one tuple slot from the foreign table, after locking it if required.
      <literal>estate</literal> is global execution state for the query.
      <literal>erm</literal> is the <structname>ExecRowMark</structname> struct describing
      the target foreign table and the row lock type (if any) to acquire.
      <literal>rowid</literal> identifies the tuple to be fetched.
-     <literal>updated</literal> is an output parameter.
+     <literal>slot</literal> contains nothing useful upon call, but can be used to
+     hold the returned tuple. <literal>updated</literal> is an output parameter.
     </para>
 
     <para>
-     This function should return a palloc'ed copy of the fetched tuple,
+     This function should return a slot containing the fetched tuple
      or <literal>NULL</literal> if the row lock couldn't be obtained.  The row lock
      type to acquire is defined by <literal>erm-&gt;markType</literal>, which is the
      value previously returned by <function>GetForeignRowMarkType</function>.
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index faeb960e1d..674569a586 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2705,23 +2705,24 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			/* fetch requests on foreign tables must be passed to their FDW */
 			if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
 			{
-				elog(ERROR, "frak, need to change fdw API");
-#ifdef FIXME
 				FdwRoutine *fdwroutine;
 				bool		updated = false;
 
 				fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
+
 				/* this should have been checked already, but let's be safe */
 				if (fdwroutine->RefetchForeignRow == NULL)
 					ereport(ERROR,
 							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 							 errmsg("cannot lock rows in foreign table \"%s\"",
 									RelationGetRelationName(erm->relation))));
-				tuple = fdwroutine->RefetchForeignRow(epqstate->estate,
-													  erm,
-													  datum,
-													  &updated);
-				if (tuple == NULL)
+
+				slot = fdwroutine->RefetchForeignRow(epqstate->estate,
+													 erm,
+													 datum,
+													 slot,
+													 &updated);
+				if (slot == NULL)
 					elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
 
 				/*
@@ -2729,7 +2730,6 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 				 * assumes that FDWs can track that exactly, which they might
 				 * not be able to.  So just ignore the flag.
 				 */
-#endif
 			}
 			else
 			{
diff --git a/src/backend/executor/nodeLockRows.c b/src/backend/executor/nodeLockRows.c
index 668f5fa7a2..e52394a65c 100644
--- a/src/backend/executor/nodeLockRows.c
+++ b/src/backend/executor/nodeLockRows.c
@@ -128,33 +128,27 @@ lnext:
 		{
 			FdwRoutine *fdwroutine;
 			bool		updated = false;
-			HeapTuple	copyTuple;
-
-			elog(ERROR, "frak, tuple based API needs to be rewritten");
 
 			fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
+
 			/* this should have been checked already, but let's be safe */
 			if (fdwroutine->RefetchForeignRow == NULL)
 				ereport(ERROR,
 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						 errmsg("cannot lock rows in foreign table \"%s\"",
 								RelationGetRelationName(erm->relation))));
-			copyTuple = fdwroutine->RefetchForeignRow(estate,
-													  erm,
-													  datum,
-													  &updated);
 
-			if (copyTuple == NULL)
+			markSlot = fdwroutine->RefetchForeignRow(estate,
+													 erm,
+													 datum,
+													 markSlot,
+													 &updated);
+			if (markSlot == NULL)
 			{
 				/* couldn't get the lock, so skip this row */
 				goto lnext;
 			}
 
-			elog(ERROR, "frak: slotify");
-
-			/* save locked tuple for possible EvalPlanQual testing below */
-			//*testTuple = copyTuple;
-
 			/*
 			 * if FDW says tuple was updated before getting locked, we need to
 			 * perform EPQ testing to see if quals are still satisfied
diff --git a/src/include/foreign/fdwapi.h b/src/include/foreign/fdwapi.h
index c14eb546c6..508b0eece8 100644
--- a/src/include/foreign/fdwapi.h
+++ b/src/include/foreign/fdwapi.h
@@ -121,10 +121,11 @@ typedef void (*EndDirectModify_function) (ForeignScanState *node);
 typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
 													   LockClauseStrength strength);
 
-typedef HeapTuple (*RefetchForeignRow_function) (EState *estate,
-												 ExecRowMark *erm,
-												 Datum rowid,
-												 bool *updated);
+typedef TupleTableSlot *(*RefetchForeignRow_function) (EState *estate,
+													   ExecRowMark *erm,
+													   Datum rowid,
+													   TupleTableSlot *slot,
+													   bool *updated);
 
 typedef void (*ExplainForeignScan_function) (ForeignScanState *node,
 											 struct ExplainState *es);
-- 
2.18.0.windows.1

From 67018b04b7e11ec0f0644afbbd451f5fbaf0a6d6 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 29 Aug 2018 13:52:39 +1000
Subject: [PATCH 1/3] copy memory limit fix

To limit memory used by the COPY FROM because of slotification,
calculates the tuple size of the first tuple in the batch and
use that for remaining batch, so that it almost averages the
memory usage by the COPY command.
---
 src/backend/commands/copy.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index c9272b344a..a82389b1a8 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2314,6 +2314,7 @@ CopyFrom(CopyState cstate)
 
 #define MAX_BUFFERED_TUPLES 1000
 	TupleTableSlot  **bufferedSlots = NULL;	/* initialize to silence warning */
+	Size		bufferedSlotsSize = 0;
 	uint64		firstBufferedLineNo = 0;
 
 	Assert(cstate->rel);
@@ -2753,24 +2754,26 @@ CopyFrom(CopyState cstate)
 					/* Add this tuple to the tuple buffer */
 					if (nBufferedTuples == 0)
 						firstBufferedLineNo = cstate->cur_lineno;
+
 					Assert(bufferedSlots[nBufferedTuples] == myslot);
 					nBufferedTuples++;
+					bufferedSlotsSize += cstate->line_buf.len;
 
 					/*
 					 * If the buffer filled up, flush it.  Also flush if the
 					 * total size of all the tuples in the buffer becomes
 					 * large, to avoid using large amounts of memory for the
 					 * buffer when the tuples are exceptionally wide.
-					 *
-					 * PBORKED: Re-introduce size limit
 					 */
-					if (nBufferedTuples == MAX_BUFFERED_TUPLES)
+					if (nBufferedTuples == MAX_BUFFERED_TUPLES ||
+						bufferedSlotsSize > 65535)
 					{
 						CopyFromInsertBatch(cstate, estate, mycid, hi_options,
 											resultRelInfo, bistate,
 											nBufferedTuples, bufferedSlots,
 											firstBufferedLineNo);
 						nBufferedTuples = 0;
+						bufferedSlotsSize = 0;
 					}
 				}
 				else
-- 
2.18.0.windows.1

From 8b59dbc51a15fe769e29f22d5049fa42bf8eebfc Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 10 Sep 2018 17:20:56 +1000
Subject: [PATCH 3/3] CREATE AS USING method grammer support

This change was missed during earlier USING grammer support.
---
 src/backend/parser/gram.y     | 11 ++++++-----
 src/include/nodes/primnodes.h |  1 +
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 8f6f9ddae2..a9c5450a37 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -4038,7 +4038,6 @@ CreateStatsStmt:
  *
  *****************************************************************************/
 
-// PBORKED: storage option
 CreateAsStmt:
 		CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
 				{
@@ -4069,14 +4068,16 @@ CreateAsStmt:
 		;
 
 create_as_target:
-			qualified_name opt_column_list OptWith OnCommitOption OptTableSpace
+			qualified_name opt_column_list table_access_method_clause
+			OptWith OnCommitOption OptTableSpace
 				{
 					$$ = makeNode(IntoClause);
 					$$->rel = $1;
 					$$->colNames = $2;
-					$$->options = $3;
-					$$->onCommit = $4;
-					$$->tableSpaceName = $5;
+					$$->accessMethod = $3;
+					$$->options = $4;
+					$$->onCommit = $5;
+					$$->tableSpaceName = $6;
 					$$->viewQuery = NULL;
 					$$->skipData = false;		/* might get changed later */
 				}
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 1b4b0d75af..ffc788c4a3 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -108,6 +108,7 @@ typedef struct IntoClause
 
 	RangeVar   *rel;			/* target relation name */
 	List	   *colNames;		/* column names to assign, or NIL */
+	char	   *accessMethod;	/* table access method */
 	List	   *options;		/* options from WITH clause */
 	OnCommitAction onCommit;	/* what do we do at COMMIT? */
 	char	   *tableSpaceName; /* table space to use, or NULL */
-- 
2.18.0.windows.1

From b01172f17c561b89c79a88733241e020ecf946e3 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 5 Sep 2018 17:18:09 +1000
Subject: [PATCH 2/3] Remove of Bulk insert state API

Currently there is no requirement of exposing Bulk Insert state
APIs, as there is no use of it currently.
---
 src/backend/access/heap/heapam_handler.c |  4 ---
 src/backend/commands/copy.c              |  6 ++---
 src/backend/commands/createas.c          |  4 +--
 src/backend/commands/matview.c           |  4 +--
 src/backend/commands/tablecmds.c         |  4 +--
 src/include/access/tableam.h             | 32 ------------------------
 6 files changed, 9 insertions(+), 45 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 382148ff1d..2d5074734b 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1771,10 +1771,6 @@ static const TableAmRoutine heapam_methods = {
 	.relation_copy_for_cluster = heap_copy_for_cluster,
 	.relation_sync = heap_sync,
 
-	.getbulkinsertstate = GetBulkInsertState,
-	.freebulkinsertstate = FreeBulkInsertState,
-	.releasebulkinsertstate = ReleaseBulkInsertStatePin,
-
 	.begin_index_fetch = heapam_begin_index_fetch,
 	.reset_index_fetch = heapam_reset_index_fetch,
 	.end_index_fetch = heapam_end_index_fetch,
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index a82389b1a8..49e654e4ee 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -2546,7 +2546,7 @@ CopyFrom(CopyState cstate)
 	 */
 	ExecBSInsertTriggers(estate, resultRelInfo);
 
-	bistate = table_getbulkinsertstate(resultRelInfo->ri_RelationDesc);
+	bistate = GetBulkInsertState();
 	econtext = GetPerTupleExprContext(estate);
 
 	/* Set up callback to identify error line number */
@@ -2639,7 +2639,7 @@ CopyFrom(CopyState cstate)
 			 */
 			if (prev_leaf_part_index != leaf_part_index)
 			{
-				table_releasebulkinsertstate(resultRelInfo->ri_RelationDesc, bistate);
+				ReleaseBulkInsertStatePin(bistate);
 				prev_leaf_part_index = leaf_part_index;
 			}
 
@@ -2848,7 +2848,7 @@ next_tuple:
 	/* Done, clean up */
 	error_context_stack = errcallback.previous;
 
-	table_freebulkinsertstate(resultRelInfo->ri_RelationDesc, bistate);
+	FreeBulkInsertState(bistate);
 
 	MemoryContextSwitchTo(oldcontext);
 
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index f84ef0a65e..852c6becba 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -572,7 +572,7 @@ intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	 */
 	myState->hi_options = HEAP_INSERT_SKIP_FSM |
 		(XLogIsNeeded() ? 0 : HEAP_INSERT_SKIP_WAL);
-	myState->bistate = table_getbulkinsertstate(intoRelationDesc);
+	myState->bistate = GetBulkInsertState();
 
 	/* Not using WAL requires smgr_targblock be initially invalid */
 	Assert(RelationGetTargetBlock(intoRelationDesc) == InvalidBlockNumber);
@@ -611,7 +611,7 @@ intorel_shutdown(DestReceiver *self)
 {
 	DR_intorel *myState = (DR_intorel *) self;
 
-	table_freebulkinsertstate(myState->rel, myState->bistate);
+	FreeBulkInsertState(myState->bistate);
 
 	/* If we skipped using WAL, must heap_sync before commit */
 	if (myState->hi_options & HEAP_INSERT_SKIP_WAL)
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index 83ee2f725e..80828ed4a6 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -466,7 +466,7 @@ transientrel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	myState->hi_options = HEAP_INSERT_SKIP_FSM | HEAP_INSERT_FROZEN;
 	if (!XLogIsNeeded())
 		myState->hi_options |= HEAP_INSERT_SKIP_WAL;
-	myState->bistate = table_getbulkinsertstate(transientrel);
+	myState->bistate = GetBulkInsertState();
 
 	/* Not using WAL requires smgr_targblock be initially invalid */
 	Assert(RelationGetTargetBlock(transientrel) == InvalidBlockNumber);
@@ -499,7 +499,7 @@ transientrel_shutdown(DestReceiver *self)
 {
 	DR_transientrel *myState = (DR_transientrel *) self;
 
-	table_freebulkinsertstate(myState->transientrel, myState->bistate);
+	FreeBulkInsertState(myState->bistate);
 
 	/* If we skipped using WAL, must heap_sync before commit */
 	if (myState->hi_options & HEAP_INSERT_SKIP_WAL)
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index ff6e4486f0..d44d865ec7 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -4616,7 +4616,7 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 	if (newrel)
 	{
 		mycid = GetCurrentCommandId(true);
-		bistate = table_getbulkinsertstate(newrel);
+		bistate = GetBulkInsertState();
 
 		hi_options = HEAP_INSERT_SKIP_FSM;
 		if (!XLogIsNeeded())
@@ -4901,7 +4901,7 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 	heap_close(oldrel, NoLock);
 	if (newrel)
 	{
-		table_freebulkinsertstate(newrel, bistate);
+		FreeBulkInsertState(bistate);
 
 		/* If we skipped writing WAL, then we need to sync the heap. */
 		if (hi_options & HEAP_INSERT_SKIP_WAL)
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 6d50410166..5f6b39c0e0 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -125,10 +125,6 @@ typedef void (*RelationCopyForCluster_function)(Relation NewHeap, Relation OldHe
 
 typedef void (*RelationSync_function) (Relation relation);
 
-typedef BulkInsertState (*GetBulkInsertState_function) (void);
-typedef void (*FreeBulkInsertState_function) (BulkInsertState bistate);
-typedef void (*ReleaseBulkInsertState_function) (BulkInsertState bistate);
-
 typedef const TupleTableSlotOps* (*SlotCallbacks_function) (Relation relation);
 
 typedef TableScanDesc (*ScanBegin_function) (Relation relation,
@@ -217,10 +213,6 @@ typedef struct TableAmRoutine
 	RelationCopyForCluster_function relation_copy_for_cluster;
 	RelationSync_function relation_sync;
 
-	GetBulkInsertState_function getbulkinsertstate;
-	FreeBulkInsertState_function freebulkinsertstate;
-	ReleaseBulkInsertState_function releasebulkinsertstate;
-
 	/* Operations on relation scans */
 	ScanBegin_function scan_begin;
 	ScanSetlimits_function scansetlimits;
@@ -650,30 +642,6 @@ table_sync(Relation rel)
 	rel->rd_tableamroutine->relation_sync(rel);
 }
 
-/*
- * -------------------
- * storage Bulk Insert functions
- * -------------------
- */
-static inline BulkInsertState
-table_getbulkinsertstate(Relation rel)
-{
-	return rel->rd_tableamroutine->getbulkinsertstate();
-}
-
-static inline void
-table_freebulkinsertstate(Relation rel, BulkInsertState bistate)
-{
-	rel->rd_tableamroutine->freebulkinsertstate(bistate);
-}
-
-static inline void
-table_releasebulkinsertstate(Relation rel, BulkInsertState bistate)
-{
-	rel->rd_tableamroutine->releasebulkinsertstate(bistate);
-}
-
-
 static inline double
 table_index_build_scan(Relation heapRelation,
 					   Relation indexRelation,
-- 
2.18.0.windows.1

From 3a783b0e62c6f93eba808e6a3c6be3c479484a5d Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Fri, 28 Sep 2018 11:25:07 +1000
Subject: [PATCH 3/3] validate index scan hook addition

Slotify the validate index is having problems as it tries to access
the buffer stored in the scandesc, so made a callback to get the
control from back.

This may needs further visit as the callback may need further
abstraction
---
 src/backend/access/heap/heapam_handler.c | 243 ++++++++++++++++-
 src/backend/catalog/index.c              | 318 +++--------------------
 src/include/access/tableam.h             |  27 ++
 src/include/catalog/index.h              |  48 ++++
 4 files changed, 352 insertions(+), 284 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 2d5074734b..ee8a658c6d 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1120,6 +1120,246 @@ IndexBuildHeapRangeScan(Relation heapRelation,
 	return reltuples;
 }
 
+/*
+ * validate_index_heapscan - second table scan for concurrent index build
+ *
+ * This has much code in common with IndexBuildHeapScan, but it's enough
+ * different that it seems cleaner to have two routines not one.
+ */
+static uint64
+validate_index_heapscan(Relation heapRelation,
+						Relation indexRelation,
+						IndexInfo *indexInfo,
+						Snapshot snapshot,
+						Tuplesortstate *tuplesort,
+						IndexValidateCallback callback,
+						void *callback_state)
+{
+	TableScanDesc sscan;
+	HeapScanDesc scan;
+	HeapTuple	heapTuple;
+	Datum		values[INDEX_MAX_KEYS];
+	bool		isnull[INDEX_MAX_KEYS];
+	ExprState  *predicate;
+	TupleTableSlot *slot;
+	EState	   *estate;
+	ExprContext *econtext;
+	BlockNumber root_blkno = InvalidBlockNumber;
+	OffsetNumber root_offsets[MaxHeapTuplesPerPage];
+	bool		in_index[MaxHeapTuplesPerPage];
+
+	/* state variables for the merge */
+	ItemPointer indexcursor = NULL;
+	ItemPointerData decoded;
+	bool		tuplesort_empty = false;
+	uint64 		nhtups = 0;
+
+	/*
+	 * sanity checks
+	 */
+	Assert(OidIsValid(indexRelation->rd_rel->relam));
+
+	/*
+	 * Need an EState for evaluation of index expressions and partial-index
+	 * predicates.  Also a slot to hold the current tuple.
+	 */
+	estate = CreateExecutorState();
+	econtext = GetPerTupleExprContext(estate);
+	slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
+									&TTSOpsHeapTuple);
+
+	/* Arrange for econtext's scan tuple to be the tuple under test */
+	econtext->ecxt_scantuple = slot;
+
+	/* Set up execution state for predicate, if any. */
+	predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
+
+	/*
+	 * Prepare for scan of the base relation.  We need just those tuples
+	 * satisfying the passed-in reference snapshot.  We must disable syncscan
+	 * here, because it's critical that we read from block zero forward to
+	 * match the sorted TIDs.
+	 */
+	sscan = heap_beginscan(heapRelation,	/* relation */
+						  snapshot,	/* snapshot */
+						  0,	/* number of keys */
+						  NULL,	/* scan key */
+						  NULL,
+						  true,	/* buffer access strategy OK */
+						  false,	/* syncscan not OK */
+						  true,
+						  false,
+						  false,
+						  false);
+
+	scan = (HeapScanDesc)sscan;
+
+	/*
+	 * Scan all tuples matching the snapshot.
+	 */
+	while ((heapTuple = heap_getnext(sscan, ForwardScanDirection)) != NULL)
+	{
+		ItemPointer heapcursor = &heapTuple->t_self;
+		ItemPointerData rootTuple;
+		OffsetNumber root_offnum;
+
+		CHECK_FOR_INTERRUPTS();
+
+		nhtups += 1;
+
+		/*
+		 * As commented in IndexBuildHeapScan, we should index heap-only
+		 * tuples under the TIDs of their root tuples; so when we advance onto
+		 * a new heap page, build a map of root item offsets on the page.
+		 *
+		 * This complicates merging against the tuplesort output: we will
+		 * visit the live tuples in order by their offsets, but the root
+		 * offsets that we need to compare against the index contents might be
+		 * ordered differently.  So we might have to "look back" within the
+		 * tuplesort output, but only within the current page.  We handle that
+		 * by keeping a bool array in_index[] showing all the
+		 * already-passed-over tuplesort output TIDs of the current page. We
+		 * clear that array here, when advancing onto a new heap page.
+		 */
+		if (scan->rs_cblock != root_blkno)
+		{
+			Page		page = BufferGetPage(scan->rs_cbuf);
+
+			LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
+			heap_get_root_tuples(page, root_offsets);
+			LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+
+			memset(in_index, 0, sizeof(in_index));
+
+			root_blkno = scan->rs_cblock;
+		}
+
+		/* Convert actual tuple TID to root TID */
+		rootTuple = *heapcursor;
+		root_offnum = ItemPointerGetOffsetNumber(heapcursor);
+
+		if (HeapTupleIsHeapOnly(heapTuple))
+		{
+			root_offnum = root_offsets[root_offnum - 1];
+			if (!OffsetNumberIsValid(root_offnum))
+				ereport(ERROR,
+						(errcode(ERRCODE_DATA_CORRUPTED),
+						 errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
+										 ItemPointerGetBlockNumber(heapcursor),
+										 ItemPointerGetOffsetNumber(heapcursor),
+										 RelationGetRelationName(heapRelation))));
+			ItemPointerSetOffsetNumber(&rootTuple, root_offnum);
+		}
+
+		/*
+		 * "merge" by skipping through the index tuples until we find or pass
+		 * the current root tuple.
+		 */
+		while (!tuplesort_empty &&
+			   (!indexcursor ||
+				ItemPointerCompare(indexcursor, &rootTuple) < 0))
+		{
+			Datum		ts_val;
+			bool		ts_isnull;
+
+			if (indexcursor)
+			{
+				/*
+				 * Remember index items seen earlier on the current heap page
+				 */
+				if (ItemPointerGetBlockNumber(indexcursor) == root_blkno)
+					in_index[ItemPointerGetOffsetNumber(indexcursor) - 1] = true;
+			}
+
+			tuplesort_empty = !tuplesort_getdatum(tuplesort, true,
+												  &ts_val, &ts_isnull, NULL);
+			Assert(tuplesort_empty || !ts_isnull);
+			if (!tuplesort_empty)
+			{
+				itemptr_decode(&decoded, DatumGetInt64(ts_val));
+				indexcursor = &decoded;
+
+				/* If int8 is pass-by-ref, free (encoded) TID Datum memory */
+#ifndef USE_FLOAT8_BYVAL
+				pfree(DatumGetPointer(ts_val));
+#endif
+			}
+			else
+			{
+				/* Be tidy */
+				indexcursor = NULL;
+			}
+		}
+
+		/*
+		 * If the tuplesort has overshot *and* we didn't see a match earlier,
+		 * then this tuple is missing from the index, so insert it.
+		 */
+		if ((tuplesort_empty ||
+			 ItemPointerCompare(indexcursor, &rootTuple) > 0) &&
+			!in_index[root_offnum - 1])
+		{
+			MemoryContextReset(econtext->ecxt_per_tuple_memory);
+
+			/* Set up for predicate or expression evaluation */
+			ExecStoreHeapTuple(heapTuple, slot, false);
+
+			/*
+			 * In a partial index, discard tuples that don't satisfy the
+			 * predicate.
+			 */
+			if (predicate != NULL)
+			{
+				if (!ExecQual(predicate, econtext))
+					continue;
+			}
+
+			/*
+			 * For the current heap tuple, extract all the attributes we use
+			 * in this index, and note which are null.  This also performs
+			 * evaluation of any expressions needed.
+			 */
+			FormIndexDatum(indexInfo,
+						   slot,
+						   estate,
+						   values,
+						   isnull);
+
+			/*
+			 * You'd think we should go ahead and build the index tuple here,
+			 * but some index AMs want to do further processing on the data
+			 * first. So pass the values[] and isnull[] arrays, instead.
+			 */
+
+			/*
+			 * If the tuple is already committed dead, you might think we
+			 * could suppress uniqueness checking, but this is no longer true
+			 * in the presence of HOT, because the insert is actually a proxy
+			 * for a uniqueness check on the whole HOT-chain.  That is, the
+			 * tuple we have here could be dead because it was already
+			 * HOT-updated, and if so the updating transaction will not have
+			 * thought it should insert index entries.  The index AM will
+			 * check the whole HOT-chain and correctly detect a conflict if
+			 * there is one.
+			 */
+
+			callback(indexRelation, values, isnull, &rootTuple, heapRelation,
+							indexInfo, callback_state);
+		}
+	}
+
+	table_endscan(sscan);
+
+	ExecDropSingleTupleTableSlot(slot);
+
+	FreeExecutorState(estate);
+
+	/* These may have been pointing to the now-gone estate */
+	indexInfo->ii_ExpressionsState = NIL;
+	indexInfo->ii_PredicateState = NULL;
+
+	return nhtups;
+}
 
 static bool
 heapam_scan_bitmap_pagescan(TableScanDesc sscan,
@@ -1775,7 +2015,8 @@ static const TableAmRoutine heapam_methods = {
 	.reset_index_fetch = heapam_reset_index_fetch,
 	.end_index_fetch = heapam_end_index_fetch,
 
-	.index_build_range_scan = IndexBuildHeapRangeScan
+	.index_build_range_scan = IndexBuildHeapRangeScan,
+	.validate_index_scan = validate_index_heapscan
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 2fe66972a1..a0096e60ca 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -81,7 +81,7 @@
 /* Potentially set by pg_upgrade_support functions */
 Oid			binary_upgrade_next_index_pg_class_oid = InvalidOid;
 
-/* state info for validate_index bulkdelete callback */
+/*  state info for validate_index bulkdelete callback */
 typedef struct
 {
 	Tuplesortstate *tuplesort;	/* for sorting the index TIDs */
@@ -134,11 +134,13 @@ static void IndexCheckExclusion(Relation heapRelation,
 static inline int64 itemptr_encode(ItemPointer itemptr);
 static inline void itemptr_decode(ItemPointer itemptr, int64 encoded);
 static bool validate_index_callback(ItemPointer itemptr, void *opaque);
-static void validate_index_heapscan(Relation heapRelation,
-						Relation indexRelation,
-						IndexInfo *indexInfo,
-						Snapshot snapshot,
-						v_i_state *state);
+static void validate_index_scan_callbck(Relation indexRelation,
+					Datum *values,
+					bool *isnull,
+					ItemPointer rootTuple,
+					Relation heapRelation,
+					IndexInfo *indexInfo,
+					void *opaque);
 static bool ReindexIsCurrentlyProcessingIndex(Oid indexOid);
 static void SetReindexProcessing(Oid heapOid, Oid indexOid);
 static void ResetReindexProcessing(void);
@@ -2638,11 +2640,13 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot)
 	/*
 	 * Now scan the heap and "merge" it with the index
 	 */
-	validate_index_heapscan(heapRelation,
-							indexRelation,
-							indexInfo,
-							snapshot,
-							&state);
+	state.htups = table_validate_index(heapRelation,
+									   indexRelation,
+									   indexInfo,
+									   snapshot,
+									   state.tuplesort,
+									   validate_index_scan_callbck,
+									   &state);
 
 	/* Done with tuplesort object */
 	tuplesort_end(state.tuplesort);
@@ -2662,45 +2666,6 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot)
 	heap_close(heapRelation, NoLock);
 }
 
-/*
- * itemptr_encode - Encode ItemPointer as int64/int8
- *
- * This representation must produce values encoded as int64 that sort in the
- * same order as their corresponding original TID values would (using the
- * default int8 opclass to produce a result equivalent to the default TID
- * opclass).
- *
- * As noted in validate_index(), this can be significantly faster.
- */
-static inline int64
-itemptr_encode(ItemPointer itemptr)
-{
-	BlockNumber block = ItemPointerGetBlockNumber(itemptr);
-	OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
-	int64		encoded;
-
-	/*
-	 * Use the 16 least significant bits for the offset.  32 adjacent bits are
-	 * used for the block number.  Since remaining bits are unused, there
-	 * cannot be negative encoded values (We assume a two's complement
-	 * representation).
-	 */
-	encoded = ((uint64) block << 16) | (uint16) offset;
-
-	return encoded;
-}
-
-/*
- * itemptr_decode - Decode int64/int8 representation back to ItemPointer
- */
-static inline void
-itemptr_decode(ItemPointer itemptr, int64 encoded)
-{
-	BlockNumber block = (BlockNumber) (encoded >> 16);
-	OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
-
-	ItemPointerSet(itemptr, block, offset);
-}
 
 /*
  * validate_index_callback - bulkdelete callback to collect the index TIDs
@@ -2717,242 +2682,29 @@ validate_index_callback(ItemPointer itemptr, void *opaque)
 }
 
 /*
- * validate_index_heapscan - second table scan for concurrent index build
- *
- * This has much code in common with IndexBuildHeapScan, but it's enough
- * different that it seems cleaner to have two routines not one.
+ * validate_index_scan_callbck - callback to insert into the index
  */
 static void
-validate_index_heapscan(Relation heapRelation,
-						Relation indexRelation,
-						IndexInfo *indexInfo,
-						Snapshot snapshot,
-						v_i_state *state)
+validate_index_scan_callbck(Relation indexRelation,
+							Datum *values,
+							bool *isnull,
+							ItemPointer rootTuple,
+							Relation heapRelation,
+							IndexInfo *indexInfo,
+							void *opaque)
 {
-	TableScanDesc sscan;
-	HeapScanDesc scan;
-	HeapTuple	heapTuple;
-	Datum		values[INDEX_MAX_KEYS];
-	bool		isnull[INDEX_MAX_KEYS];
-	ExprState  *predicate;
-	TupleTableSlot *slot;
-	EState	   *estate;
-	ExprContext *econtext;
-	BlockNumber root_blkno = InvalidBlockNumber;
-	OffsetNumber root_offsets[MaxHeapTuplesPerPage];
-	bool		in_index[MaxHeapTuplesPerPage];
-
-	/* state variables for the merge */
-	ItemPointer indexcursor = NULL;
-	ItemPointerData decoded;
-	bool		tuplesort_empty = false;
-
-	/*
-	 * sanity checks
-	 */
-	Assert(OidIsValid(indexRelation->rd_rel->relam));
-
-	/*
-	 * Need an EState for evaluation of index expressions and partial-index
-	 * predicates.  Also a slot to hold the current tuple.
-	 */
-	estate = CreateExecutorState();
-	econtext = GetPerTupleExprContext(estate);
-	slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
-									&TTSOpsHeapTuple);
-
-	/* Arrange for econtext's scan tuple to be the tuple under test */
-	econtext->ecxt_scantuple = slot;
-
-	/* Set up execution state for predicate, if any. */
-	predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
-
-	/*
-	 * Prepare for scan of the base relation.  We need just those tuples
-	 * satisfying the passed-in reference snapshot.  We must disable syncscan
-	 * here, because it's critical that we read from block zero forward to
-	 * match the sorted TIDs.
-	 */
-	sscan = table_beginscan_strat(heapRelation,	/* relation */
-								   snapshot,	/* snapshot */
-								   0,	/* number of keys */
-								   NULL,	/* scan key */
-								   true,	/* buffer access strategy OK */
-								   false);	/* syncscan not OK */
-	scan = (HeapScanDesc) sscan;
-
-	/*
-	 * Scan all tuples matching the snapshot.
-	 */
-	// PBORKED: slotify
-	while ((heapTuple = heap_scan_getnext(sscan, ForwardScanDirection)) != NULL)
-	{
-		ItemPointer heapcursor = &heapTuple->t_self;
-		ItemPointerData rootTuple;
-		OffsetNumber root_offnum;
-
-		CHECK_FOR_INTERRUPTS();
-
-		state->htups += 1;
-
-		/*
-		 * As commented in IndexBuildHeapScan, we should index heap-only
-		 * tuples under the TIDs of their root tuples; so when we advance onto
-		 * a new heap page, build a map of root item offsets on the page.
-		 *
-		 * This complicates merging against the tuplesort output: we will
-		 * visit the live tuples in order by their offsets, but the root
-		 * offsets that we need to compare against the index contents might be
-		 * ordered differently.  So we might have to "look back" within the
-		 * tuplesort output, but only within the current page.  We handle that
-		 * by keeping a bool array in_index[] showing all the
-		 * already-passed-over tuplesort output TIDs of the current page. We
-		 * clear that array here, when advancing onto a new heap page.
-		 */
-		if (scan->rs_cblock != root_blkno)
-		{
-			Page		page = BufferGetPage(scan->rs_cbuf);
-
-			LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
-			heap_get_root_tuples(page, root_offsets);
-			LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
-
-			memset(in_index, 0, sizeof(in_index));
-
-			root_blkno = scan->rs_cblock;
-		}
-
-		/* Convert actual tuple TID to root TID */
-		rootTuple = *heapcursor;
-		root_offnum = ItemPointerGetOffsetNumber(heapcursor);
-
-		if (HeapTupleIsHeapOnly(heapTuple))
-		{
-			root_offnum = root_offsets[root_offnum - 1];
-			if (!OffsetNumberIsValid(root_offnum))
-				ereport(ERROR,
-						(errcode(ERRCODE_DATA_CORRUPTED),
-						 errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
-										 ItemPointerGetBlockNumber(heapcursor),
-										 ItemPointerGetOffsetNumber(heapcursor),
-										 RelationGetRelationName(heapRelation))));
-			ItemPointerSetOffsetNumber(&rootTuple, root_offnum);
-		}
-
-		/*
-		 * "merge" by skipping through the index tuples until we find or pass
-		 * the current root tuple.
-		 */
-		while (!tuplesort_empty &&
-			   (!indexcursor ||
-				ItemPointerCompare(indexcursor, &rootTuple) < 0))
-		{
-			Datum		ts_val;
-			bool		ts_isnull;
-
-			if (indexcursor)
-			{
-				/*
-				 * Remember index items seen earlier on the current heap page
-				 */
-				if (ItemPointerGetBlockNumber(indexcursor) == root_blkno)
-					in_index[ItemPointerGetOffsetNumber(indexcursor) - 1] = true;
-			}
-
-			tuplesort_empty = !tuplesort_getdatum(state->tuplesort, true,
-												  &ts_val, &ts_isnull, NULL);
-			Assert(tuplesort_empty || !ts_isnull);
-			if (!tuplesort_empty)
-			{
-				itemptr_decode(&decoded, DatumGetInt64(ts_val));
-				indexcursor = &decoded;
-
-				/* If int8 is pass-by-ref, free (encoded) TID Datum memory */
-#ifndef USE_FLOAT8_BYVAL
-				pfree(DatumGetPointer(ts_val));
-#endif
-			}
-			else
-			{
-				/* Be tidy */
-				indexcursor = NULL;
-			}
-		}
-
-		/*
-		 * If the tuplesort has overshot *and* we didn't see a match earlier,
-		 * then this tuple is missing from the index, so insert it.
-		 */
-		if ((tuplesort_empty ||
-			 ItemPointerCompare(indexcursor, &rootTuple) > 0) &&
-			!in_index[root_offnum - 1])
-		{
-			MemoryContextReset(econtext->ecxt_per_tuple_memory);
-
-			/* Set up for predicate or expression evaluation */
-			ExecStoreHeapTuple(heapTuple, slot, false);
-
-			/*
-			 * In a partial index, discard tuples that don't satisfy the
-			 * predicate.
-			 */
-			if (predicate != NULL)
-			{
-				if (!ExecQual(predicate, econtext))
-					continue;
-			}
-
-			/*
-			 * For the current heap tuple, extract all the attributes we use
-			 * in this index, and note which are null.  This also performs
-			 * evaluation of any expressions needed.
-			 */
-			FormIndexDatum(indexInfo,
-						   slot,
-						   estate,
-						   values,
-						   isnull);
-
-			/*
-			 * You'd think we should go ahead and build the index tuple here,
-			 * but some index AMs want to do further processing on the data
-			 * first. So pass the values[] and isnull[] arrays, instead.
-			 */
-
-			/*
-			 * If the tuple is already committed dead, you might think we
-			 * could suppress uniqueness checking, but this is no longer true
-			 * in the presence of HOT, because the insert is actually a proxy
-			 * for a uniqueness check on the whole HOT-chain.  That is, the
-			 * tuple we have here could be dead because it was already
-			 * HOT-updated, and if so the updating transaction will not have
-			 * thought it should insert index entries.  The index AM will
-			 * check the whole HOT-chain and correctly detect a conflict if
-			 * there is one.
-			 */
-
-			index_insert(indexRelation,
-						 values,
-						 isnull,
-						 &rootTuple,
-						 heapRelation,
-						 indexInfo->ii_Unique ?
-						 UNIQUE_CHECK_YES : UNIQUE_CHECK_NO,
-						 indexInfo);
-
-			state->tups_inserted += 1;
-		}
-	}
-
-	table_endscan(sscan);
-
-	ExecDropSingleTupleTableSlot(slot);
-
-	FreeExecutorState(estate);
-
-	/* These may have been pointing to the now-gone estate */
-	indexInfo->ii_ExpressionsState = NIL;
-	indexInfo->ii_PredicateState = NULL;
+	v_i_state *state = (v_i_state *)opaque;
+
+	index_insert(indexRelation,
+				 values,
+				 isnull,
+				 rootTuple,
+				 heapRelation,
+				 indexInfo->ii_Unique ?
+				 UNIQUE_CHECK_YES : UNIQUE_CHECK_NO,
+				 indexInfo);
+
+	state->tups_inserted += 1;
 }
 
 
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 691f687ade..27bf57a486 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -173,6 +173,14 @@ typedef double (*IndexBuildRangeScan_function)(Relation heapRelation,
 											   void *callback_state,
 											   TableScanDesc scan);
 
+typedef uint64 (*ValidateIndexscan_function)(Relation heapRelation,
+									   Relation indexRelation,
+									   IndexInfo *indexInfo,
+									   Snapshot snapshot,
+									   Tuplesortstate *tuplesort,
+									   IndexValidateCallback callback,
+									   void *callback_state);
+
 typedef bool (*BitmapPagescan_function)(TableScanDesc scan,
 										TBMIterateResult *tbmres);
 
@@ -236,6 +244,7 @@ typedef struct TableAmRoutine
 
 
 	IndexBuildRangeScan_function index_build_range_scan;
+	ValidateIndexscan_function validate_index_scan;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -691,6 +700,24 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline uint64
+table_validate_index(Relation heapRelation,
+					 Relation indexRelation,
+					 IndexInfo *indexInfo,
+					 Snapshot snapshot,
+					 Tuplesortstate *tuplesort,
+					 IndexValidateCallback callback,
+					 void *callback_state)
+{
+	return heapRelation->rd_tableamroutine->validate_index_scan(heapRelation,
+			indexRelation,
+			indexInfo,
+			snapshot,
+			tuplesort,
+			callback,
+			callback_state);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index 376907b616..874e956c8e 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -28,6 +28,15 @@ typedef void (*IndexBuildCallback) (Relation index,
 									bool tupleIsAlive,
 									void *state);
 
+/* Typedef for callback function for table_validate_index_scan */
+typedef void (*IndexValidateCallback) (Relation indexRelation,
+									   Datum *values,
+									   bool *isnull,
+									   ItemPointer heap_t_ctid,
+									   Relation heapRelation,
+									   IndexInfo *indexInfo,
+									   void *state);
+
 /* Action code for index_set_state_flags */
 typedef enum
 {
@@ -37,6 +46,45 @@ typedef enum
 	INDEX_DROP_SET_DEAD
 } IndexStateFlagsAction;
 
+/*
+ * itemptr_encode - Encode ItemPointer as int64/int8
+ *
+ * This representation must produce values encoded as int64 that sort in the
+ * same order as their corresponding original TID values would (using the
+ * default int8 opclass to produce a result equivalent to the default TID
+ * opclass).
+ *
+ * As noted in validate_index(), this can be significantly faster.
+ */
+static inline int64
+itemptr_encode(ItemPointer itemptr)
+{
+	BlockNumber block = ItemPointerGetBlockNumber(itemptr);
+	OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
+	int64		encoded;
+
+	/*
+	 * Use the 16 least significant bits for the offset.  32 adjacent bits are
+	 * used for the block number.  Since remaining bits are unused, there
+	 * cannot be negative encoded values (We assume a two's complement
+	 * representation).
+	 */
+	encoded = ((uint64) block << 16) | (uint16) offset;
+
+	return encoded;
+}
+
+/*
+ * itemptr_decode - Decode int64/int8 representation back to ItemPointer
+ */
+static inline void
+itemptr_decode(ItemPointer itemptr, int64 encoded)
+{
+	BlockNumber block = (BlockNumber) (encoded >> 16);
+	OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
+
+	ItemPointerSet(itemptr, block, offset);
+}
 
 extern void index_check_primary_key(Relation heapRel,
 						IndexInfo *indexInfo,
-- 
2.18.0.windows.1

From 02340b6422a324eddbaa096fbeef95ed3a4cd6df Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 27 Sep 2018 15:54:10 +1000
Subject: [PATCH 1/3] Movting GUC variable declartion to proper place

---
 src/backend/access/heap/heapam.c   | 3 ---
 src/backend/access/table/tableam.c | 6 ++----
 src/include/access/tableam.h       | 1 +
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 6d516ccc0b..bff7049214 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -80,9 +80,6 @@
 #include "nodes/execnodes.h"
 #include "executor/executor.h"
 
-/* GUC variable */
-bool		synchronize_seqscans = true;
-
 static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
 					TransactionId xid, CommandId cid, int options);
 static XLogRecPtr log_heap_update(Relation reln, Buffer oldbuf,
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 96c5325ddb..af99264df9 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -15,10 +15,8 @@
 #include "storage/bufmgr.h"
 #include "storage/shmem.h"
 
-
-// PBORKED: move to header
-extern bool synchronize_seqscans;
-
+/* GUC variable */
+bool		synchronize_seqscans = true;
 
 char *default_table_access_method = DEFAULT_TABLE_ACCESS_METHOD;
 
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 5f6b39c0e0..d0a5f59aa9 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -48,6 +48,7 @@ typedef enum tuple_data_flags
 }			tuple_data_flags;
 
 extern char *default_table_access_method;
+extern bool synchronize_seqscans;
 
 /*
  * Storage routine function hooks
-- 
2.18.0.windows.1

From 8df9ac913811220bbcbfefa57e2204362c481cb9 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 27 Sep 2018 15:54:49 +1000
Subject: [PATCH 2/3] check_default_table_access_method hook to verify the
 access method

---
 src/backend/access/table/tableamapi.c | 88 +++++++++++++++++++++++++++
 src/backend/utils/misc/guc.c          |  3 +-
 src/include/access/tableam.h          |  4 ++
 3 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/table/tableamapi.c b/src/backend/access/table/tableamapi.c
index 7f08500ef4..d4eb889bd2 100644
--- a/src/backend/access/table/tableamapi.c
+++ b/src/backend/access/table/tableamapi.c
@@ -14,11 +14,14 @@
 
 #include "access/htup_details.h"
 #include "access/tableam.h"
+#include "access/xact.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_proc.h"
+#include "utils/fmgroids.h"
 #include "utils/syscache.h"
 #include "utils/memutils.h"
 
+static Oid get_table_am_oid(const char *tableamname, bool missing_ok);
 
 TupleTableSlot*
 table_gimmegimmeslot(Relation relation, List **reglist)
@@ -97,3 +100,88 @@ GetTableAmRoutineByAmId(Oid amoid)
 	/* And finally, call the handler function to get the API struct. */
 	return GetTableAmRoutine(amhandler);
 }
+
+/*
+ * get_table_am_oid - given a table access method name, look up the OID
+ *
+ * If missing_ok is false, throw an error if table access method name not
+ * found. If true, just return InvalidOid.
+ */
+static Oid
+get_table_am_oid(const char *tableamname, bool missing_ok)
+{
+	Oid			result;
+	Relation	rel;
+	TableScanDesc scandesc;
+	HeapTuple	tuple;
+	ScanKeyData entry[1];
+
+	/*
+	 * Search pg_tablespace.  We use a heapscan here even though there is an
+	 * index on name, on the theory that pg_tablespace will usually have just
+	 * a few entries and so an indexed lookup is a waste of effort.
+	 */
+	rel = heap_open(AccessMethodRelationId, AccessShareLock);
+
+	ScanKeyInit(&entry[0],
+				Anum_pg_am_amname,
+				BTEqualStrategyNumber, F_NAMEEQ,
+				CStringGetDatum(tableamname));
+	scandesc = table_beginscan_catalog(rel, 1, entry);
+	tuple = heap_scan_getnext(scandesc, ForwardScanDirection);
+
+	/* We assume that there can be at most one matching tuple */
+	if (HeapTupleIsValid(tuple) &&
+			((Form_pg_am) GETSTRUCT(tuple))->amtype == AMTYPE_TABLE)
+		result = HeapTupleGetOid(tuple);
+	else
+		result = InvalidOid;
+
+	table_endscan(scandesc);
+	heap_close(rel, AccessShareLock);
+
+	if (!OidIsValid(result) && !missing_ok)
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("table access method \"%s\" does not exist",
+						 tableamname)));
+
+	return result;
+}
+
+/* check_hook: validate new default_table_access_method */
+bool
+check_default_table_access_method(char **newval, void **extra, GucSource source)
+{
+	/*
+	 * If we aren't inside a transaction, we cannot do database access so
+	 * cannot verify the name.  Must accept the value on faith.
+	 */
+	if (IsTransactionState())
+	{
+		if (**newval != '\0' &&
+			!OidIsValid(get_table_am_oid(*newval, true)))
+		{
+			/*
+			 * When source == PGC_S_TEST, don't throw a hard error for a
+			 * nonexistent table access method, only a NOTICE.
+			 * See comments in guc.h.
+			 */
+			if (source == PGC_S_TEST)
+			{
+				ereport(NOTICE,
+						(errcode(ERRCODE_UNDEFINED_OBJECT),
+						 errmsg("Table access method \"%s\" does not exist",
+								*newval)));
+			}
+			else
+			{
+				GUC_check_errdetail("Table access method \"%s\" does not exist.",
+									*newval);
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 3b996c8088..94b135a48b 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -3336,8 +3336,7 @@ static struct config_string ConfigureNamesString[] =
 		},
 		&default_table_access_method,
 		DEFAULT_TABLE_ACCESS_METHOD,
-		/* PBORKED: a check hook would be good */
-		NULL, NULL, NULL
+		check_default_table_access_method, NULL, NULL
 	},
 
 	{
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index d0a5f59aa9..691f687ade 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -23,6 +23,7 @@
 #include "nodes/execnodes.h"
 #include "nodes/nodes.h"
 #include "fmgr.h"
+#include "utils/guc.h"
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
 #include "utils/snapshot.h"
@@ -714,4 +715,7 @@ extern const TableAmRoutine * GetTableAmRoutine(Oid amhandler);
 extern const TableAmRoutine * GetTableAmRoutineByAmId(Oid amoid);
 extern const TableAmRoutine * GetHeapamTableAmRoutine(void);
 
+extern bool check_default_table_access_method(char **newval, void **extra,
+									GucSource source);
+
 #endif		/* TABLEAM_H */
-- 
2.18.0.windows.1

From 3f1340364236b22f5a2b505e359083494b276b95 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 8 Oct 2018 15:08:59 +1100
Subject: [PATCH 2/2] init fork API

API to create INIT_FORKNUM file with wrapper
table_create_init_fork.
---
 src/backend/access/heap/heapam_handler.c | 26 +++++++++++++++++++++++-
 src/backend/catalog/heap.c               | 24 ++--------------------
 src/backend/commands/tablecmds.c         |  4 ++--
 src/include/access/tableam.h             |  8 ++++++++
 src/include/catalog/heap.h               |  2 --
 5 files changed, 37 insertions(+), 27 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 313ed319fc..87d3331ba1 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -33,6 +33,7 @@
 #include "catalog/indexing.h"
 #include "catalog/pg_am_d.h"
 #include "catalog/storage.h"
+#include "catalog/storage_xlog.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
@@ -2240,6 +2241,28 @@ RelationSetNewRelfilenode(Relation relation, char persistence,
 	EOXactListAdd(relation);
 }
 
+/*
+ * Set up an init fork for an unlogged table so that it can be correctly
+ * reinitialized on restart.  An immediate sync is required even if the
+ * page has been logged, because the write did not go through
+ * shared_buffers and therefore a concurrent checkpoint may have moved
+ * the redo pointer past our xlog record.  Recovery may as well remove it
+ * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
+ * record. Therefore, logging is necessary even if wal_level=minimal.
+ */
+static void
+heap_create_init_fork(Relation rel)
+{
+	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
+		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
+		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
+	RelationOpenSmgr(rel);
+	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
+	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
+	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
+}
+
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2289,7 +2312,8 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_validate_scan = validate_index_heapscan,
 
-	.SetNewFileNode = RelationSetNewRelfilenode
+	.SetNewFileNode = RelationSetNewRelfilenode,
+	.CreateInitFork = heap_create_init_fork
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 38b368f916..8e7c8ce684 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -32,6 +32,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/sysattr.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -1425,7 +1426,7 @@ heap_create_with_catalog(const char *relname,
 	 */
 	if (relpersistence == RELPERSISTENCE_UNLOGGED &&
 		relkind != RELKIND_PARTITIONED_TABLE)
-		heap_create_init_fork(new_rel_desc);
+		table_create_init_fork(new_rel_desc);
 
 	/*
 	 * ok, the relation has been cataloged, so close our relations and return
@@ -1437,27 +1438,6 @@ heap_create_with_catalog(const char *relname,
 	return relid;
 }
 
-/*
- * Set up an init fork for an unlogged table so that it can be correctly
- * reinitialized on restart.  An immediate sync is required even if the
- * page has been logged, because the write did not go through
- * shared_buffers and therefore a concurrent checkpoint may have moved
- * the redo pointer past our xlog record.  Recovery may as well remove it
- * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
- * record. Therefore, logging is necessary even if wal_level=minimal.
- */
-void
-heap_create_init_fork(Relation rel)
-{
-	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
-		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
-		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
-	RelationOpenSmgr(rel);
-	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
-	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
-	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
-}
-
 /*
  *		RelationRemoveInheritance
  *
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 6db214309e..e107afc786 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1647,7 +1647,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			table_set_new_filenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-				heap_create_init_fork(rel);
+				table_create_init_fork(rel);
 
 			heap_relid = RelationGetRelid(rel);
 			toast_relid = rel->rd_rel->reltoastrelid;
@@ -1661,7 +1661,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 				table_set_new_filenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-					heap_create_init_fork(rel);
+					table_create_init_fork(rel);
 				heap_close(rel, NoLock);
 			}
 
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 4d5b11c294..f3e36368db 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -196,6 +196,7 @@ typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleSc
 
 typedef void (*SetNewFileNode_function)(Relation relation, char persistence,
 										TransactionId freezeXid, MultiXactId minmulti);
+typedef void (*CreateInitFork_function)(Relation rel);
 
 /*
  * API struct for a table AM.  Note this must be allocated in a
@@ -255,6 +256,7 @@ typedef struct TableAmRoutine
 	IndexValidateScan_function index_validate_scan;
 
 	SetNewFileNode_function	SetNewFileNode;
+	CreateInitFork_function CreateInitFork;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -754,6 +756,12 @@ table_set_new_filenode(Relation relation, char persistence,
 									freezeXid, minmulti);
 }
 
+static inline void
+table_create_init_fork(Relation relation)
+{
+	relation->rd_tableamroutine->CreateInitFork(relation);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index 4584b3473c..c0e706ecc9 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -77,8 +77,6 @@ extern Oid heap_create_with_catalog(const char *relname,
 						 Oid relrewrite,
 						 ObjectAddress *typaddress);
 
-extern void heap_create_init_fork(Relation rel);
-
 extern void heap_drop_with_catalog(Oid relid);
 
 extern void heap_truncate(List *relids);
-- 
2.18.0.windows.1

From d8489cf06b9cd186f5dac801879e604bb330f79a Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 8 Oct 2018 14:33:49 +1100
Subject: [PATCH 1/2] New API setNewfilenode

This API can be used to set the filenode of a relation.
The wrapper function for this API is table_set_new_filenode,
using of it for sequence and index to create storage. The
wrapper function name can be updated if required.
---
 src/backend/access/heap/heapam_handler.c | 128 ++++++++++++++++++++-
 src/backend/catalog/index.c              |   2 +-
 src/backend/commands/sequence.c          |   5 +-
 src/backend/commands/tablecmds.c         |   6 +-
 src/backend/utils/cache/relcache.c       | 135 ++---------------------
 src/include/access/tableam.h             |  13 +++
 src/include/utils/relcache.h             |   9 +-
 7 files changed, 157 insertions(+), 141 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91f..313ed319fc 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -22,6 +22,7 @@
 
 #include "miscadmin.h"
 
+#include "access/multixact.h"
 #include "access/heapam.h"
 #include "access/relscan.h"
 #include "access/rewriteheap.h"
@@ -29,12 +30,17 @@
 #include "access/tsmapi.h"
 #include "catalog/catalog.h"
 #include "catalog/index.h"
+#include "catalog/indexing.h"
 #include "catalog/pg_am_d.h"
+#include "catalog/storage.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
 #include "utils/builtins.h"
 #include "utils/rel.h"
+#include "utils/relcache.h"
+#include "utils/relmapper.h"
+#include "utils/syscache.h"
 #include "utils/tqual.h"
 #include "storage/bufpage.h"
 #include "storage/bufmgr.h"
@@ -2116,6 +2122,124 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 	pfree(isnull);
 }
 
+/*
+ * RelationSetNewRelfilenode
+ *
+ * Assign a new relfilenode (physical file name) to the relation.
+ *
+ * This allows a full rewrite of the relation to be done with transactional
+ * safety (since the filenode assignment can be rolled back).  Note however
+ * that there is no simple way to access the relation's old data for the
+ * remainder of the current transaction.  This limits the usefulness to cases
+ * such as TRUNCATE or rebuilding an index from scratch.
+ *
+ * Caller must already hold exclusive lock on the relation.
+ *
+ * The relation is marked with relfrozenxid = freezeXid (InvalidTransactionId
+ * must be passed for indexes and sequences).  This should be a lower bound on
+ * the XIDs that will be put into the new relation contents.
+ *
+ * The new filenode's persistence is set to the given value.  This is useful
+ * for the cases that are changing the relation's persistence; other callers
+ * need to pass the original relpersistence value.
+ */
+static void
+RelationSetNewRelfilenode(Relation relation, char persistence,
+						  TransactionId freezeXid, MultiXactId minmulti)
+{
+	Oid			newrelfilenode;
+	RelFileNodeBackend newrnode;
+	Relation	pg_class;
+	HeapTuple	tuple;
+	Form_pg_class classform;
+
+	/* Indexes, sequences must have Invalid frozenxid; other rels must not */
+	Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
+			relation->rd_rel->relkind == RELKIND_SEQUENCE) ?
+		   freezeXid == InvalidTransactionId :
+		   TransactionIdIsNormal(freezeXid));
+	Assert(TransactionIdIsNormal(freezeXid) == MultiXactIdIsValid(minmulti));
+
+	/* Allocate a new relfilenode */
+	newrelfilenode = GetNewRelFileNode(relation->rd_rel->reltablespace, NULL,
+									   persistence);
+
+	/*
+	 * Get a writable copy of the pg_class tuple for the given relation.
+	 */
+	pg_class = heap_open(RelationRelationId, RowExclusiveLock);
+
+	tuple = SearchSysCacheCopy1(RELOID,
+								ObjectIdGetDatum(RelationGetRelid(relation)));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "could not find tuple for relation %u",
+			 RelationGetRelid(relation));
+	classform = (Form_pg_class) GETSTRUCT(tuple);
+
+	/*
+	 * Create storage for the main fork of the new relfilenode.
+	 *
+	 * NOTE: any conflict in relfilenode value will be caught here, if
+	 * GetNewRelFileNode messes up for any reason.
+	 */
+	newrnode.node = relation->rd_node;
+	newrnode.node.relNode = newrelfilenode;
+	newrnode.backend = relation->rd_backend;
+	RelationCreateStorage(newrnode.node, persistence);
+	smgrclosenode(newrnode);
+
+	/*
+	 * Schedule unlinking of the old storage at transaction commit.
+	 */
+	RelationDropStorage(relation);
+
+	/*
+	 * Now update the pg_class row.  However, if we're dealing with a mapped
+	 * index, pg_class.relfilenode doesn't change; instead we have to send the
+	 * update to the relation mapper.
+	 */
+	if (RelationIsMapped(relation))
+		RelationMapUpdateMap(RelationGetRelid(relation),
+							 newrelfilenode,
+							 relation->rd_rel->relisshared,
+							 false);
+	else
+		classform->relfilenode = newrelfilenode;
+
+	/* These changes are safe even for a mapped relation */
+	if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
+	{
+		classform->relpages = 0;	/* it's empty until further notice */
+		classform->reltuples = 0;
+		classform->relallvisible = 0;
+	}
+	classform->relfrozenxid = freezeXid;
+	classform->relminmxid = minmulti;
+	classform->relpersistence = persistence;
+
+	CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
+
+	heap_freetuple(tuple);
+
+	heap_close(pg_class, RowExclusiveLock);
+
+	/*
+	 * Make the pg_class row change visible, as well as the relation map
+	 * change if any.  This will cause the relcache entry to get updated, too.
+	 */
+	CommandCounterIncrement();
+
+	/*
+	 * Mark the rel as having been given a new relfilenode in the current
+	 * (sub) transaction.  This is a hint that can be used to optimize later
+	 * operations on the rel in the same transaction.
+	 */
+	relation->rd_newRelfilenodeSubid = GetCurrentSubTransactionId();
+
+	/* Flag relation as needing eoxact cleanup (to remove the hint) */
+	EOXactListAdd(relation);
+}
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2163,7 +2287,9 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.SetNewFileNode = RelationSetNewRelfilenode
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 55477bd995..df213dc07d 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -2865,7 +2865,7 @@ reindex_index(Oid indexId, bool skip_constraint_checks, char persistence,
 		}
 
 		/* We'll build a new physical relation for the index */
-		RelationSetNewRelfilenode(iRel, persistence, InvalidTransactionId,
+		table_set_new_filenode(iRel, persistence, InvalidTransactionId,
 								  InvalidMultiXactId);
 
 		/* Initialize the index and rebuild */
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index 89122d4ad7..107f9a0176 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -17,6 +17,7 @@
 #include "access/bufmask.h"
 #include "access/htup_details.h"
 #include "access/multixact.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -315,7 +316,7 @@ ResetSequence(Oid seq_relid)
 	 * sequence's relfrozenxid at 0, since it won't contain any unfrozen XIDs.
 	 * Same with relminmxid, since a sequence will never contain multixacts.
 	 */
-	RelationSetNewRelfilenode(seq_rel, seq_rel->rd_rel->relpersistence,
+	table_set_new_filenode(seq_rel, seq_rel->rd_rel->relpersistence,
 							  InvalidTransactionId, InvalidMultiXactId);
 
 	/*
@@ -485,7 +486,7 @@ AlterSequence(ParseState *pstate, AlterSeqStmt *stmt)
 		 * at 0, since it won't contain any unfrozen XIDs.  Same with
 		 * relminmxid, since a sequence will never contain multixacts.
 		 */
-		RelationSetNewRelfilenode(seqrel, seqrel->rd_rel->relpersistence,
+		table_set_new_filenode(seqrel, seqrel->rd_rel->relpersistence,
 								  InvalidTransactionId, InvalidMultiXactId);
 
 		/*
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index f3526b267d..6db214309e 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1643,10 +1643,8 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			 * Create a new empty storage file for the relation, and assign it
 			 * as the relfilenode value. The old storage file is scheduled for
 			 * deletion at commit.
-			 *
-			 * PBORKED: needs to be a callback
 			 */
-			RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
+			table_set_new_filenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
 				heap_create_init_fork(rel);
@@ -1660,7 +1658,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			if (OidIsValid(toast_relid))
 			{
 				rel = relation_open(toast_relid, AccessExclusiveLock);
-				RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
+				table_set_new_filenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
 					heap_create_init_fork(rel);
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 0d6e5a189f..0592fdc750 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -160,13 +160,6 @@ static Oid	eoxact_list[MAX_EOXACT_LIST];
 static int	eoxact_list_len = 0;
 static bool eoxact_list_overflowed = false;
 
-#define EOXactListAdd(rel) \
-	do { \
-		if (eoxact_list_len < MAX_EOXACT_LIST) \
-			eoxact_list[eoxact_list_len++] = (rel)->rd_id; \
-		else \
-			eoxact_list_overflowed = true; \
-	} while (0)
 
 /*
  * EOXactTupleDescArray stores TupleDescs that (might) need AtEOXact
@@ -292,6 +285,14 @@ static void unlink_initfile(const char *initfilename, int elevel);
 static bool equalPartitionDescs(PartitionKey key, PartitionDesc partdesc1,
 					PartitionDesc partdesc2);
 
+void
+EOXactListAdd(Relation rel)
+{
+	if (eoxact_list_len < MAX_EOXACT_LIST)
+		eoxact_list[eoxact_list_len++] = (rel)->rd_id;
+	else
+		eoxact_list_overflowed = true;
+}
 
 /*
  *		ScanPgRelation
@@ -3392,126 +3393,6 @@ RelationBuildLocalRelation(const char *relname,
 	return rel;
 }
 
-
-/*
- * RelationSetNewRelfilenode
- *
- * Assign a new relfilenode (physical file name) to the relation.
- *
- * This allows a full rewrite of the relation to be done with transactional
- * safety (since the filenode assignment can be rolled back).  Note however
- * that there is no simple way to access the relation's old data for the
- * remainder of the current transaction.  This limits the usefulness to cases
- * such as TRUNCATE or rebuilding an index from scratch.
- *
- * Caller must already hold exclusive lock on the relation.
- *
- * The relation is marked with relfrozenxid = freezeXid (InvalidTransactionId
- * must be passed for indexes and sequences).  This should be a lower bound on
- * the XIDs that will be put into the new relation contents.
- *
- * The new filenode's persistence is set to the given value.  This is useful
- * for the cases that are changing the relation's persistence; other callers
- * need to pass the original relpersistence value.
- */
-void
-RelationSetNewRelfilenode(Relation relation, char persistence,
-						  TransactionId freezeXid, MultiXactId minmulti)
-{
-	Oid			newrelfilenode;
-	RelFileNodeBackend newrnode;
-	Relation	pg_class;
-	HeapTuple	tuple;
-	Form_pg_class classform;
-
-	/* Indexes, sequences must have Invalid frozenxid; other rels must not */
-	Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
-			relation->rd_rel->relkind == RELKIND_SEQUENCE) ?
-		   freezeXid == InvalidTransactionId :
-		   TransactionIdIsNormal(freezeXid));
-	Assert(TransactionIdIsNormal(freezeXid) == MultiXactIdIsValid(minmulti));
-
-	/* Allocate a new relfilenode */
-	newrelfilenode = GetNewRelFileNode(relation->rd_rel->reltablespace, NULL,
-									   persistence);
-
-	/*
-	 * Get a writable copy of the pg_class tuple for the given relation.
-	 */
-	pg_class = heap_open(RelationRelationId, RowExclusiveLock);
-
-	tuple = SearchSysCacheCopy1(RELOID,
-								ObjectIdGetDatum(RelationGetRelid(relation)));
-	if (!HeapTupleIsValid(tuple))
-		elog(ERROR, "could not find tuple for relation %u",
-			 RelationGetRelid(relation));
-	classform = (Form_pg_class) GETSTRUCT(tuple);
-
-	/*
-	 * Create storage for the main fork of the new relfilenode.
-	 *
-	 * NOTE: any conflict in relfilenode value will be caught here, if
-	 * GetNewRelFileNode messes up for any reason.
-	 */
-	newrnode.node = relation->rd_node;
-	newrnode.node.relNode = newrelfilenode;
-	newrnode.backend = relation->rd_backend;
-	RelationCreateStorage(newrnode.node, persistence);
-	smgrclosenode(newrnode);
-
-	/*
-	 * Schedule unlinking of the old storage at transaction commit.
-	 */
-	RelationDropStorage(relation);
-
-	/*
-	 * Now update the pg_class row.  However, if we're dealing with a mapped
-	 * index, pg_class.relfilenode doesn't change; instead we have to send the
-	 * update to the relation mapper.
-	 */
-	if (RelationIsMapped(relation))
-		RelationMapUpdateMap(RelationGetRelid(relation),
-							 newrelfilenode,
-							 relation->rd_rel->relisshared,
-							 false);
-	else
-		classform->relfilenode = newrelfilenode;
-
-	/* These changes are safe even for a mapped relation */
-	if (relation->rd_rel->relkind != RELKIND_SEQUENCE)
-	{
-		classform->relpages = 0;	/* it's empty until further notice */
-		classform->reltuples = 0;
-		classform->relallvisible = 0;
-	}
-	classform->relfrozenxid = freezeXid;
-	classform->relminmxid = minmulti;
-	classform->relpersistence = persistence;
-
-	CatalogTupleUpdate(pg_class, &tuple->t_self, tuple);
-
-	heap_freetuple(tuple);
-
-	heap_close(pg_class, RowExclusiveLock);
-
-	/*
-	 * Make the pg_class row change visible, as well as the relation map
-	 * change if any.  This will cause the relcache entry to get updated, too.
-	 */
-	CommandCounterIncrement();
-
-	/*
-	 * Mark the rel as having been given a new relfilenode in the current
-	 * (sub) transaction.  This is a hint that can be used to optimize later
-	 * operations on the rel in the same transaction.
-	 */
-	relation->rd_newRelfilenodeSubid = GetCurrentSubTransactionId();
-
-	/* Flag relation as needing eoxact cleanup (to remove the hint) */
-	EOXactListAdd(relation);
-}
-
-
 /*
  *		RelationCacheInitialize
  *
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c22..4d5b11c294 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -194,6 +194,9 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*SetNewFileNode_function)(Relation relation, char persistence,
+										TransactionId freezeXid, MultiXactId minmulti);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -250,6 +253,8 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	SetNewFileNode_function	SetNewFileNode;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -741,6 +746,14 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline void
+table_set_new_filenode(Relation relation, char persistence,
+						  TransactionId freezeXid, MultiXactId minmulti)
+{
+	relation->rd_tableamroutine->SetNewFileNode(relation, persistence,
+									freezeXid, minmulti);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/utils/relcache.h b/src/include/utils/relcache.h
index 858a7b30d2..1482dae904 100644
--- a/src/include/utils/relcache.h
+++ b/src/include/utils/relcache.h
@@ -33,6 +33,9 @@ typedef struct RelationData *Relation;
  */
 typedef Relation *RelationPtr;
 
+/* Function to store the clenup OID's */
+extern void EOXactListAdd(Relation rel);
+
 /*
  * Routines to open (lookup) and close a relcache entry
  */
@@ -109,12 +112,6 @@ extern Relation RelationBuildLocalRelation(const char *relname,
 						   char relpersistence,
 						   char relkind);
 
-/*
- * Routine to manage assignment of new relfilenode to a relation
- */
-extern void RelationSetNewRelfilenode(Relation relation, char persistence,
-						  TransactionId freezeXid, MultiXactId minmulti);
-
 /*
  * Routines for flushing/rebuilding relcache entries in various scenarios
  */
-- 
2.18.0.windows.1

commit fea0ea9bceb698dbe88bee42d5fc5f3332a658dd
Author: Alexander Korotkov <akorotkov@postgresql.org>
Date:   Wed Sep 26 15:29:43 2018 +0300

    Remove some snapshot functions from TableAmRoutine
    
    snapshot_satisfiesUpdate was unused.  snapshot_satisfiesVacuum was used only
    inside heap_copy_for_cluster, so it was replaced to direct
    heapam_satisfies_vacuum() call.

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91fd..28c475e7bdc 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -483,21 +483,6 @@ heapam_satisfies(TupleTableSlot *slot, Snapshot snapshot)
 	return res;
 }
 
-static HTSU_Result
-heapam_satisfies_update(TupleTableSlot *slot, CommandId curcid)
-{
-	BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-	HTSU_Result res;
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesUpdate(bslot->base.tuple,
-								   curcid,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-}
-
 static HTSV_Result
 heapam_satisfies_vacuum(TupleTableSlot *slot, TransactionId OldestXmin)
 {
@@ -2003,7 +1988,7 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 				break;
 		}
 
-		switch (OldHeap->rd_tableamroutine->snapshot_satisfiesVacuum(slot, OldestXmin))
+		switch (heapam_satisfies_vacuum(slot, OldestXmin))
 		{
 			case HEAPTUPLE_DEAD:
 				/* Definitely dead */
@@ -2122,8 +2107,6 @@ static const TableAmRoutine heapam_methods = {
 	.slot_callbacks = heapam_slot_callbacks,
 
 	.snapshot_satisfies = heapam_satisfies,
-	.snapshot_satisfiesUpdate = heapam_satisfies_update,
-	.snapshot_satisfiesVacuum = heapam_satisfies_vacuum,
 
 	.scan_begin = heap_beginscan,
 	.scansetlimits = heap_setscanlimits,
diff --git a/src/backend/access/zheap/zheapam_handler.c b/src/backend/access/zheap/zheapam_handler.c
index bec9b16f7d6..e707baa1b5d 100644
--- a/src/backend/access/zheap/zheapam_handler.c
+++ b/src/backend/access/zheap/zheapam_handler.c
@@ -486,40 +486,6 @@ zheapam_satisfies(TupleTableSlot *slot, Snapshot snapshot)
 #endif
 }
 
-static HTSU_Result
-zheapam_satisfies_update(TupleTableSlot *slot, CommandId curcid)
-{
-	elog(ERROR, "would need to track buffer or refetch");
-#if ZBORKED
-	BufferHeapTupleTableSlot *zslot = (BufferHeapTupleTableSlot *) slot;
-	HTSU_Result res;
-
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesUpdate(bslot->base.tuple,
-								   curcid,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-#endif
-}
-
-static HTSV_Result
-zheapam_satisfies_vacuum(TupleTableSlot *slot, TransactionId OldestXmin)
-{
-	BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-	HTSV_Result res;
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesVacuum(bslot->base.tuple,
-								   OldestXmin,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-}
-
 static IndexFetchTableData*
 zheapam_begin_index_fetch(Relation rel)
 {
@@ -1621,8 +1587,6 @@ static const TableAmRoutine zheapam_methods = {
 	.slot_callbacks = zheapam_slot_callbacks,
 
 	.snapshot_satisfies = zheapam_satisfies,
-	.snapshot_satisfiesUpdate = zheapam_satisfies_update,
-	.snapshot_satisfiesVacuum = zheapam_satisfies_vacuum,
 
 	.scan_begin = zheap_beginscan,
 	.scansetlimits = zheap_setscanlimits,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c221..fb37a739918 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -55,8 +55,6 @@ extern bool synchronize_seqscans;
  * Storage routine function hooks
  */
 typedef bool (*SnapshotSatisfies_function) (TupleTableSlot *slot, Snapshot snapshot);
-typedef HTSU_Result (*SnapshotSatisfiesUpdate_function) (TupleTableSlot *slot, CommandId curcid);
-typedef HTSV_Result (*SnapshotSatisfiesVacuum_function) (TupleTableSlot *slot, TransactionId OldestXmin);
 
 typedef Oid (*TupleInsert_function) (Relation rel, TupleTableSlot *slot, CommandId cid,
 									 int options, BulkInsertState bistate);
@@ -205,8 +203,6 @@ typedef struct TableAmRoutine
 	SlotCallbacks_function slot_callbacks;
 
 	SnapshotSatisfies_function snapshot_satisfies;
-	SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
-	SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
 
 	/* Operations on physical tuples */
 	TupleInsert_function tuple_insert;

commit fa33fbebe3e33f09fdb32961b2ffdf5c7262b74a
Author: Alexander Korotkov <akorotkov@postgresql.org>
Date:   Mon Oct 15 21:33:31 2018 +0300

    Add costing function to tableam interface
    
    Costs of sequential scan and table sample scan are estimated using
    cost_seqscan() and cost_samplescan().  But they should be table access method
    specific, because different table AMs could have different costs.  This commit
    introduces zheap cost functions to be the same as heap.  That should be
    adjusted in future.  Make costs of heap lookups during index scan is TODO.

diff --git a/src/backend/access/heap/Makefile b/src/backend/access/heap/Makefile
index aee7bfd8346..e13b0e0b8fa 100644
--- a/src/backend/access/heap/Makefile
+++ b/src/backend/access/heap/Makefile
@@ -13,6 +13,7 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = heapam.o heapam_handler.o heapam_visibility.o hio.o pruneheap.o \
-	rewriteheap.o syncscan.o tuptoaster.o vacuumlazy.o visibilitymap.o
+	rewriteheap.o syncscan.o tuptoaster.o vacuumlazy.o visibilitymap.o \
+	heapam_cost.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 28c475e7bdc..35b230c3606 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -2146,7 +2146,10 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.cost_scan = heapam_cost_scan,
+	.cost_samplescan = heapam_cost_samplescan
 };
 
 const TableAmRoutine *
diff --git a/src/backend/access/zheap/Makefile b/src/backend/access/zheap/Makefile
index 75b0ff69ebf..4458e1a4238 100644
--- a/src/backend/access/zheap/Makefile
+++ b/src/backend/access/zheap/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = prunetpd.o prunezheap.o tpd.o tpdxlog.o zheapam.o zheapam_handler.o zheapamutils.o zheapamxlog.o \
-	zhio.o zmultilocker.o ztuptoaster.o ztqual.o zvacuumlazy.o
+	zhio.o zmultilocker.o ztuptoaster.o ztqual.o zvacuumlazy.o zheapam_cost.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/zheap/zheapam_handler.c b/src/backend/access/zheap/zheapam_handler.c
index e707baa1b5d..da95c881a77 100644
--- a/src/backend/access/zheap/zheapam_handler.c
+++ b/src/backend/access/zheap/zheapam_handler.c
@@ -1627,6 +1627,8 @@ static const TableAmRoutine zheapam_methods = {
 	.index_build_range_scan = IndexBuildZHeapRangeScan,
 	.index_validate_scan = validate_index_zheapscan,
 
+	.cost_scan = zheapam_cost_scan,
+	.cost_samplescan = zheapam_cost_samplescan
 };
 
 Datum
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 7bf67a05295..abdddacf89a 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -75,6 +75,7 @@
 
 #include "access/amapi.h"
 #include "access/htup_details.h"
+#include "access/tableam.h"
 #include "access/tsmapi.h"
 #include "executor/executor.h"
 #include "executor/nodeHash.h"
@@ -150,9 +151,6 @@ static MergeScanSelCache *cached_scansel(PlannerInfo *root,
 static void cost_rescan(PlannerInfo *root, Path *path,
 			Cost *rescan_startup_cost, Cost *rescan_total_cost);
 static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context);
-static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
-						  ParamPathInfo *param_info,
-						  QualCost *qpqual_cost);
 static bool has_indexed_join_quals(NestPath *joinpath);
 static double approx_tuple_count(PlannerInfo *root, JoinPath *path,
 				   List *quals);
@@ -174,7 +172,6 @@ static Cost append_nonpartial_cost(List *subpaths, int numpaths,
 static void set_rel_width(PlannerInfo *root, RelOptInfo *rel);
 static double relation_byte_size(double tuples, int width);
 static double page_size(double tuples, int width);
-static double get_parallel_divisor(Path *path);
 
 
 /*
@@ -209,70 +206,9 @@ void
 cost_seqscan(Path *path, PlannerInfo *root,
 			 RelOptInfo *baserel, ParamPathInfo *param_info)
 {
-	Cost		startup_cost = 0;
-	Cost		cpu_run_cost;
-	Cost		disk_run_cost;
-	double		spc_seq_page_cost;
-	QualCost	qpqual_cost;
-	Cost		cpu_per_tuple;
-
-	/* Should only be applied to base relations */
-	Assert(baserel->relid > 0);
-	Assert(baserel->rtekind == RTE_RELATION);
-
-	/* Mark the path with the correct row estimate */
-	if (param_info)
-		path->rows = param_info->ppi_rows;
-	else
-		path->rows = baserel->rows;
-
-	if (!enable_seqscan)
-		startup_cost += disable_cost;
-
-	/* fetch estimated page cost for tablespace containing table */
-	get_tablespace_page_costs(baserel->reltablespace,
-							  NULL,
-							  &spc_seq_page_cost);
-
-	/*
-	 * disk costs
-	 */
-	disk_run_cost = spc_seq_page_cost * baserel->pages;
-
-	/* CPU costs */
-	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
-
-	startup_cost += qpqual_cost.startup;
-	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
-	cpu_run_cost = cpu_per_tuple * baserel->tuples;
-	/* tlist eval costs are paid per output row, not per tuple scanned */
-	startup_cost += path->pathtarget->cost.startup;
-	cpu_run_cost += path->pathtarget->cost.per_tuple * path->rows;
-
-	/* Adjust costing for parallelism, if used. */
-	if (path->parallel_workers > 0)
-	{
-		double		parallel_divisor = get_parallel_divisor(path);
-
-		/* The CPU cost is divided among all the workers. */
-		cpu_run_cost /= parallel_divisor;
-
-		/*
-		 * It may be possible to amortize some of the I/O cost, but probably
-		 * not very much, because most operating systems already do aggressive
-		 * prefetching.  For now, we assume that the disk run cost can't be
-		 * amortized at all.
-		 */
-
-		/*
-		 * In the case of a parallel plan, the row count needs to represent
-		 * the number of tuples processed per worker.
-		 */
-		path->rows = clamp_row_est(path->rows / parallel_divisor);
-	}
-
-	path->startup_cost = startup_cost;
-	path->total_cost = startup_cost + cpu_run_cost + disk_run_cost;
+	TableScanCost_function cost_func = (TableScanCost_function) baserel->cost_scan;
+	Assert(cost_func != NULL);
+	return cost_func(path, root, baserel, param_info);
 }
 
 /*
@@ -286,65 +222,9 @@ void
 cost_samplescan(Path *path, PlannerInfo *root,
 				RelOptInfo *baserel, ParamPathInfo *param_info)
 {
-	Cost		startup_cost = 0;
-	Cost		run_cost = 0;
-	RangeTblEntry *rte;
-	TableSampleClause *tsc;
-	TsmRoutine *tsm;
-	double		spc_seq_page_cost,
-				spc_random_page_cost,
-				spc_page_cost;
-	QualCost	qpqual_cost;
-	Cost		cpu_per_tuple;
-
-	/* Should only be applied to base relations with tablesample clauses */
-	Assert(baserel->relid > 0);
-	rte = planner_rt_fetch(baserel->relid, root);
-	Assert(rte->rtekind == RTE_RELATION);
-	tsc = rte->tablesample;
-	Assert(tsc != NULL);
-	tsm = GetTsmRoutine(tsc->tsmhandler);
-
-	/* Mark the path with the correct row estimate */
-	if (param_info)
-		path->rows = param_info->ppi_rows;
-	else
-		path->rows = baserel->rows;
-
-	/* fetch estimated page cost for tablespace containing table */
-	get_tablespace_page_costs(baserel->reltablespace,
-							  &spc_random_page_cost,
-							  &spc_seq_page_cost);
-
-	/* if NextSampleBlock is used, assume random access, else sequential */
-	spc_page_cost = (tsm->NextSampleBlock != NULL) ?
-		spc_random_page_cost : spc_seq_page_cost;
-
-	/*
-	 * disk costs (recall that baserel->pages has already been set to the
-	 * number of pages the sampling method will visit)
-	 */
-	run_cost += spc_page_cost * baserel->pages;
-
-	/*
-	 * CPU costs (recall that baserel->tuples has already been set to the
-	 * number of tuples the sampling method will select).  Note that we ignore
-	 * execution cost of the TABLESAMPLE parameter expressions; they will be
-	 * evaluated only once per scan, and in most usages they'll likely be
-	 * simple constants anyway.  We also don't charge anything for the
-	 * calculations the sampling method might do internally.
-	 */
-	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
-
-	startup_cost += qpqual_cost.startup;
-	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
-	run_cost += cpu_per_tuple * baserel->tuples;
-	/* tlist eval costs are paid per output row, not per tuple scanned */
-	startup_cost += path->pathtarget->cost.startup;
-	run_cost += path->pathtarget->cost.per_tuple * path->rows;
-
-	path->startup_cost = startup_cost;
-	path->total_cost = startup_cost + run_cost;
+	TableScanCost_function cost_func = (TableScanCost_function) baserel->cost_samplescan;
+	Assert(cost_func != NULL);
+	return cost_func(path, root, baserel, param_info);
 }
 
 /*
@@ -3988,7 +3868,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
  * some of the quals.  We assume baserestrictcost was previously set by
  * set_baserel_size_estimates().
  */
-static void
+void
 get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
 						  ParamPathInfo *param_info,
 						  QualCost *qpqual_cost)
@@ -5343,7 +5223,7 @@ page_size(double tuples, int width)
  * Estimate the fraction of the work that each worker will do given the
  * number of workers budgeted for the path.
  */
-static double
+double
 get_parallel_divisor(Path *path)
 {
 	double		parallel_divisor = path->parallel_workers;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 86029cd1327..45f3b0372b9 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -93,6 +93,8 @@ static void set_baserel_partition_key_exprs(Relation relation,
  *	pages		number of pages
  *	tuples		number of tuples
  *	rel_parallel_workers user-defined number of parallel workers
+ *	cost_scan	costing function for sequential scan
+ *	cost_samplescan costing function for sample scan
  *
  * Also, add information about the relation's foreign keys to root->fkey_list.
  *
@@ -443,6 +445,18 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 		rel->fdwroutine = NULL;
 	}
 
+	/* Get costing functions */
+	if (relation->rd_tableamroutine != NULL)
+	{
+		rel->cost_scan = relation->rd_tableamroutine->cost_scan;
+		rel->cost_samplescan = relation->rd_tableamroutine->cost_samplescan;
+	}
+	else
+	{
+		rel->cost_scan = NULL;
+		rel->cost_samplescan = NULL;
+	}
+
 	/* Collect info about relation's foreign keys, if relevant */
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index dba50178887..2f342c7fef1 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -17,6 +17,7 @@
 #include "access/genham.h"
 #include "nodes/lockoptions.h"
 #include "nodes/primnodes.h"
+#include "optimizer/cost.h"
 #include "storage/bufpage.h"
 #include "storage/lockdefs.h"
 #include "utils/relcache.h"
@@ -59,6 +60,13 @@ extern Relation heap_openrv_extended(const RangeVar *relation,
 
 #define heap_close(r,l)  relation_close(r,l)
 
+/* in heap/heamam_cost.c */
+extern void heapam_cost_scan(Path *path, PlannerInfo *root,
+							 RelOptInfo *baserel, ParamPathInfo *param_info);
+extern void heapam_cost_samplescan(Path *path, PlannerInfo *root,
+							 RelOptInfo *baserel, ParamPathInfo *param_info);
+
+
 /* struct definitions appear in relscan.h */
 typedef struct TableScanDescData *TableScanDesc;
 typedef struct HeapScanDescData *HeapScanDesc;
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index fb37a739918..beea954885a 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -22,6 +22,7 @@
 #include "executor/tuptable.h"
 #include "nodes/execnodes.h"
 #include "nodes/nodes.h"
+#include "optimizer/cost.h"
 #include "fmgr.h"
 #include "utils/guc.h"
 #include "utils/rel.h"
@@ -192,6 +193,8 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*TableScanCost_function)(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -246,6 +249,10 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	/* Costing functions */
+	TableScanCost_function cost_scan;
+	TableScanCost_function cost_samplescan;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
diff --git a/src/include/access/zheap.h b/src/include/access/zheap.h
index c657c728ec3..583cf25f965 100644
--- a/src/include/access/zheap.h
+++ b/src/include/access/zheap.h
@@ -20,6 +20,7 @@
 #include "access/hio.h"
 #include "access/undoinsert.h"
 #include "access/zhtup.h"
+#include "optimizer/cost.h"
 #include "utils/rel.h"
 #include "utils/snapshot.h"
 
@@ -211,4 +212,11 @@ typedef struct ZHeapFreeOffsetRanges
 	int nranges;
 } ZHeapFreeOffsetRanges;
 
+/* Zheap costing functions */
+extern void zheapam_cost_scan(Path *path, PlannerInfo *root,
+							  RelOptInfo *baserel, ParamPathInfo *param_info);
+extern void zheapam_cost_samplescan(Path *path, PlannerInfo *root,
+							  RelOptInfo *baserel, ParamPathInfo *param_info);
+
+
 #endif   /* ZHEAP_H */
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index adb42650479..6c51fe27460 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -704,6 +704,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	/* Rather than include tableam.h here, we declare costing functions like this */
+	void		(*cost_scan) ();	/* sequential scan cost estimator */
+	void		(*cost_samplescan) ();	/* sample scan cost estimator */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
index 77ca7ff8371..0af574c41fe 100644
--- a/src/include/optimizer/cost.h
+++ b/src/include/optimizer/cost.h
@@ -166,6 +166,9 @@ extern void cost_gather(GatherPath *path, PlannerInfo *root,
 extern void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan);
 extern void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root);
 extern void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root);
+extern void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
+						  ParamPathInfo *param_info,
+						  QualCost *qpqual_cost);
 extern void compute_semi_anti_join_factors(PlannerInfo *root,
 							   RelOptInfo *joinrel,
 							   RelOptInfo *outerrel,
@@ -198,6 +201,7 @@ extern void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern PathTarget *set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target);
+extern double get_parallel_divisor(Path *path);
 extern double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel,
 					 Path *bitmapqual, int loop_count, Cost *cost, double *tuple);
 

commit 3a0868018d84db24024e2731e5bd6972b66d10e4
Author: Alexander Korotkov <akorotkov@postgresql.org>
Date:   Mon Oct 15 21:33:31 2018 +0300

    Add costing function to tableam interface
    
    Costs of sequential scan and table sample scan are estimated using
    cost_seqscan() and cost_samplescan().  But they should be table access method
    specific, because different table AMs could have different costs.  This commit
    introduces zheap cost functions to be the same as heap.  That should be
    adjusted in future.  Make costs of heap lookups during index scan is TODO.

diff --git a/src/backend/access/heap/Makefile b/src/backend/access/heap/Makefile
index aee7bfd8346..e13b0e0b8fa 100644
--- a/src/backend/access/heap/Makefile
+++ b/src/backend/access/heap/Makefile
@@ -13,6 +13,7 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = heapam.o heapam_handler.o heapam_visibility.o hio.o pruneheap.o \
-	rewriteheap.o syncscan.o tuptoaster.o vacuumlazy.o visibilitymap.o
+	rewriteheap.o syncscan.o tuptoaster.o vacuumlazy.o visibilitymap.o \
+	heapam_cost.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/heap/heapam_cost.c b/src/backend/access/heap/heapam_cost.c
new file mode 100644
index 00000000000..5c685c262a2
--- /dev/null
+++ b/src/backend/access/heap/heapam_cost.c
@@ -0,0 +1,187 @@
+/*-------------------------------------------------------------------------
+ *
+ * heapam_cost.c
+ *	  costing functions for heap access method
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/heap/heapam_cost.c
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <math.h>
+
+#include "access/amapi.h"
+#include "access/htup_details.h"
+#include "access/tableam.h"
+#include "access/tsmapi.h"
+#include "executor/executor.h"
+#include "executor/nodeHash.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
+#include "optimizer/cost.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/placeholder.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/restrictinfo.h"
+#include "parser/parsetree.h"
+#include "utils/lsyscache.h"
+#include "utils/selfuncs.h"
+#include "utils/spccache.h"
+#include "utils/tuplesort.h"
+
+/*
+ * heapam_cost_scan
+ *	  Determines and returns the cost of scanning a relation sequentially.
+ *
+ * 'baserel' is the relation to be scanned
+ * 'param_info' is the ParamPathInfo if this is a parameterized path, else NULL
+ */
+void
+heapam_cost_scan(Path *path, PlannerInfo *root,
+				 RelOptInfo *baserel, ParamPathInfo *param_info)
+{
+	Cost		startup_cost = 0;
+	Cost		cpu_run_cost;
+	Cost		disk_run_cost;
+	double		spc_seq_page_cost;
+	QualCost	qpqual_cost;
+	Cost		cpu_per_tuple;
+
+	/* Should only be applied to base relations */
+	Assert(baserel->relid > 0);
+	Assert(baserel->rtekind == RTE_RELATION);
+
+	/* Mark the path with the correct row estimate */
+	if (param_info)
+		path->rows = param_info->ppi_rows;
+	else
+		path->rows = baserel->rows;
+
+	if (!enable_seqscan)
+		startup_cost += disable_cost;
+
+	/* fetch estimated page cost for tablespace containing table */
+	get_tablespace_page_costs(baserel->reltablespace,
+							  NULL,
+							  &spc_seq_page_cost);
+
+	/*
+	 * disk costs
+	 */
+	disk_run_cost = spc_seq_page_cost * baserel->pages;
+
+	/* CPU costs */
+	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
+
+	startup_cost += qpqual_cost.startup;
+	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
+	cpu_run_cost = cpu_per_tuple * baserel->tuples;
+	/* tlist eval costs are paid per output row, not per tuple scanned */
+	startup_cost += path->pathtarget->cost.startup;
+	cpu_run_cost += path->pathtarget->cost.per_tuple * path->rows;
+
+	/* Adjust costing for parallelism, if used. */
+	if (path->parallel_workers > 0)
+	{
+		double		parallel_divisor = get_parallel_divisor(path);
+
+		/* The CPU cost is divided among all the workers. */
+		cpu_run_cost /= parallel_divisor;
+
+		/*
+		 * It may be possible to amortize some of the I/O cost, but probably
+		 * not very much, because most operating systems already do aggressive
+		 * prefetching.  For now, we assume that the disk run cost can't be
+		 * amortized at all.
+		 */
+
+		/*
+		 * In the case of a parallel plan, the row count needs to represent
+		 * the number of tuples processed per worker.
+		 */
+		path->rows = clamp_row_est(path->rows / parallel_divisor);
+	}
+
+	path->startup_cost = startup_cost;
+	path->total_cost = startup_cost + cpu_run_cost + disk_run_cost;
+}
+
+/*
+ * heapam_cost_samplescan
+ *	  Determines and returns the cost of scanning a relation using sampling.
+ *
+ * 'baserel' is the relation to be scanned
+ * 'param_info' is the ParamPathInfo if this is a parameterized path, else NULL
+ */
+void
+heapam_cost_samplescan(Path *path, PlannerInfo *root,
+					   RelOptInfo *baserel, ParamPathInfo *param_info)
+{
+	Cost		startup_cost = 0;
+	Cost		run_cost = 0;
+	RangeTblEntry *rte;
+	TableSampleClause *tsc;
+	TsmRoutine *tsm;
+	double		spc_seq_page_cost,
+				spc_random_page_cost,
+				spc_page_cost;
+	QualCost	qpqual_cost;
+	Cost		cpu_per_tuple;
+
+	/* Should only be applied to base relations with tablesample clauses */
+	Assert(baserel->relid > 0);
+	rte = planner_rt_fetch(baserel->relid, root);
+	Assert(rte->rtekind == RTE_RELATION);
+	tsc = rte->tablesample;
+	Assert(tsc != NULL);
+	tsm = GetTsmRoutine(tsc->tsmhandler);
+
+	/* Mark the path with the correct row estimate */
+	if (param_info)
+		path->rows = param_info->ppi_rows;
+	else
+		path->rows = baserel->rows;
+
+	/* fetch estimated page cost for tablespace containing table */
+	get_tablespace_page_costs(baserel->reltablespace,
+							  &spc_random_page_cost,
+							  &spc_seq_page_cost);
+
+	/* if NextSampleBlock is used, assume random access, else sequential */
+	spc_page_cost = (tsm->NextSampleBlock != NULL) ?
+		spc_random_page_cost : spc_seq_page_cost;
+
+	/*
+	 * disk costs (recall that baserel->pages has already been set to the
+	 * number of pages the sampling method will visit)
+	 */
+	run_cost += spc_page_cost * baserel->pages;
+
+	/*
+	 * CPU costs (recall that baserel->tuples has already been set to the
+	 * number of tuples the sampling method will select).  Note that we ignore
+	 * execution cost of the TABLESAMPLE parameter expressions; they will be
+	 * evaluated only once per scan, and in most usages they'll likely be
+	 * simple constants anyway.  We also don't charge anything for the
+	 * calculations the sampling method might do internally.
+	 */
+	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
+
+	startup_cost += qpqual_cost.startup;
+	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
+	run_cost += cpu_per_tuple * baserel->tuples;
+	/* tlist eval costs are paid per output row, not per tuple scanned */
+	startup_cost += path->pathtarget->cost.startup;
+	run_cost += path->pathtarget->cost.per_tuple * path->rows;
+
+	path->startup_cost = startup_cost;
+	path->total_cost = startup_cost + run_cost;
+}
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 28c475e7bdc..35b230c3606 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -2146,7 +2146,10 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.cost_scan = heapam_cost_scan,
+	.cost_samplescan = heapam_cost_samplescan
 };
 
 const TableAmRoutine *
diff --git a/src/backend/access/zheap/Makefile b/src/backend/access/zheap/Makefile
index 75b0ff69ebf..4458e1a4238 100644
--- a/src/backend/access/zheap/Makefile
+++ b/src/backend/access/zheap/Makefile
@@ -13,6 +13,6 @@ top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
 OBJS = prunetpd.o prunezheap.o tpd.o tpdxlog.o zheapam.o zheapam_handler.o zheapamutils.o zheapamxlog.o \
-	zhio.o zmultilocker.o ztuptoaster.o ztqual.o zvacuumlazy.o
+	zhio.o zmultilocker.o ztuptoaster.o ztqual.o zvacuumlazy.o zheapam_cost.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/zheap/zheapam_cost.c b/src/backend/access/zheap/zheapam_cost.c
new file mode 100644
index 00000000000..613ee1fb6e7
--- /dev/null
+++ b/src/backend/access/zheap/zheapam_cost.c
@@ -0,0 +1,187 @@
+/*-------------------------------------------------------------------------
+ *
+ * zheapam_cost.c
+ *	  costing functions for zheap access method
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/zheap/zheapam_cost.c
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <math.h>
+
+#include "access/amapi.h"
+#include "access/htup_details.h"
+#include "access/tableam.h"
+#include "access/tsmapi.h"
+#include "executor/executor.h"
+#include "executor/nodeHash.h"
+#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/clauses.h"
+#include "optimizer/cost.h"
+#include "optimizer/pathnode.h"
+#include "optimizer/paths.h"
+#include "optimizer/placeholder.h"
+#include "optimizer/plancat.h"
+#include "optimizer/planmain.h"
+#include "optimizer/restrictinfo.h"
+#include "parser/parsetree.h"
+#include "utils/lsyscache.h"
+#include "utils/selfuncs.h"
+#include "utils/spccache.h"
+#include "utils/tuplesort.h"
+
+/*
+ * zheapam_cost_scan
+ *	  Determines and returns the cost of scanning a relation sequentially.
+ *
+ * 'baserel' is the relation to be scanned
+ * 'param_info' is the ParamPathInfo if this is a parameterized path, else NULL
+ */
+void
+zheapam_cost_scan(Path *path, PlannerInfo *root,
+				  RelOptInfo *baserel, ParamPathInfo *param_info)
+{
+	Cost		startup_cost = 0;
+	Cost		cpu_run_cost;
+	Cost		disk_run_cost;
+	double		spc_seq_page_cost;
+	QualCost	qpqual_cost;
+	Cost		cpu_per_tuple;
+
+	/* Should only be applied to base relations */
+	Assert(baserel->relid > 0);
+	Assert(baserel->rtekind == RTE_RELATION);
+
+	/* Mark the path with the correct row estimate */
+	if (param_info)
+		path->rows = param_info->ppi_rows;
+	else
+		path->rows = baserel->rows;
+
+	if (!enable_seqscan)
+		startup_cost += disable_cost;
+
+	/* fetch estimated page cost for tablespace containing table */
+	get_tablespace_page_costs(baserel->reltablespace,
+							  NULL,
+							  &spc_seq_page_cost);
+
+	/*
+	 * disk costs
+	 */
+	disk_run_cost = spc_seq_page_cost * baserel->pages;
+
+	/* CPU costs */
+	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
+
+	startup_cost += qpqual_cost.startup;
+	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
+	cpu_run_cost = cpu_per_tuple * baserel->tuples;
+	/* tlist eval costs are paid per output row, not per tuple scanned */
+	startup_cost += path->pathtarget->cost.startup;
+	cpu_run_cost += path->pathtarget->cost.per_tuple * path->rows;
+
+	/* Adjust costing for parallelism, if used. */
+	if (path->parallel_workers > 0)
+	{
+		double		parallel_divisor = get_parallel_divisor(path);
+
+		/* The CPU cost is divided among all the workers. */
+		cpu_run_cost /= parallel_divisor;
+
+		/*
+		 * It may be possible to amortize some of the I/O cost, but probably
+		 * not very much, because most operating systems already do aggressive
+		 * prefetching.  For now, we assume that the disk run cost can't be
+		 * amortized at all.
+		 */
+
+		/*
+		 * In the case of a parallel plan, the row count needs to represent
+		 * the number of tuples processed per worker.
+		 */
+		path->rows = clamp_row_est(path->rows / parallel_divisor);
+	}
+
+	path->startup_cost = startup_cost;
+	path->total_cost = startup_cost + cpu_run_cost + disk_run_cost;
+}
+
+/*
+ * zheapam_cost_samplescan
+ *	  Determines and returns the cost of scanning a relation using sampling.
+ *
+ * 'baserel' is the relation to be scanned
+ * 'param_info' is the ParamPathInfo if this is a parameterized path, else NULL
+ */
+void
+zheapam_cost_samplescan(Path *path, PlannerInfo *root,
+						RelOptInfo *baserel, ParamPathInfo *param_info)
+{
+	Cost		startup_cost = 0;
+	Cost		run_cost = 0;
+	RangeTblEntry *rte;
+	TableSampleClause *tsc;
+	TsmRoutine *tsm;
+	double		spc_seq_page_cost,
+				spc_random_page_cost,
+				spc_page_cost;
+	QualCost	qpqual_cost;
+	Cost		cpu_per_tuple;
+
+	/* Should only be applied to base relations with tablesample clauses */
+	Assert(baserel->relid > 0);
+	rte = planner_rt_fetch(baserel->relid, root);
+	Assert(rte->rtekind == RTE_RELATION);
+	tsc = rte->tablesample;
+	Assert(tsc != NULL);
+	tsm = GetTsmRoutine(tsc->tsmhandler);
+
+	/* Mark the path with the correct row estimate */
+	if (param_info)
+		path->rows = param_info->ppi_rows;
+	else
+		path->rows = baserel->rows;
+
+	/* fetch estimated page cost for tablespace containing table */
+	get_tablespace_page_costs(baserel->reltablespace,
+							  &spc_random_page_cost,
+							  &spc_seq_page_cost);
+
+	/* if NextSampleBlock is used, assume random access, else sequential */
+	spc_page_cost = (tsm->NextSampleBlock != NULL) ?
+		spc_random_page_cost : spc_seq_page_cost;
+
+	/*
+	 * disk costs (recall that baserel->pages has already been set to the
+	 * number of pages the sampling method will visit)
+	 */
+	run_cost += spc_page_cost * baserel->pages;
+
+	/*
+	 * CPU costs (recall that baserel->tuples has already been set to the
+	 * number of tuples the sampling method will select).  Note that we ignore
+	 * execution cost of the TABLESAMPLE parameter expressions; they will be
+	 * evaluated only once per scan, and in most usages they'll likely be
+	 * simple constants anyway.  We also don't charge anything for the
+	 * calculations the sampling method might do internally.
+	 */
+	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
+
+	startup_cost += qpqual_cost.startup;
+	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
+	run_cost += cpu_per_tuple * baserel->tuples;
+	/* tlist eval costs are paid per output row, not per tuple scanned */
+	startup_cost += path->pathtarget->cost.startup;
+	run_cost += path->pathtarget->cost.per_tuple * path->rows;
+
+	path->startup_cost = startup_cost;
+	path->total_cost = startup_cost + run_cost;
+}
diff --git a/src/backend/access/zheap/zheapam_handler.c b/src/backend/access/zheap/zheapam_handler.c
index e707baa1b5d..da95c881a77 100644
--- a/src/backend/access/zheap/zheapam_handler.c
+++ b/src/backend/access/zheap/zheapam_handler.c
@@ -1627,6 +1627,8 @@ static const TableAmRoutine zheapam_methods = {
 	.index_build_range_scan = IndexBuildZHeapRangeScan,
 	.index_validate_scan = validate_index_zheapscan,
 
+	.cost_scan = zheapam_cost_scan,
+	.cost_samplescan = zheapam_cost_samplescan
 };
 
 Datum
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 7bf67a05295..abdddacf89a 100644
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -75,6 +75,7 @@
 
 #include "access/amapi.h"
 #include "access/htup_details.h"
+#include "access/tableam.h"
 #include "access/tsmapi.h"
 #include "executor/executor.h"
 #include "executor/nodeHash.h"
@@ -150,9 +151,6 @@ static MergeScanSelCache *cached_scansel(PlannerInfo *root,
 static void cost_rescan(PlannerInfo *root, Path *path,
 			Cost *rescan_startup_cost, Cost *rescan_total_cost);
 static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context);
-static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
-						  ParamPathInfo *param_info,
-						  QualCost *qpqual_cost);
 static bool has_indexed_join_quals(NestPath *joinpath);
 static double approx_tuple_count(PlannerInfo *root, JoinPath *path,
 				   List *quals);
@@ -174,7 +172,6 @@ static Cost append_nonpartial_cost(List *subpaths, int numpaths,
 static void set_rel_width(PlannerInfo *root, RelOptInfo *rel);
 static double relation_byte_size(double tuples, int width);
 static double page_size(double tuples, int width);
-static double get_parallel_divisor(Path *path);
 
 
 /*
@@ -209,70 +206,9 @@ void
 cost_seqscan(Path *path, PlannerInfo *root,
 			 RelOptInfo *baserel, ParamPathInfo *param_info)
 {
-	Cost		startup_cost = 0;
-	Cost		cpu_run_cost;
-	Cost		disk_run_cost;
-	double		spc_seq_page_cost;
-	QualCost	qpqual_cost;
-	Cost		cpu_per_tuple;
-
-	/* Should only be applied to base relations */
-	Assert(baserel->relid > 0);
-	Assert(baserel->rtekind == RTE_RELATION);
-
-	/* Mark the path with the correct row estimate */
-	if (param_info)
-		path->rows = param_info->ppi_rows;
-	else
-		path->rows = baserel->rows;
-
-	if (!enable_seqscan)
-		startup_cost += disable_cost;
-
-	/* fetch estimated page cost for tablespace containing table */
-	get_tablespace_page_costs(baserel->reltablespace,
-							  NULL,
-							  &spc_seq_page_cost);
-
-	/*
-	 * disk costs
-	 */
-	disk_run_cost = spc_seq_page_cost * baserel->pages;
-
-	/* CPU costs */
-	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
-
-	startup_cost += qpqual_cost.startup;
-	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
-	cpu_run_cost = cpu_per_tuple * baserel->tuples;
-	/* tlist eval costs are paid per output row, not per tuple scanned */
-	startup_cost += path->pathtarget->cost.startup;
-	cpu_run_cost += path->pathtarget->cost.per_tuple * path->rows;
-
-	/* Adjust costing for parallelism, if used. */
-	if (path->parallel_workers > 0)
-	{
-		double		parallel_divisor = get_parallel_divisor(path);
-
-		/* The CPU cost is divided among all the workers. */
-		cpu_run_cost /= parallel_divisor;
-
-		/*
-		 * It may be possible to amortize some of the I/O cost, but probably
-		 * not very much, because most operating systems already do aggressive
-		 * prefetching.  For now, we assume that the disk run cost can't be
-		 * amortized at all.
-		 */
-
-		/*
-		 * In the case of a parallel plan, the row count needs to represent
-		 * the number of tuples processed per worker.
-		 */
-		path->rows = clamp_row_est(path->rows / parallel_divisor);
-	}
-
-	path->startup_cost = startup_cost;
-	path->total_cost = startup_cost + cpu_run_cost + disk_run_cost;
+	TableScanCost_function cost_func = (TableScanCost_function) baserel->cost_scan;
+	Assert(cost_func != NULL);
+	return cost_func(path, root, baserel, param_info);
 }
 
 /*
@@ -286,65 +222,9 @@ void
 cost_samplescan(Path *path, PlannerInfo *root,
 				RelOptInfo *baserel, ParamPathInfo *param_info)
 {
-	Cost		startup_cost = 0;
-	Cost		run_cost = 0;
-	RangeTblEntry *rte;
-	TableSampleClause *tsc;
-	TsmRoutine *tsm;
-	double		spc_seq_page_cost,
-				spc_random_page_cost,
-				spc_page_cost;
-	QualCost	qpqual_cost;
-	Cost		cpu_per_tuple;
-
-	/* Should only be applied to base relations with tablesample clauses */
-	Assert(baserel->relid > 0);
-	rte = planner_rt_fetch(baserel->relid, root);
-	Assert(rte->rtekind == RTE_RELATION);
-	tsc = rte->tablesample;
-	Assert(tsc != NULL);
-	tsm = GetTsmRoutine(tsc->tsmhandler);
-
-	/* Mark the path with the correct row estimate */
-	if (param_info)
-		path->rows = param_info->ppi_rows;
-	else
-		path->rows = baserel->rows;
-
-	/* fetch estimated page cost for tablespace containing table */
-	get_tablespace_page_costs(baserel->reltablespace,
-							  &spc_random_page_cost,
-							  &spc_seq_page_cost);
-
-	/* if NextSampleBlock is used, assume random access, else sequential */
-	spc_page_cost = (tsm->NextSampleBlock != NULL) ?
-		spc_random_page_cost : spc_seq_page_cost;
-
-	/*
-	 * disk costs (recall that baserel->pages has already been set to the
-	 * number of pages the sampling method will visit)
-	 */
-	run_cost += spc_page_cost * baserel->pages;
-
-	/*
-	 * CPU costs (recall that baserel->tuples has already been set to the
-	 * number of tuples the sampling method will select).  Note that we ignore
-	 * execution cost of the TABLESAMPLE parameter expressions; they will be
-	 * evaluated only once per scan, and in most usages they'll likely be
-	 * simple constants anyway.  We also don't charge anything for the
-	 * calculations the sampling method might do internally.
-	 */
-	get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
-
-	startup_cost += qpqual_cost.startup;
-	cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
-	run_cost += cpu_per_tuple * baserel->tuples;
-	/* tlist eval costs are paid per output row, not per tuple scanned */
-	startup_cost += path->pathtarget->cost.startup;
-	run_cost += path->pathtarget->cost.per_tuple * path->rows;
-
-	path->startup_cost = startup_cost;
-	path->total_cost = startup_cost + run_cost;
+	TableScanCost_function cost_func = (TableScanCost_function) baserel->cost_samplescan;
+	Assert(cost_func != NULL);
+	return cost_func(path, root, baserel, param_info);
 }
 
 /*
@@ -3988,7 +3868,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
  * some of the quals.  We assume baserestrictcost was previously set by
  * set_baserel_size_estimates().
  */
-static void
+void
 get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
 						  ParamPathInfo *param_info,
 						  QualCost *qpqual_cost)
@@ -5343,7 +5223,7 @@ page_size(double tuples, int width)
  * Estimate the fraction of the work that each worker will do given the
  * number of workers budgeted for the path.
  */
-static double
+double
 get_parallel_divisor(Path *path)
 {
 	double		parallel_divisor = path->parallel_workers;
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 86029cd1327..45f3b0372b9 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -93,6 +93,8 @@ static void set_baserel_partition_key_exprs(Relation relation,
  *	pages		number of pages
  *	tuples		number of tuples
  *	rel_parallel_workers user-defined number of parallel workers
+ *	cost_scan	costing function for sequential scan
+ *	cost_samplescan costing function for sample scan
  *
  * Also, add information about the relation's foreign keys to root->fkey_list.
  *
@@ -443,6 +445,18 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 		rel->fdwroutine = NULL;
 	}
 
+	/* Get costing functions */
+	if (relation->rd_tableamroutine != NULL)
+	{
+		rel->cost_scan = relation->rd_tableamroutine->cost_scan;
+		rel->cost_samplescan = relation->rd_tableamroutine->cost_samplescan;
+	}
+	else
+	{
+		rel->cost_scan = NULL;
+		rel->cost_samplescan = NULL;
+	}
+
 	/* Collect info about relation's foreign keys, if relevant */
 	get_relation_foreign_keys(root, rel, relation, inhparent);
 
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index dba50178887..2f342c7fef1 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -17,6 +17,7 @@
 #include "access/genham.h"
 #include "nodes/lockoptions.h"
 #include "nodes/primnodes.h"
+#include "optimizer/cost.h"
 #include "storage/bufpage.h"
 #include "storage/lockdefs.h"
 #include "utils/relcache.h"
@@ -59,6 +60,13 @@ extern Relation heap_openrv_extended(const RangeVar *relation,
 
 #define heap_close(r,l)  relation_close(r,l)
 
+/* in heap/heamam_cost.c */
+extern void heapam_cost_scan(Path *path, PlannerInfo *root,
+							 RelOptInfo *baserel, ParamPathInfo *param_info);
+extern void heapam_cost_samplescan(Path *path, PlannerInfo *root,
+							 RelOptInfo *baserel, ParamPathInfo *param_info);
+
+
 /* struct definitions appear in relscan.h */
 typedef struct TableScanDescData *TableScanDesc;
 typedef struct HeapScanDescData *HeapScanDesc;
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index fb37a739918..beea954885a 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -22,6 +22,7 @@
 #include "executor/tuptable.h"
 #include "nodes/execnodes.h"
 #include "nodes/nodes.h"
+#include "optimizer/cost.h"
 #include "fmgr.h"
 #include "utils/guc.h"
 #include "utils/rel.h"
@@ -192,6 +193,8 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*TableScanCost_function)(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -246,6 +249,10 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	/* Costing functions */
+	TableScanCost_function cost_scan;
+	TableScanCost_function cost_samplescan;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
diff --git a/src/include/access/zheap.h b/src/include/access/zheap.h
index c657c728ec3..583cf25f965 100644
--- a/src/include/access/zheap.h
+++ b/src/include/access/zheap.h
@@ -20,6 +20,7 @@
 #include "access/hio.h"
 #include "access/undoinsert.h"
 #include "access/zhtup.h"
+#include "optimizer/cost.h"
 #include "utils/rel.h"
 #include "utils/snapshot.h"
 
@@ -211,4 +212,11 @@ typedef struct ZHeapFreeOffsetRanges
 	int nranges;
 } ZHeapFreeOffsetRanges;
 
+/* Zheap costing functions */
+extern void zheapam_cost_scan(Path *path, PlannerInfo *root,
+							  RelOptInfo *baserel, ParamPathInfo *param_info);
+extern void zheapam_cost_samplescan(Path *path, PlannerInfo *root,
+							  RelOptInfo *baserel, ParamPathInfo *param_info);
+
+
 #endif   /* ZHEAP_H */
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index adb42650479..6c51fe27460 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -704,6 +704,10 @@ typedef struct RelOptInfo
 	List	  **partexprs;		/* Non-nullable partition key expressions. */
 	List	  **nullable_partexprs; /* Nullable partition key expressions. */
 	List	   *partitioned_child_rels; /* List of RT indexes. */
+
+	/* Rather than include tableam.h here, we declare costing functions like this */
+	void		(*cost_scan) ();	/* sequential scan cost estimator */
+	void		(*cost_samplescan) ();	/* sample scan cost estimator */
 } RelOptInfo;
 
 /*
diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
index 77ca7ff8371..0af574c41fe 100644
--- a/src/include/optimizer/cost.h
+++ b/src/include/optimizer/cost.h
@@ -166,6 +166,9 @@ extern void cost_gather(GatherPath *path, PlannerInfo *root,
 extern void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan);
 extern void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root);
 extern void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root);
+extern void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel,
+						  ParamPathInfo *param_info,
+						  QualCost *qpqual_cost);
 extern void compute_semi_anti_join_factors(PlannerInfo *root,
 							   RelOptInfo *joinrel,
 							   RelOptInfo *outerrel,
@@ -198,6 +201,7 @@ extern void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel);
 extern PathTarget *set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target);
+extern double get_parallel_divisor(Path *path);
 extern double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel,
 					 Path *bitmapqual, int loop_count, Cost *cost, double *tuple);
 

commit fea0ea9bceb698dbe88bee42d5fc5f3332a658dd
Author: Alexander Korotkov <akorotkov@postgresql.org>
Date:   Wed Sep 26 15:29:43 2018 +0300

    Remove some snapshot functions from TableAmRoutine
    
    snapshot_satisfiesUpdate was unused.  snapshot_satisfiesVacuum was used only
    inside heap_copy_for_cluster, so it was replaced to direct
    heapam_satisfies_vacuum() call.

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91fd..28c475e7bdc 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -483,21 +483,6 @@ heapam_satisfies(TupleTableSlot *slot, Snapshot snapshot)
 	return res;
 }
 
-static HTSU_Result
-heapam_satisfies_update(TupleTableSlot *slot, CommandId curcid)
-{
-	BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-	HTSU_Result res;
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesUpdate(bslot->base.tuple,
-								   curcid,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-}
-
 static HTSV_Result
 heapam_satisfies_vacuum(TupleTableSlot *slot, TransactionId OldestXmin)
 {
@@ -2003,7 +1988,7 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 				break;
 		}
 
-		switch (OldHeap->rd_tableamroutine->snapshot_satisfiesVacuum(slot, OldestXmin))
+		switch (heapam_satisfies_vacuum(slot, OldestXmin))
 		{
 			case HEAPTUPLE_DEAD:
 				/* Definitely dead */
@@ -2122,8 +2107,6 @@ static const TableAmRoutine heapam_methods = {
 	.slot_callbacks = heapam_slot_callbacks,
 
 	.snapshot_satisfies = heapam_satisfies,
-	.snapshot_satisfiesUpdate = heapam_satisfies_update,
-	.snapshot_satisfiesVacuum = heapam_satisfies_vacuum,
 
 	.scan_begin = heap_beginscan,
 	.scansetlimits = heap_setscanlimits,
diff --git a/src/backend/access/zheap/zheapam_handler.c b/src/backend/access/zheap/zheapam_handler.c
index bec9b16f7d6..e707baa1b5d 100644
--- a/src/backend/access/zheap/zheapam_handler.c
+++ b/src/backend/access/zheap/zheapam_handler.c
@@ -486,40 +486,6 @@ zheapam_satisfies(TupleTableSlot *slot, Snapshot snapshot)
 #endif
 }
 
-static HTSU_Result
-zheapam_satisfies_update(TupleTableSlot *slot, CommandId curcid)
-{
-	elog(ERROR, "would need to track buffer or refetch");
-#if ZBORKED
-	BufferHeapTupleTableSlot *zslot = (BufferHeapTupleTableSlot *) slot;
-	HTSU_Result res;
-
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesUpdate(bslot->base.tuple,
-								   curcid,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-#endif
-}
-
-static HTSV_Result
-zheapam_satisfies_vacuum(TupleTableSlot *slot, TransactionId OldestXmin)
-{
-	BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
-	HTSV_Result res;
-
-	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesVacuum(bslot->base.tuple,
-								   OldestXmin,
-								   bslot->buffer);
-	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
-
-	return res;
-}
-
 static IndexFetchTableData*
 zheapam_begin_index_fetch(Relation rel)
 {
@@ -1621,8 +1587,6 @@ static const TableAmRoutine zheapam_methods = {
 	.slot_callbacks = zheapam_slot_callbacks,
 
 	.snapshot_satisfies = zheapam_satisfies,
-	.snapshot_satisfiesUpdate = zheapam_satisfies_update,
-	.snapshot_satisfiesVacuum = zheapam_satisfies_vacuum,
 
 	.scan_begin = zheap_beginscan,
 	.scansetlimits = zheap_setscanlimits,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c221..fb37a739918 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -55,8 +55,6 @@ extern bool synchronize_seqscans;
  * Storage routine function hooks
  */
 typedef bool (*SnapshotSatisfies_function) (TupleTableSlot *slot, Snapshot snapshot);
-typedef HTSU_Result (*SnapshotSatisfiesUpdate_function) (TupleTableSlot *slot, CommandId curcid);
-typedef HTSV_Result (*SnapshotSatisfiesVacuum_function) (TupleTableSlot *slot, TransactionId OldestXmin);
 
 typedef Oid (*TupleInsert_function) (Relation rel, TupleTableSlot *slot, CommandId cid,
 									 int options, BulkInsertState bistate);
@@ -205,8 +203,6 @@ typedef struct TableAmRoutine
 	SlotCallbacks_function slot_callbacks;
 
 	SnapshotSatisfies_function snapshot_satisfies;
-	SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
-	SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
 
 	/* Operations on physical tuples */
 	TupleInsert_function tuple_insert;

From edc69f750fa13e252bff67f4aa615d4fdcec2b5e Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 17:58:27 +1100
Subject: [PATCH 3/3] init fork API

API to create INIT_FORKNUM file with wrapper
table_create_init_fork.
---
 src/backend/access/heap/heapam_handler.c | 27 +++++++++++++++++++++++-
 src/backend/catalog/heap.c               | 24 ++-------------------
 src/backend/commands/tablecmds.c         |  4 ++--
 src/include/access/tableam.h             | 10 +++++++++
 src/include/catalog/heap.h               |  2 --
 5 files changed, 40 insertions(+), 27 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91f..c0cfbe74b1 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -30,6 +30,7 @@
 #include "catalog/catalog.h"
 #include "catalog/index.h"
 #include "catalog/pg_am_d.h"
+#include "catalog/storage_xlog.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
@@ -2116,6 +2117,28 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 	pfree(isnull);
 }
 
+/*
+ * Set up an init fork for an unlogged table so that it can be correctly
+ * reinitialized on restart.  An immediate sync is required even if the
+ * page has been logged, because the write did not go through
+ * shared_buffers and therefore a concurrent checkpoint may have moved
+ * the redo pointer past our xlog record.  Recovery may as well remove it
+ * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
+ * record. Therefore, logging is necessary even if wal_level=minimal.
+ */
+static void
+heap_create_init_fork(Relation rel)
+{
+	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
+		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
+		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
+	RelationOpenSmgr(rel);
+	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
+	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
+	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
+}
+
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2163,7 +2186,9 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.CreateInitFork = heap_create_init_fork
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 38b368f916..8e7c8ce684 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -32,6 +32,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/sysattr.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -1425,7 +1426,7 @@ heap_create_with_catalog(const char *relname,
 	 */
 	if (relpersistence == RELPERSISTENCE_UNLOGGED &&
 		relkind != RELKIND_PARTITIONED_TABLE)
-		heap_create_init_fork(new_rel_desc);
+		table_create_init_fork(new_rel_desc);
 
 	/*
 	 * ok, the relation has been cataloged, so close our relations and return
@@ -1437,27 +1438,6 @@ heap_create_with_catalog(const char *relname,
 	return relid;
 }
 
-/*
- * Set up an init fork for an unlogged table so that it can be correctly
- * reinitialized on restart.  An immediate sync is required even if the
- * page has been logged, because the write did not go through
- * shared_buffers and therefore a concurrent checkpoint may have moved
- * the redo pointer past our xlog record.  Recovery may as well remove it
- * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
- * record. Therefore, logging is necessary even if wal_level=minimal.
- */
-void
-heap_create_init_fork(Relation rel)
-{
-	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
-		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
-		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
-	RelationOpenSmgr(rel);
-	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
-	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
-	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
-}
-
 /*
  *		RelationRemoveInheritance
  *
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index f3526b267d..3c46a48882 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1649,7 +1649,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-				heap_create_init_fork(rel);
+				table_create_init_fork(rel);
 
 			heap_relid = RelationGetRelid(rel);
 			toast_relid = rel->rd_rel->reltoastrelid;
@@ -1663,7 +1663,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 				RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-					heap_create_init_fork(rel);
+					table_create_init_fork(rel);
 				heap_close(rel, NoLock);
 			}
 
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c22..79c71b06e5 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -194,6 +194,8 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*CreateInitFork_function)(Relation rel);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -250,6 +252,8 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	CreateInitFork_function CreateInitFork;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -741,6 +745,12 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline void
+table_create_init_fork(Relation relation)
+{
+	relation->rd_tableamroutine->CreateInitFork(relation);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index 4584b3473c..c0e706ecc9 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -77,8 +77,6 @@ extern Oid heap_create_with_catalog(const char *relname,
 						 Oid relrewrite,
 						 ObjectAddress *typaddress);
 
-extern void heap_create_init_fork(Relation rel);
-
 extern void heap_drop_with_catalog(Oid relid);
 
 extern void heap_truncate(List *relids);
-- 
2.18.0.windows.1

From 3b4974dd4fa27f7a726b49cb8b16828818fe4093 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 16:07:07 +1100
Subject: [PATCH 2/3] Remove the extra Tuple visibility function

In heapgettup_pagemode the tuple visiblity check is added
during the early devlopment of pluggable storage, but the visibility
check is already carried out in heapgetpage function itself.
---
 src/backend/access/heap/heapam.c | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ec99d0bcae..ef6b4c3e54 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -947,31 +947,25 @@ heapgettup_pagemode(HeapScanDesc scan,
 			/*
 			 * if current tuple qualifies, return it.
 			 */
-			if (HeapTupleSatisfies(tuple, scan->rs_scan.rs_snapshot, scan->rs_cbuf))
+			if (key != NULL)
 			{
-				/*
-				 * if current tuple qualifies, return it.
-				 */
-				if (key != NULL)
-				{
-					bool		valid;
+				bool		valid;
 
-					HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
-								nkeys, key, valid);
-					if (valid)
-					{
-						scan->rs_cindex = lineindex;
-						LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
-						return;
-					}
-				}
-				else
+				HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
+							nkeys, key, valid);
+				if (valid)
 				{
 					scan->rs_cindex = lineindex;
 					LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 					return;
 				}
 			}
+			else
+			{
+				scan->rs_cindex = lineindex;
+				LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+				return;
+			}
 
 			/*
 			 * otherwise move to the next item on the page
-- 
2.18.0.windows.1

From ab6169b484b134522a4bacb22f226c3dd4f67e42 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 16:06:10 +1100
Subject: [PATCH 1/3] Remove the old slot interface file and also update the
 Makefile.

---
 src/backend/access/table/Makefile         | 2 +-
 src/backend/access/table/tableam_common.c | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 src/backend/access/table/tableam_common.c

diff --git a/src/backend/access/table/Makefile b/src/backend/access/table/Makefile
index fe22bf9208..006ba99182 100644
--- a/src/backend/access/table/Makefile
+++ b/src/backend/access/table/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/access/table
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = tableam.o tableamapi.o tableam_common.o
+OBJS = tableam.o tableamapi.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/table/tableam_common.c b/src/backend/access/table/tableam_common.c
deleted file mode 100644
index e69de29bb2..0000000000
-- 
2.18.0.windows.1

From 82ae4f7a6ef78c9e04bc5abeeb0593b890ee454b Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 23 Oct 2018 15:42:57 +1100
Subject: [PATCH 1/2] scan start offset fix during analyze

---
 src/backend/access/heap/heapam_handler.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c0cfbe74b1..ae832e1f71 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1742,7 +1742,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 {
 	HeapScanDesc scan = (HeapScanDesc) sscan;
 	Page		targpage;
-	OffsetNumber targoffset = scan->rs_cindex;
+	OffsetNumber targoffset;
 	OffsetNumber maxoffset;
 	BufferHeapTupleTableSlot *hslot;
 
@@ -1752,7 +1752,9 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 	maxoffset = PageGetMaxOffsetNumber(targpage);
 
 	/* Inner loop over all tuples on the selected page */
-	for (targoffset = scan->rs_cindex; targoffset <= maxoffset; targoffset++)
+	for (targoffset = scan->rs_cindex ? scan->rs_cindex : FirstOffsetNumber;
+			targoffset <= maxoffset;
+			targoffset++)
 	{
 		ItemId		itemid;
 		HeapTuple	targtuple = &hslot->base.tupdata;
-- 
2.18.0.windows.1

From 52865d2ede0c6d0b2b8af26d67736124cd44450d Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 23 Oct 2018 17:15:18 +1100
Subject: [PATCH 2/2] Materialize all the slots before they are processed using
 into_rel

---
 src/backend/commands/createas.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 84de804175..27a28a896d 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -593,6 +593,7 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self)
 	if (myState->rel->rd_rel->relhasoids)
 		slot->tts_tupleOid = InvalidOid;
 
+	ExecMaterializeSlot(slot);
 	table_insert(myState->rel,
 				 slot,
 				 myState->output_cid,
-- 
2.18.0.windows.1

From f0d9dbf5c5608beb99b879e7317b68a285bbeab8 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 23 Oct 2018 17:15:18 +1100
Subject: [PATCH 2/2] Materialize the slot before they are processed using
 intorel_receive

---
 src/backend/commands/createas.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 84de804175..d3ffe417ff 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -593,6 +593,10 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self)
 	if (myState->rel->rd_rel->relhasoids)
 		slot->tts_tupleOid = InvalidOid;
 
+	/* Materialize the slot */
+	if (!TTS_IS_VIRTUAL(slot))
+		ExecMaterializeSlot(slot);
+
 	table_insert(myState->rel,
 				 slot,
 				 myState->output_cid,
-- 
2.18.0.windows.1

From 118907d991360848715c893f8a9cf892ecc2bd5b Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 17:58:27 +1100
Subject: [PATCH 2/2] init fork API

API to create INIT_FORKNUM file with wrapper
table_create_init_fork.
---
 src/backend/access/heap/heapam_handler.c | 27 +++++++++++++++++++++++-
 src/backend/catalog/heap.c               | 24 ++-------------------
 src/backend/commands/tablecmds.c         |  4 ++--
 src/include/access/tableam.h             | 10 +++++++++
 src/include/catalog/heap.h               |  2 --
 5 files changed, 40 insertions(+), 27 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 3254e30a45..ae832e1f71 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -30,6 +30,7 @@
 #include "catalog/catalog.h"
 #include "catalog/index.h"
 #include "catalog/pg_am_d.h"
+#include "catalog/storage_xlog.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
@@ -2118,6 +2119,28 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 	pfree(isnull);
 }
 
+/*
+ * Set up an init fork for an unlogged table so that it can be correctly
+ * reinitialized on restart.  An immediate sync is required even if the
+ * page has been logged, because the write did not go through
+ * shared_buffers and therefore a concurrent checkpoint may have moved
+ * the redo pointer past our xlog record.  Recovery may as well remove it
+ * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
+ * record. Therefore, logging is necessary even if wal_level=minimal.
+ */
+static void
+heap_create_init_fork(Relation rel)
+{
+	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
+		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
+		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
+	RelationOpenSmgr(rel);
+	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
+	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
+	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
+}
+
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2165,7 +2188,9 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.CreateInitFork = heap_create_init_fork
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 38b368f916..8e7c8ce684 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -32,6 +32,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/sysattr.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -1425,7 +1426,7 @@ heap_create_with_catalog(const char *relname,
 	 */
 	if (relpersistence == RELPERSISTENCE_UNLOGGED &&
 		relkind != RELKIND_PARTITIONED_TABLE)
-		heap_create_init_fork(new_rel_desc);
+		table_create_init_fork(new_rel_desc);
 
 	/*
 	 * ok, the relation has been cataloged, so close our relations and return
@@ -1437,27 +1438,6 @@ heap_create_with_catalog(const char *relname,
 	return relid;
 }
 
-/*
- * Set up an init fork for an unlogged table so that it can be correctly
- * reinitialized on restart.  An immediate sync is required even if the
- * page has been logged, because the write did not go through
- * shared_buffers and therefore a concurrent checkpoint may have moved
- * the redo pointer past our xlog record.  Recovery may as well remove it
- * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
- * record. Therefore, logging is necessary even if wal_level=minimal.
- */
-void
-heap_create_init_fork(Relation rel)
-{
-	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
-		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
-		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
-	RelationOpenSmgr(rel);
-	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
-	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
-	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
-}
-
 /*
  *		RelationRemoveInheritance
  *
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index f3526b267d..3c46a48882 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1649,7 +1649,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-				heap_create_init_fork(rel);
+				table_create_init_fork(rel);
 
 			heap_relid = RelationGetRelid(rel);
 			toast_relid = rel->rd_rel->reltoastrelid;
@@ -1663,7 +1663,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 				RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-					heap_create_init_fork(rel);
+					table_create_init_fork(rel);
 				heap_close(rel, NoLock);
 			}
 
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c22..79c71b06e5 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -194,6 +194,8 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*CreateInitFork_function)(Relation rel);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -250,6 +252,8 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	CreateInitFork_function CreateInitFork;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -741,6 +745,12 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline void
+table_create_init_fork(Relation relation)
+{
+	relation->rd_tableamroutine->CreateInitFork(relation);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index 4584b3473c..c0e706ecc9 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -77,8 +77,6 @@ extern Oid heap_create_with_catalog(const char *relname,
 						 Oid relrewrite,
 						 ObjectAddress *typaddress);
 
-extern void heap_create_init_fork(Relation rel);
-
 extern void heap_drop_with_catalog(Oid relid);
 
 extern void heap_truncate(List *relids);
-- 
2.18.0.windows.1

From c2dc08ce7d41294cc52cc2820578e5a1668dddf7 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 16:06:10 +1100
Subject: [PATCH 1/2] Further fixes and cleanup

1. Remove the old slot interface file and also update the Makefile.
2. CREATE AS USING method grammer support

This change was missed during earlier USING grammer support.

3. Remove the extra Tuple visibility check

In heapgettup_pagemode the tuple visiblity check is added
during the early devlopment of pluggable storage, but the visibility
check is already carried out in heapgetpage function itself.

regression fixes

1. scan start offset fix during analyze
2. Materialize the slot before they are processed using intorel_receive
3. ROW_MARK_COPY support by force store of heap tuple
4. partition prune extra heap page fix
---
 contrib/pg_visibility/pg_visibility.c     |  5 ++--
 src/backend/access/heap/heapam.c          | 28 +++++++++--------------
 src/backend/access/heap/heapam_handler.c  |  6 +++--
 src/backend/access/table/Makefile         |  2 +-
 src/backend/access/table/tableam_common.c |  0
 src/backend/commands/createas.c           |  4 ++++
 src/backend/executor/execExprInterp.c     |  3 +++
 src/backend/executor/execMain.c           | 13 ++---------
 src/backend/executor/execTuples.c         | 21 +++++++++++++++++
 src/backend/executor/nodeBitmapHeapscan.c | 12 ++++++++++
 src/backend/executor/nodeModifyTable.c    | 12 ++++++++--
 src/backend/parser/gram.y                 | 11 +++++----
 src/include/executor/tuptable.h           |  1 +
 src/include/nodes/primnodes.h             |  1 +
 14 files changed, 79 insertions(+), 40 deletions(-)
 delete mode 100644 src/backend/access/table/tableam_common.c

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index dce5262e34..88ca4fd2af 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -563,12 +563,13 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 
 	rel = relation_open(relid, AccessShareLock);
 
+	/* Only some relkinds have a visibility map */
+	check_relation_relkind(rel);
+
 	if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
 		ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						errmsg("only heap AM is supported")));
 
-	/* Only some relkinds have a visibility map */
-	check_relation_relkind(rel);
 
 	nblocks = RelationGetNumberOfBlocks(rel);
 
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ec99d0bcae..ef6b4c3e54 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -947,31 +947,25 @@ heapgettup_pagemode(HeapScanDesc scan,
 			/*
 			 * if current tuple qualifies, return it.
 			 */
-			if (HeapTupleSatisfies(tuple, scan->rs_scan.rs_snapshot, scan->rs_cbuf))
+			if (key != NULL)
 			{
-				/*
-				 * if current tuple qualifies, return it.
-				 */
-				if (key != NULL)
-				{
-					bool		valid;
+				bool		valid;
 
-					HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
-								nkeys, key, valid);
-					if (valid)
-					{
-						scan->rs_cindex = lineindex;
-						LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
-						return;
-					}
-				}
-				else
+				HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
+							nkeys, key, valid);
+				if (valid)
 				{
 					scan->rs_cindex = lineindex;
 					LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 					return;
 				}
 			}
+			else
+			{
+				scan->rs_cindex = lineindex;
+				LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+				return;
+			}
 
 			/*
 			 * otherwise move to the next item on the page
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91f..3254e30a45 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1741,7 +1741,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 {
 	HeapScanDesc scan = (HeapScanDesc) sscan;
 	Page		targpage;
-	OffsetNumber targoffset = scan->rs_cindex;
+	OffsetNumber targoffset;
 	OffsetNumber maxoffset;
 	BufferHeapTupleTableSlot *hslot;
 
@@ -1751,7 +1751,9 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 	maxoffset = PageGetMaxOffsetNumber(targpage);
 
 	/* Inner loop over all tuples on the selected page */
-	for (targoffset = scan->rs_cindex; targoffset <= maxoffset; targoffset++)
+	for (targoffset = scan->rs_cindex ? scan->rs_cindex : FirstOffsetNumber;
+			targoffset <= maxoffset;
+			targoffset++)
 	{
 		ItemId		itemid;
 		HeapTuple	targtuple = &hslot->base.tupdata;
diff --git a/src/backend/access/table/Makefile b/src/backend/access/table/Makefile
index fe22bf9208..006ba99182 100644
--- a/src/backend/access/table/Makefile
+++ b/src/backend/access/table/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/access/table
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = tableam.o tableamapi.o tableam_common.o
+OBJS = tableam.o tableamapi.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/table/tableam_common.c b/src/backend/access/table/tableam_common.c
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 84de804175..d3ffe417ff 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -593,6 +593,10 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self)
 	if (myState->rel->rd_rel->relhasoids)
 		slot->tts_tupleOid = InvalidOid;
 
+	/* Materialize the slot */
+	if (!TTS_IS_VIRTUAL(slot))
+		ExecMaterializeSlot(slot);
+
 	table_insert(myState->rel,
 				 slot,
 				 myState->output_cid,
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index ef94ac4aa0..12651f5ceb 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -570,6 +570,9 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 				Assert(TTS_IS_HEAPTUPLE(scanslot) ||
 					   TTS_IS_BUFFERTUPLE(scanslot));
 
+				if (hslot->tuple == NULL)
+					ExecMaterializeSlot(scanslot);
+
 				d = heap_getsysattr(hslot->tuple, attnum,
 									scanslot->tts_tupleDescriptor,
 									op->resnull);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index e055c0a7c6..34ef86a5bd 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2594,7 +2594,7 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
 	 * datums that may be present in copyTuple).  As with the next step, this
 	 * is to guard against early re-use of the EPQ query.
 	 */
-	if (!TupIsNull(slot))
+	if (!TupIsNull(slot) && !TTS_IS_VIRTUAL(slot))
 		ExecMaterializeSlot(slot);
 
 #if FIXME
@@ -2787,16 +2787,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			if (isNull)
 				continue;
 
-			elog(ERROR, "frak, need to implement ROW_MARK_COPY");
-#ifdef FIXME
-			// FIXME: this should just deform the tuple and store it as a
-			// virtual one.
-			tuple = table_tuple_by_datum(erm->relation, datum, erm->relid);
-
-			/* store tuple */
-			EvalPlanQualSetTuple(epqstate, erm->rti, tuple);
-#endif
-
+			ExecForceStoreHeapTupleDatum(datum, slot);
 		}
 	}
 }
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 917bf80f71..74149cc3ad 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1364,6 +1364,27 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 	return ExecFinishStoreSlotValues(slot);
 }
 
+void
+ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
+{
+	HeapTuple	tuple;
+	HeapTupleHeader td;
+
+	td = DatumGetHeapTupleHeader(data);
+
+	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + HeapTupleHeaderGetDatumLength(td));
+	tuple->t_len = HeapTupleHeaderGetDatumLength(td);
+	tuple->t_self = td->t_ctid;
+	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+	memcpy((char *) tuple->t_data, (char *) td, tuple->t_len);
+
+	ExecClearTuple(slot);
+
+	heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
+					  slot->tts_values, slot->tts_isnull);
+	ExecFinishStoreSlotValues(slot);
+}
+
 /* --------------------------------
  *		ExecFetchSlotTuple
  *			Fetch the slot's regular physical tuple.
diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index 56880e3d16..36ca07beb2 100644
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -224,6 +224,18 @@ BitmapHeapNext(BitmapHeapScanState *node)
 
 			BitmapAdjustPrefetchIterator(node, tbmres);
 
+			/*
+			 * Ignore any claimed entries past what we think is the end of the
+			 * relation.  (This is probably not necessary given that we got at
+			 * least AccessShareLock on the table before performing any of the
+			 * indexscans, but let's be safe.)
+			 */
+			if (tbmres->blockno >= scan->rs_nblocks)
+			{
+				node->tbmres = tbmres = NULL;
+				continue;
+			}
+
 			/*
 			 * We can skip fetching the heap page if we don't need any fields
 			 * from the heap, and the bitmap entries don't need rechecking,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 3cc9092413..307c12ee69 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -607,7 +607,7 @@ ExecDelete(ModifyTableState *mtstate,
 		   bool canSetTag,
 		   bool changingPart,
 		   bool *tupleDeleted,
-		   TupleTableSlot **epqslot)
+		   TupleTableSlot **epqreturnslot)
 {
 	ResultRelInfo *resultRelInfo;
 	Relation	resultRelationDesc;
@@ -632,7 +632,7 @@ ExecDelete(ModifyTableState *mtstate,
 		bool		dodelete;
 
 		dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
-										tupleid, oldtuple, epqslot);
+										tupleid, oldtuple, epqreturnslot);
 
 		if (!dodelete)			/* "do nothing" */
 			return NULL;
@@ -724,6 +724,14 @@ ldelete:;
 					/* Tuple no more passing quals, exiting... */
 					return NULL;
 				}
+
+				/**/
+				if (epqreturnslot)
+				{
+					*epqreturnslot = epqslot;
+					return NULL;
+				}
+
 				goto ldelete;
 			}
 		}
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 54382aba88..f030ad25a2 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -4037,7 +4037,6 @@ CreateStatsStmt:
  *
  *****************************************************************************/
 
-// PBORKED: storage option
 CreateAsStmt:
 		CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
 				{
@@ -4068,14 +4067,16 @@ CreateAsStmt:
 		;
 
 create_as_target:
-			qualified_name opt_column_list OptWith OnCommitOption OptTableSpace
+			qualified_name opt_column_list table_access_method_clause
+			OptWith OnCommitOption OptTableSpace
 				{
 					$$ = makeNode(IntoClause);
 					$$->rel = $1;
 					$$->colNames = $2;
-					$$->options = $3;
-					$$->onCommit = $4;
-					$$->tableSpaceName = $5;
+					$$->accessMethod = $3;
+					$$->options = $4;
+					$$->onCommit = $5;
+					$$->tableSpaceName = $6;
 					$$->viewQuery = NULL;
 					$$->skipData = false;		/* might get changed later */
 				}
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index 05f38cfd0d..20fc425a27 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -476,6 +476,7 @@ extern TupleTableSlot *ExecCopySlot(TupleTableSlot *dstslot,
 
 extern void ExecForceStoreHeapTuple(HeapTuple tuple,
 			   TupleTableSlot *slot);
+extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 
 extern void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum);
 extern Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull);
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 40f6eb03d2..4d194a8c2a 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -111,6 +111,7 @@ typedef struct IntoClause
 
 	RangeVar   *rel;			/* target relation name */
 	List	   *colNames;		/* column names to assign, or NIL */
+	char	   *accessMethod;	/* table access method */
 	List	   *options;		/* options from WITH clause */
 	OnCommitAction onCommit;	/* what do we do at COMMIT? */
 	char	   *tableSpaceName; /* table space to use, or NULL */
-- 
2.18.0.windows.1

diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 307c12ee69..074593b1cc 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1170,42 +1170,6 @@ lreplace:;
 							  true /* wait for commit */,
 							  &hufd, &lockmode, &update_indexes);
 
-		if (result == HeapTupleUpdated && !IsolationUsesXactSnapshot())
-		{
-			TupleTableSlot *inputslot;
-
-			EvalPlanQualBegin(epqstate, estate);
-
-			inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
-			ExecCopySlot(inputslot, slot);
-
-			result = table_lock_tuple(resultRelationDesc, tupleid,
-									  estate->es_snapshot,
-									  inputslot, estate->es_output_cid,
-									  lockmode, LockWaitBlock,
-									  TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
-									  &hufd);
-			/* hari FIXME*/
-			/*Assert(result != HeapTupleUpdated && hufd.traversed);*/
-			if (result == HeapTupleMayBeUpdated)
-			{
-				TupleTableSlot *epqslot;
-
-				epqslot = EvalPlanQual(estate,
-									   epqstate,
-									   resultRelationDesc,
-									   resultRelInfo->ri_RangeTableIndex,
-									   inputslot);
-				if (TupIsNull(epqslot))
-				{
-					/* Tuple no more passing quals, exiting... */
-					return NULL;
-				}
-				slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
-				goto lreplace;
-			}
-		}
-
 		switch (result)
 		{
 			case HeapTupleSelfUpdated:
@@ -1250,10 +1214,37 @@ lreplace:;
 					ereport(ERROR,
 							(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
 							 errmsg("could not serialize access due to concurrent update")));
-				else
-					/* shouldn't get there */
-					elog(ERROR, "wrong heap_delete status: %u", result);
-				break;
+
+				if (ItemPointerIndicatesMovedPartitions(&hufd.ctid))
+					ereport(ERROR,
+							(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
+							 errmsg("tuple to be updated was already moved to another partition due to concurrent update")));
+
+				if (!ItemPointerEquals(tupleid, &hufd.ctid))
+				{
+					TupleTableSlot *epqslot;
+					TupleTableSlot *inputslot;
+
+					EvalPlanQualBegin(epqstate, estate);
+
+					inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex);
+					ExecCopySlot(inputslot, slot);
+
+					epqslot = EvalPlanQual(estate,
+										   epqstate,
+										   resultRelationDesc,
+										   resultRelInfo->ri_RangeTableIndex,
+										   inputslot);
+					if (!TupIsNull(epqslot))
+					{
+						*tupleid = hufd.ctid;
+						slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
+						slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
+						goto lreplace;
+					}
+				}
+				/* tuple already deleted; nothing to do */
+				return NULL;
 
 			case HeapTupleDeleted:
 				if (IsolationUsesXactSnapshot())

From c34faa5ad6af9ef4562feabd6bb4d361fe813945 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 29 Oct 2018 15:53:30 +1100
Subject: [PATCH] Handling HeapTupleInvisible case

In update/delete scenarios, when the tuple is
concurrently updated/deleted, sometimes locking
of a tuple may return HeapTupleInvisible. Handle
that case as nothing to do.
---
 src/backend/executor/nodeModifyTable.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 307c12ee69..b3851b180d 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -734,6 +734,11 @@ ldelete:;
 
 				goto ldelete;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
@@ -1204,6 +1209,11 @@ lreplace:;
 				slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
 				goto lreplace;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
-- 
2.18.0.windows.1

From 2a530ea1306c291a40fff4042a0b1a5755dcefc9 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 1 Nov 2018 12:00:10 +1100
Subject: [PATCH 3/3] First draft of pluggable-storage documentation

---
 doc/src/sgml/{indexam.sgml => am.sgml}     | 590 ++++++++++++++++++++-
 doc/src/sgml/catalogs.sgml                 |   5 +-
 doc/src/sgml/config.sgml                   |  24 +
 doc/src/sgml/filelist.sgml                 |   2 +-
 doc/src/sgml/postgres.sgml                 |   2 +-
 doc/src/sgml/ref/create_access_method.sgml |  12 +-
 doc/src/sgml/ref/create_table.sgml         |  18 +-
 doc/src/sgml/ref/create_table_as.sgml      |  14 +
 doc/src/sgml/release-9.6.sgml              |   2 +-
 doc/src/sgml/xindex.sgml                   |   2 +-
 10 files changed, 640 insertions(+), 31 deletions(-)
 rename doc/src/sgml/{indexam.sgml => am.sgml} (78%)

diff --git a/doc/src/sgml/indexam.sgml b/doc/src/sgml/am.sgml
similarity index 78%
rename from doc/src/sgml/indexam.sgml
rename to doc/src/sgml/am.sgml
index beb99d1831..dc13bc1073 100644
--- a/doc/src/sgml/indexam.sgml
+++ b/doc/src/sgml/am.sgml
@@ -1,16 +1,20 @@
-<!-- doc/src/sgml/indexam.sgml -->
+<!-- doc/src/sgml/am.sgml -->
 
-<chapter id="indexam">
- <title>Index Access Method Interface Definition</title>
+<chapter id="am">
+ <title>Access Method Interface Definition</title>
 
   <para>
    This chapter defines the interface between the core
-   <productname>PostgreSQL</productname> system and <firstterm>index access
-   methods</firstterm>, which manage individual index types.  The core system
-   knows nothing about indexes beyond what is specified here, so it is
-   possible to develop entirely new index types by writing add-on code.
+   <productname>PostgreSQL</productname> system and <firstterm>access
+   methods</firstterm>, which manage individual <literal>INDEX</literal> 
+   and <literal>TABLE</literal> types.  The core system knows nothing
+   about these access methods beyond what is specified here, so it is
+   possible to develop entirely new access method types by writing add-on code.
   </para>
-
+ 
+ <sect1 id="index-access-methods">
+  <title>Overview of Index access methods</title>
+  
   <para>
    All indexes in <productname>PostgreSQL</productname> are what are known
    technically as <firstterm>secondary indexes</firstterm>; that is, the index is
@@ -42,8 +46,8 @@
    dead tuples are reclaimed (by vacuuming) when the dead tuples themselves
    are reclaimed.
   </para>
-
- <sect1 id="index-api">
+  
+ <sect2 id="index-api">
   <title>Basic API Structure for Indexes</title>
 
   <para>
@@ -217,9 +221,9 @@ typedef struct IndexAmRoutine
    conditions.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-functions">
+ <sect2 id="index-functions">
   <title>Index Access Method Functions</title>
 
   <para>
@@ -709,9 +713,11 @@ amparallelrescan (IndexScanDesc scan);
    the beginning.
   </para>
 
- </sect1>
+ </sect2>
+ 
+ 
 
- <sect1 id="index-scanning">
+ <sect2 id="index-scanning">
   <title>Index Scanning</title>
 
   <para>
@@ -864,9 +870,9 @@ amparallelrescan (IndexScanDesc scan);
    if its internal implementation is unsuited to one API or the other.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-locking">
+ <sect2 id="index-locking">
   <title>Index Locking Considerations</title>
 
   <para>
@@ -978,9 +984,9 @@ amparallelrescan (IndexScanDesc scan);
    reduce the frequency of such transaction cancellations.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-unique-checks">
+ <sect2 id="index-unique-checks">
   <title>Index Uniqueness Checks</title>
 
   <para>
@@ -1127,9 +1133,9 @@ amparallelrescan (IndexScanDesc scan);
     </itemizedlist>
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-cost-estimation">
+ <sect2 id="index-cost-estimation">
   <title>Index Cost Estimation Functions</title>
 
   <para>
@@ -1376,5 +1382,549 @@ cost_qual_eval(&amp;index_qual_cost, path-&gt;indexquals, root);
    Examples of cost estimator functions can be found in
    <filename>src/backend/utils/adt/selfuncs.c</filename>.
   </para>
+ </sect2>
  </sect1>
+ 
+ <sect1 id="table-access-methods">
+  <title>Overview of Table access methods </title>
+  
+  <para>
+   All Tables in <productname>PostgreSQL</productname> are the primary data store.
+   Each table is stored as its own physical <firstterm>relation</firstterm> and so
+   is described by an entry in the <structname>pg_class</structname> catalog.
+   The contents of an table are entirely under the control of its access method.
+   (All the access methods furthermore use the standard page layout described in
+   <xref linkend="storage-page-layout"/>.)
+  </para>
+  
+ <sect2 id="table-api">
+  <title>Table access method API</title>
+  
+  <para>
+   Each table access method is described by a row in the
+   <link linkend="catalog-pg-am"><structname>pg_am</structname></link>
+   system catalog.  The <structname>pg_am</structname> entry
+   specifies a name and a <firstterm>handler function</firstterm> for the access
+   method.  These entries can be created and deleted using the
+   <xref linkend="sql-create-access-method"/> and
+   <xref linkend="sql-drop-access-method"/> SQL commands.
+  </para>
+
+  <para>
+   A table access method handler function must be declared to accept a
+   single argument of type <type>internal</type> and to return the
+   pseudo-type <type>table_am_handler</type>.  The argument is a dummy value that
+   simply serves to prevent handler functions from being called directly from
+   SQL commands.  The result of the function must be a palloc'd struct of
+   type <structname>TableAmRoutine</structname>, which contains everything
+   that the core code needs to know to make use of the table access method.
+   The <structname>TableAmRoutine</structname> struct, also called the access
+   method's <firstterm>API struct</firstterm>, includes fields specifying assorted
+   fixed properties of the access method, such as whether it can support
+   bitmap scans.  More importantly, it contains pointers to support
+   functions for the access method, which do all of the real work to access
+   tables.  These support functions are plain C functions and are not
+   visible or callable at the SQL level.  The support functions are described
+   in <xref linkend="table-functions"/>.
+  </para>
+
+  <para>
+   The structure <structname>TableAmRoutine</structname> is defined thus:
+<programlisting>
+typedef struct TableAmRoutine
+{
+    NodeTag     type;
+
+    SlotCallbacks_function slot_callbacks;
+
+    SnapshotSatisfies_function snapshot_satisfies;
+    SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
+    SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
+
+    /* Operations on physical tuples */
+    TupleInsert_function tuple_insert;
+    TupleInsertSpeculative_function tuple_insert_speculative;
+    TupleCompleteSpeculative_function tuple_complete_speculative;
+    TupleUpdate_function tuple_update;
+    TupleDelete_function tuple_delete;
+    TupleFetchRowVersion_function tuple_fetch_row_version;
+    TupleLock_function tuple_lock;
+    MultiInsert_function multi_insert;
+    TupleGetLatestTid_function tuple_get_latest_tid;
+    TupleFetchFollow_function tuple_fetch_follow;
+
+    GetTupleData_function get_tuple_data;
+
+    RelationVacuum_function relation_vacuum;
+    RelationScanAnalyzeNextBlock_function scan_analyze_next_block;
+    RelationScanAnalyzeNextTuple_function scan_analyze_next_tuple;
+    RelationCopyForCluster_function relation_copy_for_cluster;
+    RelationSync_function relation_sync;
+
+    /* Operations on relation scans */
+    ScanBegin_function scan_begin;
+    ScanSetlimits_function scansetlimits;
+    ScanGetnextSlot_function scan_getnextslot;
+
+    BitmapPagescan_function scan_bitmap_pagescan;
+    BitmapPagescanNext_function scan_bitmap_pagescan_next;
+
+    SampleScanNextBlock_function scan_sample_next_block;
+    SampleScanNextTuple_function scan_sample_next_tuple;
+
+    ScanEnd_function scan_end;
+    ScanRescan_function scan_rescan;
+    ScanUpdateSnapshot_function scan_update_snapshot;
+
+    BeginIndexFetchTable_function begin_index_fetch;
+    EndIndexFetchTable_function reset_index_fetch;
+    EndIndexFetchTable_function end_index_fetch;
+
+
+    IndexBuildRangeScan_function index_build_range_scan;
+    IndexValidateScan_function index_validate_scan;
+
+    CreateInitFork_function CreateInitFork;
+}           TableAmRoutine;
+</programlisting>
+  </para>
+  
+  <para>
+   An individual table is defined by a
+   <link linkend="catalog-pg-class"><structname>pg_class</structname></link>
+   entry that describes it as a physical relation.
+  </para>
+   
+ </sect2>
+ 
+ <sect2 id="table-functions">
+  <title>Table Access Method Functions</title>
+
+  <para>
+   The table construction and maintenance functions that an table access
+   method must provide in <structname>TableAmRoutine</structname> are:
+  </para>
+
+  <para>
+<programlisting>
+TupleTableSlotOps *
+slot_callbacks (Relation relation);
+</programlisting>
+   API to access the slot specific methods;
+   Following methods are available; 
+   <structname>TTSOpsVirtual</structname>,
+   <structname>TTSOpsHeapTuple</structname>,
+   <structname>TTSOpsMinimalTuple</structname>,
+   <structname>TTSOpsBufferTuple</structname>,
+  </para>
+  
+  <para>
+<programlisting>
+bool
+snapshot_satisfies (TupleTableSlot *slot, Snapshot snapshot);
+</programlisting>
+   API to check whether the provided slot is visible to the current
+   transaction according the snapshot.
+  </para>
+ 
+  <para>
+<programlisting>
+Oid
+tuple_insert (Relation rel, TupleTableSlot *slot, CommandId cid,
+              int options, BulkInsertState bistate);
+</programlisting>
+   API to insert the tuple and provide the <literal>ItemPointerData</literal>
+   where the tuple is successfully inserted.
+  </para>
+  
+  <para>
+<programlisting>
+Oid
+tuple_insert_speculative (Relation rel,
+                         TupleTableSlot *slot,
+                         CommandId cid,
+                         int options,
+                         BulkInsertState bistate,
+                         uint32 specToken);
+</programlisting>
+   API to insert the tuple with a speculative token. This API is similar
+   like <literal>tuple_insert</literal>, with additional speculative
+   information.
+  </para>
+  
+  <para>
+<programlisting>
+void
+tuple_complete_speculative (Relation rel,
+                          TupleTableSlot *slot,
+                          uint32 specToken,
+                          bool succeeded);
+</programlisting>
+   API to complete the state of the tuple inserted by the API <literal>tuple_insert_speculative</literal>
+   with the successful completion of the index insert.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+tuple_update (Relation relation,
+             ItemPointer otid,
+             TupleTableSlot *slot,
+             CommandId cid,
+             Snapshot crosscheck,
+             bool wait,
+             HeapUpdateFailureData *hufd,
+             LockTupleMode *lockmode,
+             bool *update_indexes);
+</programlisting>
+   API to update the existing tuple with new data.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+tuple_delete (Relation relation,
+             ItemPointer tid,
+             CommandId cid,
+             Snapshot crosscheck,
+             bool wait,
+             HeapUpdateFailureData *hufd,
+             bool changingPart);
+</programlisting>
+   API to delete the existing tuple.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+tuple_fetch_row_version (Relation relation,
+                       ItemPointer tid,
+                       Snapshot snapshot,
+                       TupleTableSlot *slot,
+                       Relation stats_relation);
+</programlisting>
+   API to fetch and store the Buffered Heap tuple in the provided slot
+   based on the ItemPointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+TupleLock_function (Relation relation,
+                   ItemPointer tid,
+                   Snapshot snapshot,
+                   TupleTableSlot *slot,
+                   CommandId cid,
+                   LockTupleMode mode,
+                   LockWaitPolicy wait_policy,
+                   uint8 flags,
+                   HeapUpdateFailureData *hufd);
+</programlisting>
+   API to lock the specified the ItemPointer tuple and fetches the newest version of
+   its tuple and TID.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+multi_insert (Relation relation, TupleTableSlot **slots, int nslots,
+              CommandId cid, int options, BulkInsertState bistate);
+</programlisting>
+   API to insert multiple tuples at a time into the relation.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+tuple_get_latest_tid (Relation relation,
+                    Snapshot snapshot,
+                    ItemPointer tid);
+</programlisting>
+   API to get the the latest TID of the tuple with the given itempointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+tuple_fetch_follow (struct IndexFetchTableData *scan,
+                  ItemPointer tid,
+                  Snapshot snapshot,
+                  TupleTableSlot *slot,
+                  bool *call_again, bool *all_dead);
+</programlisting>
+   API to get the all the tuples of the page that satisfies itempointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+tuple_data
+get_tuple_data (TupleTableSlot *slot, tuple_data_flags flags);
+</programlisting>
+   API to return the internal structure members of the HeapTuple.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_vacuum (Relation onerel, int options,
+                struct VacuumParams *params, BufferAccessStrategy bstrategy);
+</programlisting>
+   API to perform vacuum for one heap relation.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+scan_analyze_next_block (TableScanDesc scan, BlockNumber blockno,
+                      BufferAccessStrategy bstrategy);
+</programlisting>
+   API to fill the scan descriptor with the buffer of the specified block.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+scan_analyze_next_tuple (TableScanDesc scan, TransactionId OldestXmin,
+                      double *liverows, double *deadrows, TupleTableSlot *slot));
+</programlisting>
+   API to analyze the block and fill the buffered heap tuple in the slot and also
+   provide the live and dead rows.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_copy_for_cluster (Relation NewHeap, Relation OldHeap, Relation OldIndex,
+                       bool use_sort,
+                       TransactionId OldestXmin, TransactionId FreezeXid, MultiXactId MultiXactCutoff,
+                       double *num_tuples, double *tups_vacuumed, double *tups_recently_dead);
+</programlisting>
+   API to copy one relation to another relation eith using the Index or table scan.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_sync (Relation relation);
+</programlisting>
+   API to sync the relation to disk, useful for the cases where no WAL is written.
+  </para>
+  
+  
+  <para>
+<programlisting>
+TableScanDesc
+scan_begin (Relation relation,
+            Snapshot snapshot,
+            int nkeys, ScanKey key,
+            ParallelTableScanDesc parallel_scan,
+            bool allow_strat,
+            bool allow_sync,
+            bool allow_pagemode,
+            bool is_bitmapscan,
+            bool is_samplescan,
+            bool temp_snap);
+</programlisting>
+   API to start the relation scan for the provided relation and returns the
+   <structname>TableScanDesc</structname> structure.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scansetlimits (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks);
+</programlisting>
+   API to fix the relation scan range limits.
+  </para>
+  
+  
+    <para>
+<programlisting>
+TupleTableSlot *
+scan_getnextslot (TableScanDesc scan,
+                 ScanDirection direction, TupleTableSlot *slot);
+</programlisting>
+   API to fill the next visible tuple from the relation scan in the provided slot
+   and return it.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_bitmap_pagescan (TableScanDesc scan,
+                    TBMIterateResult *tbmres);
+</programlisting>
+   API to scan the relation and fill the scan description bitmap with valid item pointers
+   for the specified block.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_bitmap_pagescan_next (TableScanDesc scan,
+                        TupleTableSlot *slot);
+</programlisting>
+   API to fill the buffered heap tuple data from the bitmap scanned item pointers and store
+   it in the provided slot.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_sample_next_block (TableScanDesc scan, struct SampleScanState *scanstate);
+</programlisting>
+   API to scan the relation and fill the scan description bitmap with valid item pointers
+   for the specified block provided by the sample method.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_sample_next_tuple (TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
+</programlisting>
+   API to fill the buffered heap tuple data from the bitmap scanned item pointers based on the sample
+   method and store it in the provided slot.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scan_end (TableScanDesc scan);
+</programlisting>
+   API to end the relation scan.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scan_rescan (TableScanDesc scan, ScanKey key, bool set_params,
+             bool allow_strat, bool allow_sync, bool allow_pagemode);
+</programlisting>
+   API to restart the relation scan with provided data.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+scan_update_snapshot (TableScanDesc scan, Snapshot snapshot);
+</programlisting>
+   API to update the relation scan with the new snapshot.
+  </para>
+  
+  <para>
+<programlisting>
+IndexFetchTableData *
+begin_index_fetch (Relation relation);
+</programlisting>
+   API to prepare the <structname>IndexFetchTableData</structname> for the relation.
+  </para>
+  
+  <para>
+<programlisting>
+void
+reset_index_fetch (struct IndexFetchTableData* data);
+</programlisting>
+   API to reset the prepared internal members of the <structname>IndexFetchTableData</structname>.
+  </para>
+  
+  <para>
+<programlisting>
+void
+end_index_fetch (struct IndexFetchTableData* data);
+</programlisting>
+   API to clear and free the <structname>IndexFetchTableData</structname>.
+  </para>
+  
+    <para>
+<programlisting>
+double
+index_build_range_scan (Relation heapRelation,
+                       Relation indexRelation,
+                       IndexInfo *indexInfo,
+                       bool allow_sync,
+                       bool anyvisible,
+                       BlockNumber start_blockno,
+                       BlockNumber end_blockno,
+                       IndexBuildCallback callback,
+                       void *callback_state,
+                       TableScanDesc scan);
+</programlisting>
+   API to perform the table scan with bounded range specified by the caller
+   and insert the satisfied records into the index using the provided callback
+   function pointer.
+  </para>
+  
+    <para>
+<programlisting>
+void
+index_validate_scan (Relation heapRelation,
+                   Relation indexRelation,
+                   IndexInfo *indexInfo,
+                   Snapshot snapshot,
+                   struct ValidateIndexState *state);
+</programlisting>
+   API to perform the table scan and insert the satisfied records into the index.
+   This API is similar like <function>index_build_range_scan</function>. This 
+   is used in the scenario of concurrent index build.
+  </para>
+  
+ </sect2>
+ 
+ <sect2>
+  <title>Table scanning</title>
+  
+  <para>
+  </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table insert/update/delete</title>
+
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table locking</title>
+
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table vacuum</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table fetch</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ </sect1> 
 </chapter>
diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index 0179deea2e..f0c8037bbc 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -587,8 +587,9 @@
    The catalog <structname>pg_am</structname> stores information about
    relation access methods.  There is one row for each access method supported
    by the system.
-   Currently, only indexes have access methods.  The requirements for index
-   access methods are discussed in detail in <xref linkend="indexam"/>.
+   Currently, only <literal>INDEX</literal> and <literal>TABLE</literal> have
+   access methods.  The requirements for access methods are discussed in detail
+   in <xref linkend="am"/>.
   </para>
 
   <table>
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index f11b8f724c..8765d7c57c 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -6585,6 +6585,30 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-default-table-access-method" xreflabel="default_table_access_method">
+      <term><varname>default_table_access_method</varname> (<type>string</type>)
+      <indexterm>
+       <primary><varname>default_table_access_method</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        This variable specifies the default table access method using which to create
+        objects (tables and materialized views) when a <command>CREATE</command> command does
+        not explicitly specify a access method.
+       </para>
+
+       <para>
+        The value is either the name of a table access method, or an empty string
+        to specify using the default table access method of the current database.
+        If the value does not match the name of any existing table access methods,
+        <productname>PostgreSQL</productname> will automatically use the default
+        table access method of the current database.
+       </para>
+
+      </listitem>
+     </varlistentry>
+     
      <varlistentry id="guc-default-tablespace" xreflabel="default_tablespace">
       <term><varname>default_tablespace</varname> (<type>string</type>)
       <indexterm>
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 48ac14a838..99a6496502 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -90,7 +90,7 @@
 <!ENTITY gin        SYSTEM "gin.sgml">
 <!ENTITY brin       SYSTEM "brin.sgml">
 <!ENTITY planstats    SYSTEM "planstats.sgml">
-<!ENTITY indexam    SYSTEM "indexam.sgml">
+<!ENTITY am         SYSTEM "am.sgml">
 <!ENTITY nls        SYSTEM "nls.sgml">
 <!ENTITY plhandler  SYSTEM "plhandler.sgml">
 <!ENTITY fdwhandler SYSTEM "fdwhandler.sgml">
diff --git a/doc/src/sgml/postgres.sgml b/doc/src/sgml/postgres.sgml
index 0070603fc3..3e66ae9c8a 100644
--- a/doc/src/sgml/postgres.sgml
+++ b/doc/src/sgml/postgres.sgml
@@ -251,7 +251,7 @@
   &tablesample-method;
   &custom-scan;
   &geqo;
-  &indexam;
+  &am;
   &generic-wal;
   &btree;
   &gist;
diff --git a/doc/src/sgml/ref/create_access_method.sgml b/doc/src/sgml/ref/create_access_method.sgml
index 851c5e63be..256914022a 100644
--- a/doc/src/sgml/ref/create_access_method.sgml
+++ b/doc/src/sgml/ref/create_access_method.sgml
@@ -61,7 +61,8 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
     <listitem>
      <para>
       This clause specifies the type of access method to define.
-      Only <literal>INDEX</literal> is supported at present.
+      Only <literal>INDEX</literal> and <literal>TABLE</literal>
+      are supported at present.
      </para>
     </listitem>
    </varlistentry>
@@ -76,9 +77,12 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
       declared to take a single argument of type <type>internal</type>,
       and its return type depends on the type of access method;
       for <literal>INDEX</literal> access methods, it must
-      be <type>index_am_handler</type>.  The C-level API that the handler
-      function must implement varies depending on the type of access method.
-      The index access method API is described in <xref linkend="indexam"/>.
+      be <type>index_am_handler</type> and for <literal>TABLE</literal>
+      access methods, it must be <type>table_am_handler</type>.
+      The C-level API that the handler function must implement varies
+      depending on the type of access method. The index access method API
+      is described in <xref linkend="index-access-methods"/> and the table access method
+      API is described in <xref linkend="table-access-methods"/>.
      </para>
     </listitem>
    </varlistentry>
diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml
index 10428f8ff0..87e0f01ab2 100644
--- a/doc/src/sgml/ref/create_table.sgml
+++ b/doc/src/sgml/ref/create_table.sgml
@@ -29,6 +29,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
 ] )
 [ INHERITS ( <replaceable>parent_table</replaceable> [, ... ] ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -40,6 +41,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -51,6 +53,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ] { FOR VALUES <replaceable class="parameter">partition_bound_spec</replaceable> | DEFAULT }
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -955,7 +958,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
 
      <para>
       The access method must support <literal>amgettuple</literal> (see <xref
-      linkend="indexam"/>); at present this means <acronym>GIN</acronym>
+      linkend="index-access-methods"/>); at present this means <acronym>GIN</acronym>
       cannot be used.  Although it's allowed, there is little point in using
       B-tree or hash indexes with an exclusion constraint, because this
       does nothing that an ordinary unique constraint doesn't do better.
@@ -1138,6 +1141,19 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/ref/create_table_as.sgml b/doc/src/sgml/ref/create_table_as.sgml
index 527138e787..2acf52d2f5 100644
--- a/doc/src/sgml/ref/create_table_as.sgml
+++ b/doc/src/sgml/ref/create_table_as.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
     [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -120,6 +121,19 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml
index acb6a88b31..68c79db4b5 100644
--- a/doc/src/sgml/release-9.6.sgml
+++ b/doc/src/sgml/release-9.6.sgml
@@ -10081,7 +10081,7 @@ This commit is also listed under libpq and PL/pgSQL
 2016-08-13 [ed0097e4f] Add SQL-accessible functions for inspecting index AM pro
 -->
        <para>
-        Restructure <link linkend="indexam">index access
+        Restructure <link linkend="index-access-methods">index access
         method <acronym>API</acronym></link> to hide most of it at
         the <application>C</application> level (Alexander Korotkov, Andrew Gierth)
        </para>
diff --git a/doc/src/sgml/xindex.sgml b/doc/src/sgml/xindex.sgml
index 9446f8b836..4fa821160c 100644
--- a/doc/src/sgml/xindex.sgml
+++ b/doc/src/sgml/xindex.sgml
@@ -36,7 +36,7 @@
    described in <classname>pg_am</classname>.  It is possible to add a
    new index access method by writing the necessary code and
    then creating an entry in <classname>pg_am</classname> &mdash; but that is
-   beyond the scope of this chapter (see <xref linkend="indexam"/>).
+   beyond the scope of this chapter (see <xref linkend="am"/>).
   </para>
 
   <para>
-- 
2.18.0.windows.1

From caf9356688a722c2246969e2f1421bf25c7c882e Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 17:58:27 +1100
Subject: [PATCH 2/3] New API's are added

1. init fork API
2. set New filenode
3. Estimate rel size

Set New filenode and estimate rel size are added as function hooks
and these not complusory for heap, when they exist, it take over
the control.
---
 src/backend/access/heap/heapam_handler.c | 27 +++++++++++++++++++++++-
 src/backend/catalog/heap.c               | 24 ++-------------------
 src/backend/commands/tablecmds.c         |  4 ++--
 src/backend/optimizer/util/plancat.c     | 12 +++++++++++
 src/backend/utils/cache/relcache.c       | 12 +++++++++++
 src/include/access/tableam.h             | 16 ++++++++++++++
 src/include/catalog/heap.h               |  2 --
 7 files changed, 70 insertions(+), 27 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 3254e30a45..ae832e1f71 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -30,6 +30,7 @@
 #include "catalog/catalog.h"
 #include "catalog/index.h"
 #include "catalog/pg_am_d.h"
+#include "catalog/storage_xlog.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
@@ -2118,6 +2119,28 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 	pfree(isnull);
 }
 
+/*
+ * Set up an init fork for an unlogged table so that it can be correctly
+ * reinitialized on restart.  An immediate sync is required even if the
+ * page has been logged, because the write did not go through
+ * shared_buffers and therefore a concurrent checkpoint may have moved
+ * the redo pointer past our xlog record.  Recovery may as well remove it
+ * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
+ * record. Therefore, logging is necessary even if wal_level=minimal.
+ */
+static void
+heap_create_init_fork(Relation rel)
+{
+	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
+		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
+		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
+	RelationOpenSmgr(rel);
+	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
+	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
+	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
+}
+
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2165,7 +2188,9 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.CreateInitFork = heap_create_init_fork
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 38b368f916..8e7c8ce684 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -32,6 +32,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/sysattr.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -1425,7 +1426,7 @@ heap_create_with_catalog(const char *relname,
 	 */
 	if (relpersistence == RELPERSISTENCE_UNLOGGED &&
 		relkind != RELKIND_PARTITIONED_TABLE)
-		heap_create_init_fork(new_rel_desc);
+		table_create_init_fork(new_rel_desc);
 
 	/*
 	 * ok, the relation has been cataloged, so close our relations and return
@@ -1437,27 +1438,6 @@ heap_create_with_catalog(const char *relname,
 	return relid;
 }
 
-/*
- * Set up an init fork for an unlogged table so that it can be correctly
- * reinitialized on restart.  An immediate sync is required even if the
- * page has been logged, because the write did not go through
- * shared_buffers and therefore a concurrent checkpoint may have moved
- * the redo pointer past our xlog record.  Recovery may as well remove it
- * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
- * record. Therefore, logging is necessary even if wal_level=minimal.
- */
-void
-heap_create_init_fork(Relation rel)
-{
-	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
-		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
-		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
-	RelationOpenSmgr(rel);
-	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
-	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
-	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
-}
-
 /*
  *		RelationRemoveInheritance
  *
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index f3526b267d..3c46a48882 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1649,7 +1649,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-				heap_create_init_fork(rel);
+				table_create_init_fork(rel);
 
 			heap_relid = RelationGetRelid(rel);
 			toast_relid = rel->rd_rel->reltoastrelid;
@@ -1663,7 +1663,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 				RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-					heap_create_init_fork(rel);
+					table_create_init_fork(rel);
 				heap_close(rel, NoLock);
 			}
 
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 8da468a86f..3355f8bff4 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -947,6 +947,18 @@ estimate_rel_size(Relation rel, int32 *attr_widths,
 	BlockNumber relallvisible;
 	double		density;
 
+	/*
+	 * If the relation contains any specific EstimateRelSize
+	 * function, use that instead of the regular default heap method.
+	 */
+	if (rel->rd_tableamroutine &&
+			rel->rd_tableamroutine->EstimateRelSize)
+	{
+		rel->rd_tableamroutine->EstimateRelSize(rel, attr_widths, pages,
+												tuples, allvisfrac);
+		return;
+	}
+
 	switch (rel->rd_rel->relkind)
 	{
 		case RELKIND_RELATION:
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 0d6e5a189f..9cc8e98e40 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -3424,6 +3424,18 @@ RelationSetNewRelfilenode(Relation relation, char persistence,
 	HeapTuple	tuple;
 	Form_pg_class classform;
 
+	/*
+	 * If the relation contains any specific SetNewFilenode
+	 * function, use that instead of the regular default heap method.
+	 */
+	if (relation->rd_tableamroutine &&
+			relation->rd_tableamroutine->SetNewFileNode)
+	{
+		relation->rd_tableamroutine->SetNewFileNode(relation, persistence,
+													freezeXid, minmulti);
+		return;
+	}
+
 	/* Indexes, sequences must have Invalid frozenxid; other rels must not */
 	Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
 			relation->rd_rel->relkind == RELKIND_SEQUENCE) ?
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c22..eb7c9b8007 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -194,6 +194,12 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*CreateInitFork_function)(Relation rel);
+typedef void (*EstimateRelSize_function)(Relation rel, int32 *attr_widths,
+				  BlockNumber *pages, double *tuples, double *allvisfrac);
+typedef void (*SetNewFileNode_function)(Relation relation, char persistence,
+										TransactionId freezeXid, MultiXactId minmulti);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -250,6 +256,10 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	CreateInitFork_function CreateInitFork;
+	EstimateRelSize_function EstimateRelSize;
+	SetNewFileNode_function	SetNewFileNode;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -741,6 +751,12 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline void
+table_create_init_fork(Relation relation)
+{
+	relation->rd_tableamroutine->CreateInitFork(relation);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index 4584b3473c..c0e706ecc9 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -77,8 +77,6 @@ extern Oid heap_create_with_catalog(const char *relname,
 						 Oid relrewrite,
 						 ObjectAddress *typaddress);
 
-extern void heap_create_init_fork(Relation rel);
-
 extern void heap_drop_with_catalog(Oid relid);
 
 extern void heap_truncate(List *relids);
-- 
2.18.0.windows.1

From 5b03e5e2aab35477e409b531cca09e9fef528e6f Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 16:06:10 +1100
Subject: [PATCH 1/3] Further fixes and cleanup

1. Remove the old slot interface file and also update the Makefile.
2. CREATE AS USING method grammer support

This change was missed during earlier USING grammer support.

3. Remove the extra Tuple visibility check

In heapgettup_pagemode the tuple visiblity check is added
during the early devlopment of pluggable storage, but the visibility
check is already carried out in heapgetpage function itself.

4. Handling HeapTupleInvisible case

In update/delete scenarios, when the tuple is
concurrently updated/deleted, sometimes locking
of a tuple may return HeapTupleInvisible. Handle
that case as nothing to do.

regression fixes

1. scan start offset fix during analyze
2. Materialize the slot before they are processed using intorel_receive
3. ROW_MARK_COPY support by force store of heap tuple
4. partition prune extra heap page fix
---
 contrib/pg_visibility/pg_visibility.c     |  5 ++--
 src/backend/access/heap/heapam.c          | 28 +++++++++--------------
 src/backend/access/heap/heapam_handler.c  |  6 +++--
 src/backend/access/table/Makefile         |  2 +-
 src/backend/access/table/tableam_common.c |  0
 src/backend/commands/createas.c           |  4 ++++
 src/backend/executor/execExprInterp.c     | 16 +++++--------
 src/backend/executor/execMain.c           | 13 ++---------
 src/backend/executor/execTuples.c         | 21 +++++++++++++++++
 src/backend/executor/nodeBitmapHeapscan.c | 12 ++++++++++
 src/backend/executor/nodeModifyTable.c    | 22 ++++++++++++++++--
 src/backend/parser/gram.y                 | 11 +++++----
 src/include/executor/tuptable.h           |  1 +
 src/include/nodes/primnodes.h             |  1 +
 14 files changed, 92 insertions(+), 50 deletions(-)
 delete mode 100644 src/backend/access/table/tableam_common.c

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index dce5262e34..88ca4fd2af 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -563,12 +563,13 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 
 	rel = relation_open(relid, AccessShareLock);
 
+	/* Only some relkinds have a visibility map */
+	check_relation_relkind(rel);
+
 	if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
 		ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						errmsg("only heap AM is supported")));
 
-	/* Only some relkinds have a visibility map */
-	check_relation_relkind(rel);
 
 	nblocks = RelationGetNumberOfBlocks(rel);
 
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ec99d0bcae..ef6b4c3e54 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -947,31 +947,25 @@ heapgettup_pagemode(HeapScanDesc scan,
 			/*
 			 * if current tuple qualifies, return it.
 			 */
-			if (HeapTupleSatisfies(tuple, scan->rs_scan.rs_snapshot, scan->rs_cbuf))
+			if (key != NULL)
 			{
-				/*
-				 * if current tuple qualifies, return it.
-				 */
-				if (key != NULL)
-				{
-					bool		valid;
+				bool		valid;
 
-					HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
-								nkeys, key, valid);
-					if (valid)
-					{
-						scan->rs_cindex = lineindex;
-						LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
-						return;
-					}
-				}
-				else
+				HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
+							nkeys, key, valid);
+				if (valid)
 				{
 					scan->rs_cindex = lineindex;
 					LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 					return;
 				}
 			}
+			else
+			{
+				scan->rs_cindex = lineindex;
+				LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+				return;
+			}
 
 			/*
 			 * otherwise move to the next item on the page
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91f..3254e30a45 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1741,7 +1741,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 {
 	HeapScanDesc scan = (HeapScanDesc) sscan;
 	Page		targpage;
-	OffsetNumber targoffset = scan->rs_cindex;
+	OffsetNumber targoffset;
 	OffsetNumber maxoffset;
 	BufferHeapTupleTableSlot *hslot;
 
@@ -1751,7 +1751,9 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 	maxoffset = PageGetMaxOffsetNumber(targpage);
 
 	/* Inner loop over all tuples on the selected page */
-	for (targoffset = scan->rs_cindex; targoffset <= maxoffset; targoffset++)
+	for (targoffset = scan->rs_cindex ? scan->rs_cindex : FirstOffsetNumber;
+			targoffset <= maxoffset;
+			targoffset++)
 	{
 		ItemId		itemid;
 		HeapTuple	targtuple = &hslot->base.tupdata;
diff --git a/src/backend/access/table/Makefile b/src/backend/access/table/Makefile
index fe22bf9208..006ba99182 100644
--- a/src/backend/access/table/Makefile
+++ b/src/backend/access/table/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/access/table
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = tableam.o tableamapi.o tableam_common.o
+OBJS = tableam.o tableamapi.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/table/tableam_common.c b/src/backend/access/table/tableam_common.c
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 84de804175..d3ffe417ff 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -593,6 +593,10 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self)
 	if (myState->rel->rd_rel->relhasoids)
 		slot->tts_tupleOid = InvalidOid;
 
+	/* Materialize the slot */
+	if (!TTS_IS_VIRTUAL(slot))
+		ExecMaterializeSlot(slot);
+
 	table_insert(myState->rel,
 				 slot,
 				 myState->output_cid,
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index ef94ac4aa0..8df85c2f48 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -529,20 +529,13 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 			Assert(TTS_IS_HEAPTUPLE(outerslot) ||
 				   TTS_IS_BUFFERTUPLE(outerslot));
 
-			/* The slot should have a valid heap tuple. */
-#if FIXME
-			/* The slot should have a valid heap tuple. */
-			Assert(hslot->tuple != NULL);
-#endif
-
-			/*
-			 * hari
-			 * Assert(outerslot->tts_storageslotam->slot_is_physical_tuple(outerslot));
-			 */
 			if (attnum == TableOidAttributeNumber)
 				d = ObjectIdGetDatum(outerslot->tts_tableOid);
 			else
 			{
+				/* The slot should have a valid heap tuple. */
+				Assert(hslot->tuple != NULL);
+
 				/* heap_getsysattr has sufficient defenses against bad attnums */
 				d = heap_getsysattr(hslot->tuple, attnum,
 									outerslot->tts_tupleDescriptor,
@@ -570,6 +563,9 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 				Assert(TTS_IS_HEAPTUPLE(scanslot) ||
 					   TTS_IS_BUFFERTUPLE(scanslot));
 
+				if (hslot->tuple == NULL)
+					ExecMaterializeSlot(scanslot);
+
 				d = heap_getsysattr(hslot->tuple, attnum,
 									scanslot->tts_tupleDescriptor,
 									op->resnull);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index e055c0a7c6..34ef86a5bd 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2594,7 +2594,7 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
 	 * datums that may be present in copyTuple).  As with the next step, this
 	 * is to guard against early re-use of the EPQ query.
 	 */
-	if (!TupIsNull(slot))
+	if (!TupIsNull(slot) && !TTS_IS_VIRTUAL(slot))
 		ExecMaterializeSlot(slot);
 
 #if FIXME
@@ -2787,16 +2787,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			if (isNull)
 				continue;
 
-			elog(ERROR, "frak, need to implement ROW_MARK_COPY");
-#ifdef FIXME
-			// FIXME: this should just deform the tuple and store it as a
-			// virtual one.
-			tuple = table_tuple_by_datum(erm->relation, datum, erm->relid);
-
-			/* store tuple */
-			EvalPlanQualSetTuple(epqstate, erm->rti, tuple);
-#endif
-
+			ExecForceStoreHeapTupleDatum(datum, slot);
 		}
 	}
 }
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 917bf80f71..74149cc3ad 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1364,6 +1364,27 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 	return ExecFinishStoreSlotValues(slot);
 }
 
+void
+ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
+{
+	HeapTuple	tuple;
+	HeapTupleHeader td;
+
+	td = DatumGetHeapTupleHeader(data);
+
+	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + HeapTupleHeaderGetDatumLength(td));
+	tuple->t_len = HeapTupleHeaderGetDatumLength(td);
+	tuple->t_self = td->t_ctid;
+	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+	memcpy((char *) tuple->t_data, (char *) td, tuple->t_len);
+
+	ExecClearTuple(slot);
+
+	heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
+					  slot->tts_values, slot->tts_isnull);
+	ExecFinishStoreSlotValues(slot);
+}
+
 /* --------------------------------
  *		ExecFetchSlotTuple
  *			Fetch the slot's regular physical tuple.
diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index 56880e3d16..36ca07beb2 100644
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -224,6 +224,18 @@ BitmapHeapNext(BitmapHeapScanState *node)
 
 			BitmapAdjustPrefetchIterator(node, tbmres);
 
+			/*
+			 * Ignore any claimed entries past what we think is the end of the
+			 * relation.  (This is probably not necessary given that we got at
+			 * least AccessShareLock on the table before performing any of the
+			 * indexscans, but let's be safe.)
+			 */
+			if (tbmres->blockno >= scan->rs_nblocks)
+			{
+				node->tbmres = tbmres = NULL;
+				continue;
+			}
+
 			/*
 			 * We can skip fetching the heap page if we don't need any fields
 			 * from the heap, and the bitmap entries don't need rechecking,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 3cc9092413..b3851b180d 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -607,7 +607,7 @@ ExecDelete(ModifyTableState *mtstate,
 		   bool canSetTag,
 		   bool changingPart,
 		   bool *tupleDeleted,
-		   TupleTableSlot **epqslot)
+		   TupleTableSlot **epqreturnslot)
 {
 	ResultRelInfo *resultRelInfo;
 	Relation	resultRelationDesc;
@@ -632,7 +632,7 @@ ExecDelete(ModifyTableState *mtstate,
 		bool		dodelete;
 
 		dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
-										tupleid, oldtuple, epqslot);
+										tupleid, oldtuple, epqreturnslot);
 
 		if (!dodelete)			/* "do nothing" */
 			return NULL;
@@ -724,8 +724,21 @@ ldelete:;
 					/* Tuple no more passing quals, exiting... */
 					return NULL;
 				}
+
+				/**/
+				if (epqreturnslot)
+				{
+					*epqreturnslot = epqslot;
+					return NULL;
+				}
+
 				goto ldelete;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
@@ -1196,6 +1209,11 @@ lreplace:;
 				slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
 				goto lreplace;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 54382aba88..f030ad25a2 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -4037,7 +4037,6 @@ CreateStatsStmt:
  *
  *****************************************************************************/
 
-// PBORKED: storage option
 CreateAsStmt:
 		CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
 				{
@@ -4068,14 +4067,16 @@ CreateAsStmt:
 		;
 
 create_as_target:
-			qualified_name opt_column_list OptWith OnCommitOption OptTableSpace
+			qualified_name opt_column_list table_access_method_clause
+			OptWith OnCommitOption OptTableSpace
 				{
 					$$ = makeNode(IntoClause);
 					$$->rel = $1;
 					$$->colNames = $2;
-					$$->options = $3;
-					$$->onCommit = $4;
-					$$->tableSpaceName = $5;
+					$$->accessMethod = $3;
+					$$->options = $4;
+					$$->onCommit = $5;
+					$$->tableSpaceName = $6;
 					$$->viewQuery = NULL;
 					$$->skipData = false;		/* might get changed later */
 				}
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index 05f38cfd0d..20fc425a27 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -476,6 +476,7 @@ extern TupleTableSlot *ExecCopySlot(TupleTableSlot *dstslot,
 
 extern void ExecForceStoreHeapTuple(HeapTuple tuple,
 			   TupleTableSlot *slot);
+extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 
 extern void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum);
 extern Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull);
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 40f6eb03d2..4d194a8c2a 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -111,6 +111,7 @@ typedef struct IntoClause
 
 	RangeVar   *rel;			/* target relation name */
 	List	   *colNames;		/* column names to assign, or NIL */
+	char	   *accessMethod;	/* table access method */
 	List	   *options;		/* options from WITH clause */
 	OnCommitAction onCommit;	/* what do we do at COMMIT? */
 	char	   *tableSpaceName; /* table space to use, or NULL */
-- 
2.18.0.windows.1

From 2c1414f2e847577174ba3087868e4920342dfeb1 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 1 Nov 2018 12:00:10 +1100
Subject: [PATCH 3/3] First draft of pluggable-storage documentation

---
 doc/src/sgml/{indexam.sgml => am.sgml}     | 590 ++++++++++++++++++++-
 doc/src/sgml/catalogs.sgml                 |   5 +-
 doc/src/sgml/config.sgml                   |  24 +
 doc/src/sgml/filelist.sgml                 |   2 +-
 doc/src/sgml/postgres.sgml                 |   2 +-
 doc/src/sgml/ref/create_access_method.sgml |  12 +-
 doc/src/sgml/ref/create_table.sgml         |  18 +-
 doc/src/sgml/ref/create_table_as.sgml      |  14 +
 doc/src/sgml/release-9.6.sgml              |   2 +-
 doc/src/sgml/xindex.sgml                   |   2 +-
 10 files changed, 640 insertions(+), 31 deletions(-)
 rename doc/src/sgml/{indexam.sgml => am.sgml} (78%)

diff --git a/doc/src/sgml/indexam.sgml b/doc/src/sgml/am.sgml
similarity index 78%
rename from doc/src/sgml/indexam.sgml
rename to doc/src/sgml/am.sgml
index beb99d1831..dc13bc1073 100644
--- a/doc/src/sgml/indexam.sgml
+++ b/doc/src/sgml/am.sgml
@@ -1,16 +1,20 @@
-<!-- doc/src/sgml/indexam.sgml -->
+<!-- doc/src/sgml/am.sgml -->
 
-<chapter id="indexam">
- <title>Index Access Method Interface Definition</title>
+<chapter id="am">
+ <title>Access Method Interface Definition</title>
 
   <para>
    This chapter defines the interface between the core
-   <productname>PostgreSQL</productname> system and <firstterm>index access
-   methods</firstterm>, which manage individual index types.  The core system
-   knows nothing about indexes beyond what is specified here, so it is
-   possible to develop entirely new index types by writing add-on code.
+   <productname>PostgreSQL</productname> system and <firstterm>access
+   methods</firstterm>, which manage individual <literal>INDEX</literal> 
+   and <literal>TABLE</literal> types.  The core system knows nothing
+   about these access methods beyond what is specified here, so it is
+   possible to develop entirely new access method types by writing add-on code.
   </para>
-
+ 
+ <sect1 id="index-access-methods">
+  <title>Overview of Index access methods</title>
+  
   <para>
    All indexes in <productname>PostgreSQL</productname> are what are known
    technically as <firstterm>secondary indexes</firstterm>; that is, the index is
@@ -42,8 +46,8 @@
    dead tuples are reclaimed (by vacuuming) when the dead tuples themselves
    are reclaimed.
   </para>
-
- <sect1 id="index-api">
+  
+ <sect2 id="index-api">
   <title>Basic API Structure for Indexes</title>
 
   <para>
@@ -217,9 +221,9 @@ typedef struct IndexAmRoutine
    conditions.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-functions">
+ <sect2 id="index-functions">
   <title>Index Access Method Functions</title>
 
   <para>
@@ -709,9 +713,11 @@ amparallelrescan (IndexScanDesc scan);
    the beginning.
   </para>
 
- </sect1>
+ </sect2>
+ 
+ 
 
- <sect1 id="index-scanning">
+ <sect2 id="index-scanning">
   <title>Index Scanning</title>
 
   <para>
@@ -864,9 +870,9 @@ amparallelrescan (IndexScanDesc scan);
    if its internal implementation is unsuited to one API or the other.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-locking">
+ <sect2 id="index-locking">
   <title>Index Locking Considerations</title>
 
   <para>
@@ -978,9 +984,9 @@ amparallelrescan (IndexScanDesc scan);
    reduce the frequency of such transaction cancellations.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-unique-checks">
+ <sect2 id="index-unique-checks">
   <title>Index Uniqueness Checks</title>
 
   <para>
@@ -1127,9 +1133,9 @@ amparallelrescan (IndexScanDesc scan);
     </itemizedlist>
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-cost-estimation">
+ <sect2 id="index-cost-estimation">
   <title>Index Cost Estimation Functions</title>
 
   <para>
@@ -1376,5 +1382,549 @@ cost_qual_eval(&amp;index_qual_cost, path-&gt;indexquals, root);
    Examples of cost estimator functions can be found in
    <filename>src/backend/utils/adt/selfuncs.c</filename>.
   </para>
+ </sect2>
  </sect1>
+ 
+ <sect1 id="table-access-methods">
+  <title>Overview of Table access methods </title>
+  
+  <para>
+   All Tables in <productname>PostgreSQL</productname> are the primary data store.
+   Each table is stored as its own physical <firstterm>relation</firstterm> and so
+   is described by an entry in the <structname>pg_class</structname> catalog.
+   The contents of an table are entirely under the control of its access method.
+   (All the access methods furthermore use the standard page layout described in
+   <xref linkend="storage-page-layout"/>.)
+  </para>
+  
+ <sect2 id="table-api">
+  <title>Table access method API</title>
+  
+  <para>
+   Each table access method is described by a row in the
+   <link linkend="catalog-pg-am"><structname>pg_am</structname></link>
+   system catalog.  The <structname>pg_am</structname> entry
+   specifies a name and a <firstterm>handler function</firstterm> for the access
+   method.  These entries can be created and deleted using the
+   <xref linkend="sql-create-access-method"/> and
+   <xref linkend="sql-drop-access-method"/> SQL commands.
+  </para>
+
+  <para>
+   A table access method handler function must be declared to accept a
+   single argument of type <type>internal</type> and to return the
+   pseudo-type <type>table_am_handler</type>.  The argument is a dummy value that
+   simply serves to prevent handler functions from being called directly from
+   SQL commands.  The result of the function must be a palloc'd struct of
+   type <structname>TableAmRoutine</structname>, which contains everything
+   that the core code needs to know to make use of the table access method.
+   The <structname>TableAmRoutine</structname> struct, also called the access
+   method's <firstterm>API struct</firstterm>, includes fields specifying assorted
+   fixed properties of the access method, such as whether it can support
+   bitmap scans.  More importantly, it contains pointers to support
+   functions for the access method, which do all of the real work to access
+   tables.  These support functions are plain C functions and are not
+   visible or callable at the SQL level.  The support functions are described
+   in <xref linkend="table-functions"/>.
+  </para>
+
+  <para>
+   The structure <structname>TableAmRoutine</structname> is defined thus:
+<programlisting>
+typedef struct TableAmRoutine
+{
+    NodeTag     type;
+
+    SlotCallbacks_function slot_callbacks;
+
+    SnapshotSatisfies_function snapshot_satisfies;
+    SnapshotSatisfiesUpdate_function snapshot_satisfiesUpdate;
+    SnapshotSatisfiesVacuum_function snapshot_satisfiesVacuum;
+
+    /* Operations on physical tuples */
+    TupleInsert_function tuple_insert;
+    TupleInsertSpeculative_function tuple_insert_speculative;
+    TupleCompleteSpeculative_function tuple_complete_speculative;
+    TupleUpdate_function tuple_update;
+    TupleDelete_function tuple_delete;
+    TupleFetchRowVersion_function tuple_fetch_row_version;
+    TupleLock_function tuple_lock;
+    MultiInsert_function multi_insert;
+    TupleGetLatestTid_function tuple_get_latest_tid;
+    TupleFetchFollow_function tuple_fetch_follow;
+
+    GetTupleData_function get_tuple_data;
+
+    RelationVacuum_function relation_vacuum;
+    RelationScanAnalyzeNextBlock_function scan_analyze_next_block;
+    RelationScanAnalyzeNextTuple_function scan_analyze_next_tuple;
+    RelationCopyForCluster_function relation_copy_for_cluster;
+    RelationSync_function relation_sync;
+
+    /* Operations on relation scans */
+    ScanBegin_function scan_begin;
+    ScanSetlimits_function scansetlimits;
+    ScanGetnextSlot_function scan_getnextslot;
+
+    BitmapPagescan_function scan_bitmap_pagescan;
+    BitmapPagescanNext_function scan_bitmap_pagescan_next;
+
+    SampleScanNextBlock_function scan_sample_next_block;
+    SampleScanNextTuple_function scan_sample_next_tuple;
+
+    ScanEnd_function scan_end;
+    ScanRescan_function scan_rescan;
+    ScanUpdateSnapshot_function scan_update_snapshot;
+
+    BeginIndexFetchTable_function begin_index_fetch;
+    EndIndexFetchTable_function reset_index_fetch;
+    EndIndexFetchTable_function end_index_fetch;
+
+
+    IndexBuildRangeScan_function index_build_range_scan;
+    IndexValidateScan_function index_validate_scan;
+
+    CreateInitFork_function CreateInitFork;
+}           TableAmRoutine;
+</programlisting>
+  </para>
+  
+  <para>
+   An individual table is defined by a
+   <link linkend="catalog-pg-class"><structname>pg_class</structname></link>
+   entry that describes it as a physical relation.
+  </para>
+   
+ </sect2>
+ 
+ <sect2 id="table-functions">
+  <title>Table Access Method Functions</title>
+
+  <para>
+   The table construction and maintenance functions that an table access
+   method must provide in <structname>TableAmRoutine</structname> are:
+  </para>
+
+  <para>
+<programlisting>
+TupleTableSlotOps *
+slot_callbacks (Relation relation);
+</programlisting>
+   API to access the slot specific methods;
+   Following methods are available; 
+   <structname>TTSOpsVirtual</structname>,
+   <structname>TTSOpsHeapTuple</structname>,
+   <structname>TTSOpsMinimalTuple</structname>,
+   <structname>TTSOpsBufferTuple</structname>,
+  </para>
+  
+  <para>
+<programlisting>
+bool
+snapshot_satisfies (TupleTableSlot *slot, Snapshot snapshot);
+</programlisting>
+   API to check whether the provided slot is visible to the current
+   transaction according the snapshot.
+  </para>
+ 
+  <para>
+<programlisting>
+Oid
+tuple_insert (Relation rel, TupleTableSlot *slot, CommandId cid,
+              int options, BulkInsertState bistate);
+</programlisting>
+   API to insert the tuple and provide the <literal>ItemPointerData</literal>
+   where the tuple is successfully inserted.
+  </para>
+  
+  <para>
+<programlisting>
+Oid
+tuple_insert_speculative (Relation rel,
+                         TupleTableSlot *slot,
+                         CommandId cid,
+                         int options,
+                         BulkInsertState bistate,
+                         uint32 specToken);
+</programlisting>
+   API to insert the tuple with a speculative token. This API is similar
+   like <literal>tuple_insert</literal>, with additional speculative
+   information.
+  </para>
+  
+  <para>
+<programlisting>
+void
+tuple_complete_speculative (Relation rel,
+                          TupleTableSlot *slot,
+                          uint32 specToken,
+                          bool succeeded);
+</programlisting>
+   API to complete the state of the tuple inserted by the API <literal>tuple_insert_speculative</literal>
+   with the successful completion of the index insert.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+tuple_update (Relation relation,
+             ItemPointer otid,
+             TupleTableSlot *slot,
+             CommandId cid,
+             Snapshot crosscheck,
+             bool wait,
+             HeapUpdateFailureData *hufd,
+             LockTupleMode *lockmode,
+             bool *update_indexes);
+</programlisting>
+   API to update the existing tuple with new data.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+tuple_delete (Relation relation,
+             ItemPointer tid,
+             CommandId cid,
+             Snapshot crosscheck,
+             bool wait,
+             HeapUpdateFailureData *hufd,
+             bool changingPart);
+</programlisting>
+   API to delete the existing tuple.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+tuple_fetch_row_version (Relation relation,
+                       ItemPointer tid,
+                       Snapshot snapshot,
+                       TupleTableSlot *slot,
+                       Relation stats_relation);
+</programlisting>
+   API to fetch and store the Buffered Heap tuple in the provided slot
+   based on the ItemPointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+HTSU_Result
+TupleLock_function (Relation relation,
+                   ItemPointer tid,
+                   Snapshot snapshot,
+                   TupleTableSlot *slot,
+                   CommandId cid,
+                   LockTupleMode mode,
+                   LockWaitPolicy wait_policy,
+                   uint8 flags,
+                   HeapUpdateFailureData *hufd);
+</programlisting>
+   API to lock the specified the ItemPointer tuple and fetches the newest version of
+   its tuple and TID.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+multi_insert (Relation relation, TupleTableSlot **slots, int nslots,
+              CommandId cid, int options, BulkInsertState bistate);
+</programlisting>
+   API to insert multiple tuples at a time into the relation.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+tuple_get_latest_tid (Relation relation,
+                    Snapshot snapshot,
+                    ItemPointer tid);
+</programlisting>
+   API to get the the latest TID of the tuple with the given itempointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+tuple_fetch_follow (struct IndexFetchTableData *scan,
+                  ItemPointer tid,
+                  Snapshot snapshot,
+                  TupleTableSlot *slot,
+                  bool *call_again, bool *all_dead);
+</programlisting>
+   API to get the all the tuples of the page that satisfies itempointer.
+  </para>
+  
+  
+  <para>
+<programlisting>
+tuple_data
+get_tuple_data (TupleTableSlot *slot, tuple_data_flags flags);
+</programlisting>
+   API to return the internal structure members of the HeapTuple.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_vacuum (Relation onerel, int options,
+                struct VacuumParams *params, BufferAccessStrategy bstrategy);
+</programlisting>
+   API to perform vacuum for one heap relation.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+scan_analyze_next_block (TableScanDesc scan, BlockNumber blockno,
+                      BufferAccessStrategy bstrategy);
+</programlisting>
+   API to fill the scan descriptor with the buffer of the specified block.
+  </para>
+  
+  
+  <para>
+<programlisting>
+bool
+scan_analyze_next_tuple (TableScanDesc scan, TransactionId OldestXmin,
+                      double *liverows, double *deadrows, TupleTableSlot *slot));
+</programlisting>
+   API to analyze the block and fill the buffered heap tuple in the slot and also
+   provide the live and dead rows.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_copy_for_cluster (Relation NewHeap, Relation OldHeap, Relation OldIndex,
+                       bool use_sort,
+                       TransactionId OldestXmin, TransactionId FreezeXid, MultiXactId MultiXactCutoff,
+                       double *num_tuples, double *tups_vacuumed, double *tups_recently_dead);
+</programlisting>
+   API to copy one relation to another relation eith using the Index or table scan.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+relation_sync (Relation relation);
+</programlisting>
+   API to sync the relation to disk, useful for the cases where no WAL is written.
+  </para>
+  
+  
+  <para>
+<programlisting>
+TableScanDesc
+scan_begin (Relation relation,
+            Snapshot snapshot,
+            int nkeys, ScanKey key,
+            ParallelTableScanDesc parallel_scan,
+            bool allow_strat,
+            bool allow_sync,
+            bool allow_pagemode,
+            bool is_bitmapscan,
+            bool is_samplescan,
+            bool temp_snap);
+</programlisting>
+   API to start the relation scan for the provided relation and returns the
+   <structname>TableScanDesc</structname> structure.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scansetlimits (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks);
+</programlisting>
+   API to fix the relation scan range limits.
+  </para>
+  
+  
+    <para>
+<programlisting>
+TupleTableSlot *
+scan_getnextslot (TableScanDesc scan,
+                 ScanDirection direction, TupleTableSlot *slot);
+</programlisting>
+   API to fill the next visible tuple from the relation scan in the provided slot
+   and return it.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_bitmap_pagescan (TableScanDesc scan,
+                    TBMIterateResult *tbmres);
+</programlisting>
+   API to scan the relation and fill the scan description bitmap with valid item pointers
+   for the specified block.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_bitmap_pagescan_next (TableScanDesc scan,
+                        TupleTableSlot *slot);
+</programlisting>
+   API to fill the buffered heap tuple data from the bitmap scanned item pointers and store
+   it in the provided slot.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_sample_next_block (TableScanDesc scan, struct SampleScanState *scanstate);
+</programlisting>
+   API to scan the relation and fill the scan description bitmap with valid item pointers
+   for the specified block provided by the sample method.
+  </para>
+  
+  
+    <para>
+<programlisting>
+bool
+scan_sample_next_tuple (TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
+</programlisting>
+   API to fill the buffered heap tuple data from the bitmap scanned item pointers based on the sample
+   method and store it in the provided slot.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scan_end (TableScanDesc scan);
+</programlisting>
+   API to end the relation scan.
+  </para>
+  
+  
+    <para>
+<programlisting>
+void
+scan_rescan (TableScanDesc scan, ScanKey key, bool set_params,
+             bool allow_strat, bool allow_sync, bool allow_pagemode);
+</programlisting>
+   API to restart the relation scan with provided data.
+  </para>
+  
+  
+  <para>
+<programlisting>
+void
+scan_update_snapshot (TableScanDesc scan, Snapshot snapshot);
+</programlisting>
+   API to update the relation scan with the new snapshot.
+  </para>
+  
+  <para>
+<programlisting>
+IndexFetchTableData *
+begin_index_fetch (Relation relation);
+</programlisting>
+   API to prepare the <structname>IndexFetchTableData</structname> for the relation.
+  </para>
+  
+  <para>
+<programlisting>
+void
+reset_index_fetch (struct IndexFetchTableData* data);
+</programlisting>
+   API to reset the prepared internal members of the <structname>IndexFetchTableData</structname>.
+  </para>
+  
+  <para>
+<programlisting>
+void
+end_index_fetch (struct IndexFetchTableData* data);
+</programlisting>
+   API to clear and free the <structname>IndexFetchTableData</structname>.
+  </para>
+  
+    <para>
+<programlisting>
+double
+index_build_range_scan (Relation heapRelation,
+                       Relation indexRelation,
+                       IndexInfo *indexInfo,
+                       bool allow_sync,
+                       bool anyvisible,
+                       BlockNumber start_blockno,
+                       BlockNumber end_blockno,
+                       IndexBuildCallback callback,
+                       void *callback_state,
+                       TableScanDesc scan);
+</programlisting>
+   API to perform the table scan with bounded range specified by the caller
+   and insert the satisfied records into the index using the provided callback
+   function pointer.
+  </para>
+  
+    <para>
+<programlisting>
+void
+index_validate_scan (Relation heapRelation,
+                   Relation indexRelation,
+                   IndexInfo *indexInfo,
+                   Snapshot snapshot,
+                   struct ValidateIndexState *state);
+</programlisting>
+   API to perform the table scan and insert the satisfied records into the index.
+   This API is similar like <function>index_build_range_scan</function>. This 
+   is used in the scenario of concurrent index build.
+  </para>
+  
+ </sect2>
+ 
+ <sect2>
+  <title>Table scanning</title>
+  
+  <para>
+  </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table insert/update/delete</title>
+
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table locking</title>
+
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table vacuum</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table fetch</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ </sect1> 
 </chapter>
diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index 0179deea2e..f0c8037bbc 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -587,8 +587,9 @@
    The catalog <structname>pg_am</structname> stores information about
    relation access methods.  There is one row for each access method supported
    by the system.
-   Currently, only indexes have access methods.  The requirements for index
-   access methods are discussed in detail in <xref linkend="indexam"/>.
+   Currently, only <literal>INDEX</literal> and <literal>TABLE</literal> have
+   access methods.  The requirements for access methods are discussed in detail
+   in <xref linkend="am"/>.
   </para>
 
   <table>
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index f11b8f724c..8765d7c57c 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -6585,6 +6585,30 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-default-table-access-method" xreflabel="default_table_access_method">
+      <term><varname>default_table_access_method</varname> (<type>string</type>)
+      <indexterm>
+       <primary><varname>default_table_access_method</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        This variable specifies the default table access method using which to create
+        objects (tables and materialized views) when a <command>CREATE</command> command does
+        not explicitly specify a access method.
+       </para>
+
+       <para>
+        The value is either the name of a table access method, or an empty string
+        to specify using the default table access method of the current database.
+        If the value does not match the name of any existing table access methods,
+        <productname>PostgreSQL</productname> will automatically use the default
+        table access method of the current database.
+       </para>
+
+      </listitem>
+     </varlistentry>
+     
      <varlistentry id="guc-default-tablespace" xreflabel="default_tablespace">
       <term><varname>default_tablespace</varname> (<type>string</type>)
       <indexterm>
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 48ac14a838..99a6496502 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -90,7 +90,7 @@
 <!ENTITY gin        SYSTEM "gin.sgml">
 <!ENTITY brin       SYSTEM "brin.sgml">
 <!ENTITY planstats    SYSTEM "planstats.sgml">
-<!ENTITY indexam    SYSTEM "indexam.sgml">
+<!ENTITY am         SYSTEM "am.sgml">
 <!ENTITY nls        SYSTEM "nls.sgml">
 <!ENTITY plhandler  SYSTEM "plhandler.sgml">
 <!ENTITY fdwhandler SYSTEM "fdwhandler.sgml">
diff --git a/doc/src/sgml/postgres.sgml b/doc/src/sgml/postgres.sgml
index 0070603fc3..3e66ae9c8a 100644
--- a/doc/src/sgml/postgres.sgml
+++ b/doc/src/sgml/postgres.sgml
@@ -251,7 +251,7 @@
   &tablesample-method;
   &custom-scan;
   &geqo;
-  &indexam;
+  &am;
   &generic-wal;
   &btree;
   &gist;
diff --git a/doc/src/sgml/ref/create_access_method.sgml b/doc/src/sgml/ref/create_access_method.sgml
index 851c5e63be..256914022a 100644
--- a/doc/src/sgml/ref/create_access_method.sgml
+++ b/doc/src/sgml/ref/create_access_method.sgml
@@ -61,7 +61,8 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
     <listitem>
      <para>
       This clause specifies the type of access method to define.
-      Only <literal>INDEX</literal> is supported at present.
+      Only <literal>INDEX</literal> and <literal>TABLE</literal>
+      are supported at present.
      </para>
     </listitem>
    </varlistentry>
@@ -76,9 +77,12 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
       declared to take a single argument of type <type>internal</type>,
       and its return type depends on the type of access method;
       for <literal>INDEX</literal> access methods, it must
-      be <type>index_am_handler</type>.  The C-level API that the handler
-      function must implement varies depending on the type of access method.
-      The index access method API is described in <xref linkend="indexam"/>.
+      be <type>index_am_handler</type> and for <literal>TABLE</literal>
+      access methods, it must be <type>table_am_handler</type>.
+      The C-level API that the handler function must implement varies
+      depending on the type of access method. The index access method API
+      is described in <xref linkend="index-access-methods"/> and the table access method
+      API is described in <xref linkend="table-access-methods"/>.
      </para>
     </listitem>
    </varlistentry>
diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml
index 10428f8ff0..87e0f01ab2 100644
--- a/doc/src/sgml/ref/create_table.sgml
+++ b/doc/src/sgml/ref/create_table.sgml
@@ -29,6 +29,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
 ] )
 [ INHERITS ( <replaceable>parent_table</replaceable> [, ... ] ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -40,6 +41,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -51,6 +53,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ] { FOR VALUES <replaceable class="parameter">partition_bound_spec</replaceable> | DEFAULT }
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -955,7 +958,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
 
      <para>
       The access method must support <literal>amgettuple</literal> (see <xref
-      linkend="indexam"/>); at present this means <acronym>GIN</acronym>
+      linkend="index-access-methods"/>); at present this means <acronym>GIN</acronym>
       cannot be used.  Although it's allowed, there is little point in using
       B-tree or hash indexes with an exclusion constraint, because this
       does nothing that an ordinary unique constraint doesn't do better.
@@ -1138,6 +1141,19 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/ref/create_table_as.sgml b/doc/src/sgml/ref/create_table_as.sgml
index 527138e787..2acf52d2f5 100644
--- a/doc/src/sgml/ref/create_table_as.sgml
+++ b/doc/src/sgml/ref/create_table_as.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITH OIDS | WITHOUT OIDS ]
     [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -120,6 +121,19 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml
index acb6a88b31..68c79db4b5 100644
--- a/doc/src/sgml/release-9.6.sgml
+++ b/doc/src/sgml/release-9.6.sgml
@@ -10081,7 +10081,7 @@ This commit is also listed under libpq and PL/pgSQL
 2016-08-13 [ed0097e4f] Add SQL-accessible functions for inspecting index AM pro
 -->
        <para>
-        Restructure <link linkend="indexam">index access
+        Restructure <link linkend="index-access-methods">index access
         method <acronym>API</acronym></link> to hide most of it at
         the <application>C</application> level (Alexander Korotkov, Andrew Gierth)
        </para>
diff --git a/doc/src/sgml/xindex.sgml b/doc/src/sgml/xindex.sgml
index 9446f8b836..4fa821160c 100644
--- a/doc/src/sgml/xindex.sgml
+++ b/doc/src/sgml/xindex.sgml
@@ -36,7 +36,7 @@
    described in <classname>pg_am</classname>.  It is possible to add a
    new index access method by writing the necessary code and
    then creating an entry in <classname>pg_am</classname> &mdash; but that is
-   beyond the scope of this chapter (see <xref linkend="indexam"/>).
+   beyond the scope of this chapter (see <xref linkend="am"/>).
   </para>
 
   <para>
-- 
2.18.0.windows.1

From 826223860a977394ed2ebc1f07c1533b0f240e9c Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 17:58:27 +1100
Subject: [PATCH 2/3] New API's are added

1. init fork API
2. set New filenode
3. Estimate rel size

Set New filenode and estimate rel size are added as function hooks
and these not complusory for heap, when they exist, it take over
the control.
---
 src/backend/access/heap/heapam_handler.c | 27 +++++++++++++++++++++++-
 src/backend/catalog/heap.c               | 24 ++-------------------
 src/backend/commands/tablecmds.c         |  4 ++--
 src/backend/optimizer/util/plancat.c     | 12 +++++++++++
 src/backend/utils/cache/relcache.c       | 12 +++++++++++
 src/include/access/tableam.h             | 16 ++++++++++++++
 src/include/catalog/heap.h               |  2 --
 7 files changed, 70 insertions(+), 27 deletions(-)

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 3254e30a45..ae832e1f71 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -30,6 +30,7 @@
 #include "catalog/catalog.h"
 #include "catalog/index.h"
 #include "catalog/pg_am_d.h"
+#include "catalog/storage_xlog.h"
 #include "executor/executor.h"
 #include "pgstat.h"
 #include "storage/lmgr.h"
@@ -2118,6 +2119,28 @@ heap_copy_for_cluster(Relation OldHeap, Relation NewHeap, Relation OldIndex,
 	pfree(isnull);
 }
 
+/*
+ * Set up an init fork for an unlogged table so that it can be correctly
+ * reinitialized on restart.  An immediate sync is required even if the
+ * page has been logged, because the write did not go through
+ * shared_buffers and therefore a concurrent checkpoint may have moved
+ * the redo pointer past our xlog record.  Recovery may as well remove it
+ * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
+ * record. Therefore, logging is necessary even if wal_level=minimal.
+ */
+static void
+heap_create_init_fork(Relation rel)
+{
+	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
+		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
+		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
+	RelationOpenSmgr(rel);
+	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
+	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
+	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
+}
+
+
 static const TableAmRoutine heapam_methods = {
 	.type = T_TableAmRoutine,
 
@@ -2165,7 +2188,9 @@ static const TableAmRoutine heapam_methods = {
 
 	.index_build_range_scan = IndexBuildHeapRangeScan,
 
-	.index_validate_scan = validate_index_heapscan
+	.index_validate_scan = validate_index_heapscan,
+
+	.CreateInitFork = heap_create_init_fork
 };
 
 const TableAmRoutine *
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 398f90775f..840319668a 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -32,6 +32,7 @@
 #include "access/htup_details.h"
 #include "access/multixact.h"
 #include "access/sysattr.h"
+#include "access/tableam.h"
 #include "access/transam.h"
 #include "access/xact.h"
 #include "access/xlog.h"
@@ -1442,7 +1443,7 @@ heap_create_with_catalog(const char *relname,
 	 */
 	if (relpersistence == RELPERSISTENCE_UNLOGGED &&
 		relkind != RELKIND_PARTITIONED_TABLE)
-		heap_create_init_fork(new_rel_desc);
+		table_create_init_fork(new_rel_desc);
 
 	/*
 	 * ok, the relation has been cataloged, so close our relations and return
@@ -1454,27 +1455,6 @@ heap_create_with_catalog(const char *relname,
 	return relid;
 }
 
-/*
- * Set up an init fork for an unlogged table so that it can be correctly
- * reinitialized on restart.  An immediate sync is required even if the
- * page has been logged, because the write did not go through
- * shared_buffers and therefore a concurrent checkpoint may have moved
- * the redo pointer past our xlog record.  Recovery may as well remove it
- * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE
- * record. Therefore, logging is necessary even if wal_level=minimal.
- */
-void
-heap_create_init_fork(Relation rel)
-{
-	Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
-		   rel->rd_rel->relkind == RELKIND_MATVIEW ||
-		   rel->rd_rel->relkind == RELKIND_TOASTVALUE);
-	RelationOpenSmgr(rel);
-	smgrcreate(rel->rd_smgr, INIT_FORKNUM, false);
-	log_smgrcreate(&rel->rd_smgr->smgr_rnode.node, INIT_FORKNUM);
-	smgrimmedsync(rel->rd_smgr, INIT_FORKNUM);
-}
-
 /*
  *		RelationRemoveInheritance
  *
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index f3526b267d..3c46a48882 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1649,7 +1649,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 			RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 									  RecentXmin, minmulti);
 			if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-				heap_create_init_fork(rel);
+				table_create_init_fork(rel);
 
 			heap_relid = RelationGetRelid(rel);
 			toast_relid = rel->rd_rel->reltoastrelid;
@@ -1663,7 +1663,7 @@ ExecuteTruncateGuts(List *explicit_rels, List *relids, List *relids_logged,
 				RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence,
 										  RecentXmin, minmulti);
 				if (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED)
-					heap_create_init_fork(rel);
+					table_create_init_fork(rel);
 				heap_close(rel, NoLock);
 			}
 
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 8da468a86f..3355f8bff4 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -947,6 +947,18 @@ estimate_rel_size(Relation rel, int32 *attr_widths,
 	BlockNumber relallvisible;
 	double		density;
 
+	/*
+	 * If the relation contains any specific EstimateRelSize
+	 * function, use that instead of the regular default heap method.
+	 */
+	if (rel->rd_tableamroutine &&
+			rel->rd_tableamroutine->EstimateRelSize)
+	{
+		rel->rd_tableamroutine->EstimateRelSize(rel, attr_widths, pages,
+												tuples, allvisfrac);
+		return;
+	}
+
 	switch (rel->rd_rel->relkind)
 	{
 		case RELKIND_RELATION:
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 0d6e5a189f..9cc8e98e40 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -3424,6 +3424,18 @@ RelationSetNewRelfilenode(Relation relation, char persistence,
 	HeapTuple	tuple;
 	Form_pg_class classform;
 
+	/*
+	 * If the relation contains any specific SetNewFilenode
+	 * function, use that instead of the regular default heap method.
+	 */
+	if (relation->rd_tableamroutine &&
+			relation->rd_tableamroutine->SetNewFileNode)
+	{
+		relation->rd_tableamroutine->SetNewFileNode(relation, persistence,
+													freezeXid, minmulti);
+		return;
+	}
+
 	/* Indexes, sequences must have Invalid frozenxid; other rels must not */
 	Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
 			relation->rd_rel->relkind == RELKIND_SEQUENCE) ?
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 7fe6ff6c22..eb7c9b8007 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -194,6 +194,12 @@ struct SampleScanState;
 typedef bool (*SampleScanNextBlock_function)(TableScanDesc scan, struct SampleScanState *scanstate);
 typedef bool (*SampleScanNextTuple_function)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot);
 
+typedef void (*CreateInitFork_function)(Relation rel);
+typedef void (*EstimateRelSize_function)(Relation rel, int32 *attr_widths,
+				  BlockNumber *pages, double *tuples, double *allvisfrac);
+typedef void (*SetNewFileNode_function)(Relation relation, char persistence,
+										TransactionId freezeXid, MultiXactId minmulti);
+
 /*
  * API struct for a table AM.  Note this must be allocated in a
  * server-lifetime manner, typically as a static const struct.
@@ -250,6 +256,10 @@ typedef struct TableAmRoutine
 
 	IndexBuildRangeScan_function index_build_range_scan;
 	IndexValidateScan_function index_validate_scan;
+
+	CreateInitFork_function CreateInitFork;
+	EstimateRelSize_function EstimateRelSize;
+	SetNewFileNode_function	SetNewFileNode;
 }			TableAmRoutine;
 
 static inline const TupleTableSlotOps*
@@ -741,6 +751,12 @@ table_index_build_range_scan(Relation heapRelation,
 		scan);
 }
 
+static inline void
+table_create_init_fork(Relation relation)
+{
+	relation->rd_tableamroutine->CreateInitFork(relation);
+}
+
 extern BlockNumber table_parallelscan_nextpage(TableScanDesc scan);
 extern void table_parallelscan_startblock_init(TableScanDesc scan);
 extern Size table_parallelscan_estimate(Snapshot snapshot);
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index 4584b3473c..c0e706ecc9 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -77,8 +77,6 @@ extern Oid heap_create_with_catalog(const char *relname,
 						 Oid relrewrite,
 						 ObjectAddress *typaddress);
 
-extern void heap_create_init_fork(Relation rel);
-
 extern void heap_drop_with_catalog(Oid relid);
 
 extern void heap_truncate(List *relids);
-- 
2.18.0.windows.1

From 2982d89e825c334d07aa14e8e5038ea02034e581 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Mon, 22 Oct 2018 16:06:10 +1100
Subject: [PATCH 1/3] Further fixes and cleanup

1. Remove the old slot interface file and also update the Makefile.
2. CREATE AS USING method grammer support
3. Materialized view grammer support

This change was missed during earlier USING grammer support.

3. Remove the extra Tuple visibility check

In heapgettup_pagemode the tuple visiblity check is added
during the early devlopment of pluggable storage, but the visibility
check is already carried out in heapgetpage function itself.

4. Handling HeapTupleInvisible case

In update/delete scenarios, when the tuple is
concurrently updated/deleted, sometimes locking
of a tuple may return HeapTupleInvisible. Handle
that case as nothing to do.

regression fixes

1. scan start offset fix during analyze
2. Materialize the slot before they are processed using intorel_receive
3. ROW_MARK_COPY support by force store of heap tuple
4. partition prune extra heap page fix
5. Basic syntax usage tests addition
---
 contrib/pg_visibility/pg_visibility.c       |  5 +-
 src/backend/access/heap/heapam.c            | 28 +++-----
 src/backend/access/heap/heapam_handler.c    |  6 +-
 src/backend/access/heap/heapam_visibility.c |  4 +-
 src/backend/access/index/genam.c            |  3 +-
 src/backend/access/table/Makefile           |  2 +-
 src/backend/access/table/tableam_common.c   |  0
 src/backend/catalog/heap.c                  | 17 +++++
 src/backend/commands/cluster.c              |  6 +-
 src/backend/commands/createas.c             |  5 ++
 src/backend/executor/execExprInterp.c       | 16 ++---
 src/backend/executor/execMain.c             | 13 +---
 src/backend/executor/execReplication.c      |  3 -
 src/backend/executor/execTuples.c           | 21 ++++++
 src/backend/executor/nodeBitmapHeapscan.c   | 12 ++++
 src/backend/executor/nodeModifyTable.c      | 22 +++++-
 src/backend/parser/gram.y                   | 18 ++---
 src/include/executor/tuptable.h             |  1 +
 src/include/nodes/primnodes.h               |  1 +
 src/test/regress/expected/create_am.out     | 78 +++++++++++++++++++++
 src/test/regress/sql/create_am.sql          | 46 ++++++++++++
 21 files changed, 243 insertions(+), 64 deletions(-)
 delete mode 100644 src/backend/access/table/tableam_common.c

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index dce5262e34..88ca4fd2af 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -563,12 +563,13 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 
 	rel = relation_open(relid, AccessShareLock);
 
+	/* Only some relkinds have a visibility map */
+	check_relation_relkind(rel);
+
 	if (rel->rd_rel->relam != HEAP_TABLE_AM_OID)
 		ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 						errmsg("only heap AM is supported")));
 
-	/* Only some relkinds have a visibility map */
-	check_relation_relkind(rel);
 
 	nblocks = RelationGetNumberOfBlocks(rel);
 
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ec99d0bcae..ef6b4c3e54 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -947,31 +947,25 @@ heapgettup_pagemode(HeapScanDesc scan,
 			/*
 			 * if current tuple qualifies, return it.
 			 */
-			if (HeapTupleSatisfies(tuple, scan->rs_scan.rs_snapshot, scan->rs_cbuf))
+			if (key != NULL)
 			{
-				/*
-				 * if current tuple qualifies, return it.
-				 */
-				if (key != NULL)
-				{
-					bool		valid;
+				bool		valid;
 
-					HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
-								nkeys, key, valid);
-					if (valid)
-					{
-						scan->rs_cindex = lineindex;
-						LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
-						return;
-					}
-				}
-				else
+				HeapKeyTest(tuple, RelationGetDescr(scan->rs_scan.rs_rd),
+							nkeys, key, valid);
+				if (valid)
 				{
 					scan->rs_cindex = lineindex;
 					LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 					return;
 				}
 			}
+			else
+			{
+				scan->rs_cindex = lineindex;
+				LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
+				return;
+			}
 
 			/*
 			 * otherwise move to the next item on the page
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index c3960dc91f..3254e30a45 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -1741,7 +1741,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 {
 	HeapScanDesc scan = (HeapScanDesc) sscan;
 	Page		targpage;
-	OffsetNumber targoffset = scan->rs_cindex;
+	OffsetNumber targoffset;
 	OffsetNumber maxoffset;
 	BufferHeapTupleTableSlot *hslot;
 
@@ -1751,7 +1751,9 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 	maxoffset = PageGetMaxOffsetNumber(targpage);
 
 	/* Inner loop over all tuples on the selected page */
-	for (targoffset = scan->rs_cindex; targoffset <= maxoffset; targoffset++)
+	for (targoffset = scan->rs_cindex ? scan->rs_cindex : FirstOffsetNumber;
+			targoffset <= maxoffset;
+			targoffset++)
 	{
 		ItemId		itemid;
 		HeapTuple	targtuple = &hslot->base.tupdata;
diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
index 8233475aa0..7bad246f55 100644
--- a/src/backend/access/heap/heapam_visibility.c
+++ b/src/backend/access/heap/heapam_visibility.c
@@ -1838,8 +1838,10 @@ HeapTupleSatisfies(HeapTuple stup, Snapshot snapshot, Buffer buffer)
 		case NON_VACUUMABLE_VISIBILTY:
 			return HeapTupleSatisfiesNonVacuumable(stup, snapshot, buffer);
 			break;
-		default:
+		case END_OF_VISIBILITY:
 			Assert(0);
 			break;
 	}
+
+	return false; /* keep compiler quiet */
 }
diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index e06bd0479f..94c9702dc1 100644
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -455,10 +455,9 @@ systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
 
 	if (sysscan->irel)
 	{
-		IndexScanDesc scan = sysscan->iscan;
 		IndexFetchHeapData *hscan = (IndexFetchHeapData *) sysscan->iscan->xs_heapfetch;
 
-		Assert(IsMVCCSnapshot(scan->xs_snapshot));
+		Assert(IsMVCCSnapshot(sysscan->iscan->xs_snapshot));
 		//Assert(tup == &hscan->xs_ctup); replace by peeking into slot?
 		Assert(BufferIsValid(hscan->xs_cbuf));
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
diff --git a/src/backend/access/table/Makefile b/src/backend/access/table/Makefile
index fe22bf9208..006ba99182 100644
--- a/src/backend/access/table/Makefile
+++ b/src/backend/access/table/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/access/table
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = tableam.o tableamapi.o tableam_common.o
+OBJS = tableam.o tableamapi.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/access/table/tableam_common.c b/src/backend/access/table/tableam_common.c
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 38b368f916..398f90775f 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -42,6 +42,7 @@
 #include "catalog/index.h"
 #include "catalog/objectaccess.h"
 #include "catalog/partition.h"
+#include "catalog/pg_am.h"
 #include "catalog/pg_attrdef.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
@@ -1388,6 +1389,22 @@ heap_create_with_catalog(const char *relname,
 			recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 		}
 
+		/*
+		 * Make a dependency link to force the relation to be deleted if its
+		 * access method is. Do this only for relation and materialized views.
+		 *
+		 * No need to add an explicit dependency with toast, as the original
+		 * table depends on it.
+		 */
+		if ((relkind == RELKIND_RELATION) ||
+				(relkind == RELKIND_MATVIEW))
+		{
+			referenced.classId = AccessMethodRelationId;
+			referenced.objectId = accessmtd;
+			referenced.objectSubId = 0;
+			recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+		}
+
 		if (relacl != NULL)
 		{
 			int			nnewmembers;
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 63974979da..3ce8862a01 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -755,8 +755,6 @@ copy_table_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose,
 	Relation	relRelation;
 	HeapTuple	reltup;
 	Form_pg_class relform;
-	TupleDesc	oldTupDesc;
-	TupleDesc	newTupDesc;
 	TransactionId OldestXmin;
 	TransactionId FreezeXid;
 	MultiXactId MultiXactCutoff;
@@ -784,9 +782,7 @@ copy_table_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose,
 	 * Their tuple descriptors should be exactly alike, but here we only need
 	 * assume that they have the same number of columns.
 	 */
-	oldTupDesc = RelationGetDescr(OldHeap);
-	newTupDesc = RelationGetDescr(NewHeap);
-	Assert(newTupDesc->natts == oldTupDesc->natts);
+	Assert(RelationGetDescr(NewHeap)->natts == RelationGetDescr(OldHeap)->natts);
 
 	/*
 	 * If the OldHeap has a toast table, get lock on the toast table to keep
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 84de804175..82c0eb2824 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -108,6 +108,7 @@ create_ctas_internal(List *attrList, IntoClause *into)
 	create->oncommit = into->onCommit;
 	create->tablespacename = into->tableSpaceName;
 	create->if_not_exists = false;
+	create->accessMethod = into->accessMethod;
 
 	// PBORKED: toast options
 
@@ -593,6 +594,10 @@ intorel_receive(TupleTableSlot *slot, DestReceiver *self)
 	if (myState->rel->rd_rel->relhasoids)
 		slot->tts_tupleOid = InvalidOid;
 
+	/* Materialize the slot */
+	if (!TTS_IS_VIRTUAL(slot))
+		ExecMaterializeSlot(slot);
+
 	table_insert(myState->rel,
 				 slot,
 				 myState->output_cid,
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index ef94ac4aa0..8df85c2f48 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -529,20 +529,13 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 			Assert(TTS_IS_HEAPTUPLE(outerslot) ||
 				   TTS_IS_BUFFERTUPLE(outerslot));
 
-			/* The slot should have a valid heap tuple. */
-#if FIXME
-			/* The slot should have a valid heap tuple. */
-			Assert(hslot->tuple != NULL);
-#endif
-
-			/*
-			 * hari
-			 * Assert(outerslot->tts_storageslotam->slot_is_physical_tuple(outerslot));
-			 */
 			if (attnum == TableOidAttributeNumber)
 				d = ObjectIdGetDatum(outerslot->tts_tableOid);
 			else
 			{
+				/* The slot should have a valid heap tuple. */
+				Assert(hslot->tuple != NULL);
+
 				/* heap_getsysattr has sufficient defenses against bad attnums */
 				d = heap_getsysattr(hslot->tuple, attnum,
 									outerslot->tts_tupleDescriptor,
@@ -570,6 +563,9 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 				Assert(TTS_IS_HEAPTUPLE(scanslot) ||
 					   TTS_IS_BUFFERTUPLE(scanslot));
 
+				if (hslot->tuple == NULL)
+					ExecMaterializeSlot(scanslot);
+
 				d = heap_getsysattr(hslot->tuple, attnum,
 									scanslot->tts_tupleDescriptor,
 									op->resnull);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index e055c0a7c6..34ef86a5bd 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -2594,7 +2594,7 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
 	 * datums that may be present in copyTuple).  As with the next step, this
 	 * is to guard against early re-use of the EPQ query.
 	 */
-	if (!TupIsNull(slot))
+	if (!TupIsNull(slot) && !TTS_IS_VIRTUAL(slot))
 		ExecMaterializeSlot(slot);
 
 #if FIXME
@@ -2787,16 +2787,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
 			if (isNull)
 				continue;
 
-			elog(ERROR, "frak, need to implement ROW_MARK_COPY");
-#ifdef FIXME
-			// FIXME: this should just deform the tuple and store it as a
-			// virtual one.
-			tuple = table_tuple_by_datum(erm->relation, datum, erm->relid);
-
-			/* store tuple */
-			EvalPlanQualSetTuple(epqstate, erm->rti, tuple);
-#endif
-
+			ExecForceStoreHeapTupleDatum(datum, slot);
 		}
 	}
 }
diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c
index 452973e4ca..489e7d42a2 100644
--- a/src/backend/executor/execReplication.c
+++ b/src/backend/executor/execReplication.c
@@ -239,9 +239,6 @@ RelationFindReplTupleSeq(Relation rel, LockTupleMode lockmode,
 	SnapshotData snap;
 	TransactionId xwait;
 	bool		found;
-	TupleDesc	desc = RelationGetDescr(rel);
-
-	Assert(equalTupleDescs(desc, outslot->tts_tupleDescriptor));
 
 	/* Start a heap scan. */
 	InitDirtySnapshot(snap);
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 917bf80f71..74149cc3ad 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -1364,6 +1364,27 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 	return ExecFinishStoreSlotValues(slot);
 }
 
+void
+ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
+{
+	HeapTuple	tuple;
+	HeapTupleHeader td;
+
+	td = DatumGetHeapTupleHeader(data);
+
+	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + HeapTupleHeaderGetDatumLength(td));
+	tuple->t_len = HeapTupleHeaderGetDatumLength(td);
+	tuple->t_self = td->t_ctid;
+	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
+	memcpy((char *) tuple->t_data, (char *) td, tuple->t_len);
+
+	ExecClearTuple(slot);
+
+	heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
+					  slot->tts_values, slot->tts_isnull);
+	ExecFinishStoreSlotValues(slot);
+}
+
 /* --------------------------------
  *		ExecFetchSlotTuple
  *			Fetch the slot's regular physical tuple.
diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index 56880e3d16..36ca07beb2 100644
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -224,6 +224,18 @@ BitmapHeapNext(BitmapHeapScanState *node)
 
 			BitmapAdjustPrefetchIterator(node, tbmres);
 
+			/*
+			 * Ignore any claimed entries past what we think is the end of the
+			 * relation.  (This is probably not necessary given that we got at
+			 * least AccessShareLock on the table before performing any of the
+			 * indexscans, but let's be safe.)
+			 */
+			if (tbmres->blockno >= scan->rs_nblocks)
+			{
+				node->tbmres = tbmres = NULL;
+				continue;
+			}
+
 			/*
 			 * We can skip fetching the heap page if we don't need any fields
 			 * from the heap, and the bitmap entries don't need rechecking,
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 3cc9092413..b3851b180d 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -607,7 +607,7 @@ ExecDelete(ModifyTableState *mtstate,
 		   bool canSetTag,
 		   bool changingPart,
 		   bool *tupleDeleted,
-		   TupleTableSlot **epqslot)
+		   TupleTableSlot **epqreturnslot)
 {
 	ResultRelInfo *resultRelInfo;
 	Relation	resultRelationDesc;
@@ -632,7 +632,7 @@ ExecDelete(ModifyTableState *mtstate,
 		bool		dodelete;
 
 		dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
-										tupleid, oldtuple, epqslot);
+										tupleid, oldtuple, epqreturnslot);
 
 		if (!dodelete)			/* "do nothing" */
 			return NULL;
@@ -724,8 +724,21 @@ ldelete:;
 					/* Tuple no more passing quals, exiting... */
 					return NULL;
 				}
+
+				/**/
+				if (epqreturnslot)
+				{
+					*epqreturnslot = epqslot;
+					return NULL;
+				}
+
 				goto ldelete;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
@@ -1196,6 +1209,11 @@ lreplace:;
 				slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
 				goto lreplace;
 			}
+			else if (result == HeapTupleInvisible)
+			{
+				/* tuple is not visible; nothing to do */
+				return NULL;
+			}
 		}
 
 		switch (result)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 54382aba88..ea48e1d6e8 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -4037,7 +4037,6 @@ CreateStatsStmt:
  *
  *****************************************************************************/
 
-// PBORKED: storage option
 CreateAsStmt:
 		CREATE OptTemp TABLE create_as_target AS SelectStmt opt_with_data
 				{
@@ -4068,14 +4067,16 @@ CreateAsStmt:
 		;
 
 create_as_target:
-			qualified_name opt_column_list OptWith OnCommitOption OptTableSpace
+			qualified_name opt_column_list table_access_method_clause
+			OptWith OnCommitOption OptTableSpace
 				{
 					$$ = makeNode(IntoClause);
 					$$->rel = $1;
 					$$->colNames = $2;
-					$$->options = $3;
-					$$->onCommit = $4;
-					$$->tableSpaceName = $5;
+					$$->accessMethod = $3;
+					$$->options = $4;
+					$$->onCommit = $5;
+					$$->tableSpaceName = $6;
 					$$->viewQuery = NULL;
 					$$->skipData = false;		/* might get changed later */
 				}
@@ -4125,14 +4126,15 @@ CreateMatViewStmt:
 		;
 
 create_mv_target:
-			qualified_name opt_column_list opt_reloptions OptTableSpace
+			qualified_name opt_column_list table_access_method_clause opt_reloptions OptTableSpace
 				{
 					$$ = makeNode(IntoClause);
 					$$->rel = $1;
 					$$->colNames = $2;
-					$$->options = $3;
+					$$->accessMethod = $3;
+					$$->options = $4;
 					$$->onCommit = ONCOMMIT_NOOP;
-					$$->tableSpaceName = $4;
+					$$->tableSpaceName = $5;
 					$$->viewQuery = NULL;		/* filled at analysis time */
 					$$->skipData = false;		/* might get changed later */
 				}
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index 05f38cfd0d..20fc425a27 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -476,6 +476,7 @@ extern TupleTableSlot *ExecCopySlot(TupleTableSlot *dstslot,
 
 extern void ExecForceStoreHeapTuple(HeapTuple tuple,
 			   TupleTableSlot *slot);
+extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 
 extern void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum);
 extern Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull);
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 40f6eb03d2..4d194a8c2a 100644
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -111,6 +111,7 @@ typedef struct IntoClause
 
 	RangeVar   *rel;			/* target relation name */
 	List	   *colNames;		/* column names to assign, or NIL */
+	char	   *accessMethod;	/* table access method */
 	List	   *options;		/* options from WITH clause */
 	OnCommitAction onCommit;	/* what do we do at COMMIT? */
 	char	   *tableSpaceName; /* table space to use, or NULL */
diff --git a/src/test/regress/expected/create_am.out b/src/test/regress/expected/create_am.out
index 47dd885c4e..a4094ca3f1 100644
--- a/src/test/regress/expected/create_am.out
+++ b/src/test/regress/expected/create_am.out
@@ -99,3 +99,81 @@ HINT:  Use DROP ... CASCADE to drop the dependent objects too.
 -- Drop access method cascade
 DROP ACCESS METHOD gist2 CASCADE;
 NOTICE:  drop cascades to index grect2ind2
+-- Create a heap2 table am handler with heapam handler
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+SELECT * FROM pg_am where amtype = 't';
+ amname |      amhandler       | amtype 
+--------+----------------------+--------
+ heap   | heap_tableam_handler | t
+ heap2  | heap_tableam_handler | t
+(2 rows)
+
+CREATE TABLE tbl_heap2(f1 int, f2 char(100)) using heap2;
+INSERT INTO tbl_heap2 VALUES(generate_series(1,10), 'Test series');
+SELECT count(*) FROM tbl_heap2;
+ count 
+-------
+    10
+(1 row)
+
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tbl_heap2';
+  relname  | relkind | amname 
+-----------+---------+--------
+ tbl_heap2 | r       | heap2
+(1 row)
+
+-- create table as using heap2
+CREATE TABLE tblas_heap2 using heap2 AS select * from tbl_heap2;
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tblas_heap2';
+   relname   | relkind | amname 
+-------------+---------+--------
+ tblas_heap2 | r       | heap2
+(1 row)
+
+--
+-- select into doesn't support new syntax, so it should be
+-- default access method.
+--
+SELECT INTO tblselectinto_heap from tbl_heap2;
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tblselectinto_heap';
+      relname       | relkind | amname 
+--------------------+---------+--------
+ tblselectinto_heap | r       | heap
+(1 row)
+
+DROP TABLE tblselectinto_heap;
+-- create materialized view using heap2
+CREATE MATERIALIZED VIEW mv_heap2 USING heap2 AS
+		SELECT * FROM tbl_heap2;
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'mv_heap2';
+ relname  | relkind | amname 
+----------+---------+--------
+ mv_heap2 | m       | heap2
+(1 row)
+
+-- Try creating the unsupported relation kinds with using syntax
+CREATE VIEW test_view USING heap2 AS SELECT * FROM tbl_heap2;
+ERROR:  syntax error at or near "USING"
+LINE 1: CREATE VIEW test_view USING heap2 AS SELECT * FROM tbl_heap2...
+                              ^
+CREATE SEQUENCE test_seq USING heap2;
+ERROR:  syntax error at or near "USING"
+LINE 1: CREATE SEQUENCE test_seq USING heap2;
+                                 ^
+-- Drop table access method, but fails as objects depends on it
+DROP ACCESS METHOD heap2;
+ERROR:  cannot drop access method heap2 because other objects depend on it
+DETAIL:  table tbl_heap2 depends on access method heap2
+table tblas_heap2 depends on access method heap2
+materialized view mv_heap2 depends on access method heap2
+HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+-- Drop table access method with cascade
+DROP ACCESS METHOD heap2 CASCADE;
+NOTICE:  drop cascades to 3 other objects
+DETAIL:  drop cascades to table tbl_heap2
+drop cascades to table tblas_heap2
+drop cascades to materialized view mv_heap2
diff --git a/src/test/regress/sql/create_am.sql b/src/test/regress/sql/create_am.sql
index 3e0ac104f3..0472a60f20 100644
--- a/src/test/regress/sql/create_am.sql
+++ b/src/test/regress/sql/create_am.sql
@@ -66,3 +66,49 @@ DROP ACCESS METHOD gist2;
 
 -- Drop access method cascade
 DROP ACCESS METHOD gist2 CASCADE;
+
+-- Create a heap2 table am handler with heapam handler
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+
+SELECT * FROM pg_am where amtype = 't';
+
+CREATE TABLE tbl_heap2(f1 int, f2 char(100)) using heap2;
+INSERT INTO tbl_heap2 VALUES(generate_series(1,10), 'Test series');
+SELECT count(*) FROM tbl_heap2;
+
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tbl_heap2';
+
+-- create table as using heap2
+CREATE TABLE tblas_heap2 using heap2 AS select * from tbl_heap2;
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tblas_heap2';
+
+--
+-- select into doesn't support new syntax, so it should be
+-- default access method.
+--
+SELECT INTO tblselectinto_heap from tbl_heap2;
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'tblselectinto_heap';
+
+DROP TABLE tblselectinto_heap;
+
+-- create materialized view using heap2
+CREATE MATERIALIZED VIEW mv_heap2 USING heap2 AS
+		SELECT * FROM tbl_heap2;
+
+SELECT r.relname, r.relkind, a.amname from pg_class as r, pg_am as a
+		where a.oid = r.relam AND r.relname = 'mv_heap2';
+
+-- Try creating the unsupported relation kinds with using syntax
+CREATE VIEW test_view USING heap2 AS SELECT * FROM tbl_heap2;
+
+CREATE SEQUENCE test_seq USING heap2;
+
+
+-- Drop table access method, but fails as objects depends on it
+DROP ACCESS METHOD heap2;
+
+-- Drop table access method with cascade
+DROP ACCESS METHOD heap2 CASCADE;
-- 
2.18.0.windows.1

diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 0a181b01d9..a292c531b5 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1484,6 +1484,7 @@ describeOneTableDetails(const char *schemaname,
 		char	   *reloftype;
 		char		relpersistence;
 		char		relreplident;
+		char	   *relam;
 	}			tableinfo;
 	bool		show_column_details = false;
 
@@ -1503,9 +1504,10 @@ describeOneTableDetails(const char *schemaname,
 						  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
 						  "false AS relhasoids, %s, c.reltablespace, "
 						  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
-						  "c.relpersistence, c.relreplident\n"
+						  "c.relpersistence, c.relreplident, am.amname\n"
 						  "FROM pg_catalog.pg_class c\n "
 						  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
+						  "LEFT JOIN pg_catalog.pg_am am ON (c.relam = am.oid)\n"
 						  "WHERE c.oid = '%s';",
 						  (verbose ?
 						   "pg_catalog.array_to_string(c.reloptions || "
@@ -1656,6 +1658,8 @@ describeOneTableDetails(const char *schemaname,
 		*(PQgetvalue(res, 0, 11)) : 0;
 	tableinfo.relreplident = (pset.sversion >= 90400) ?
 		*(PQgetvalue(res, 0, 12)) : 'd';
+	tableinfo.relam = (pset.sversion >= 120000) ?
+		pg_strdup(PQgetvalue(res, 0, 13)) : NULL;
 	PQclear(res);
 	res = NULL;
 
@@ -3141,6 +3145,15 @@ describeOneTableDetails(const char *schemaname,
 		/* Tablespace info */
 		add_tablespace_footer(&cont, tableinfo.relkind, tableinfo.tablespace,
 							  true);
+
+		/* Access method info */
+		if (pset.sversion >= 120000 && verbose)
+		{
+			printfPQExpBuffer(&buf, _("Access method: %s"), tableinfo.relam);
+			printTableAddFooter(&cont, buf.data);
+		}
+
+
 	}
 
 	/* reloptions, if verbose */
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 19bb538411..84d182303e 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -432,6 +432,7 @@ alter table check_con_tbl add check (check_con_function(check_con_tbl.*));
  f1     | integer |           |          |         | plain   |              | 
 Check constraints:
     "check_con_tbl_check" CHECK (check_con_function(check_con_tbl.*))
+Access method: heap
 
 copy check_con_tbl from stdin;
 NOTICE:  input = {"f1":1}
diff --git a/src/test/regress/expected/create_table.out b/src/test/regress/expected/create_table.out
index 7e52c27e3f..dbaa713e6b 100644
--- a/src/test/regress/expected/create_table.out
+++ b/src/test/regress/expected/create_table.out
@@ -438,6 +438,7 @@ Number of partitions: 0
  b      | text    |           |          |         | extended |              | 
 Partition key: RANGE (((a + 1)), substr(b, 1, 5))
 Number of partitions: 0
+Access method: heap
 
 INSERT INTO partitioned2 VALUES (1, 'hello');
 ERROR:  no partition of relation "partitioned2" found for row
@@ -451,6 +452,7 @@ CREATE TABLE part2_1 PARTITION OF partitioned2 FOR VALUES FROM (-1, 'aaaaa') TO
  b      | text    |           |          |         | extended |              | 
 Partition of: partitioned2 FOR VALUES FROM ('-1', 'aaaaa') TO (100, 'ccccc')
 Partition constraint: (((a + 1) IS NOT NULL) AND (substr(b, 1, 5) IS NOT NULL) AND (((a + 1) > '-1'::integer) OR (((a + 1) = '-1'::integer) AND (substr(b, 1, 5) >= 'aaaaa'::text))) AND (((a + 1) < 100) OR (((a + 1) = 100) AND (substr(b, 1, 5) < 'ccccc'::text))))
+Access method: heap
 
 DROP TABLE partitioned, partitioned2;
 --
@@ -783,6 +785,7 @@ drop table parted_collate_must_match;
  b      | integer |           | not null | 1       | plain    |              | 
 Partition of: parted FOR VALUES IN ('b')
 Partition constraint: ((a IS NOT NULL) AND (a = 'b'::text))
+Access method: heap
 
 -- Both partition bound and partition key in describe output
 \d+ part_c
@@ -795,6 +798,7 @@ Partition of: parted FOR VALUES IN ('c')
 Partition constraint: ((a IS NOT NULL) AND (a = 'c'::text))
 Partition key: RANGE (b)
 Partitions: part_c_1_10 FOR VALUES FROM (1) TO (10)
+Access method: heap
 
 -- a level-2 partition's constraint will include the parent's expressions
 \d+ part_c_1_10
@@ -805,6 +809,7 @@ Partitions: part_c_1_10 FOR VALUES FROM (1) TO (10)
  b      | integer |           | not null | 0       | plain    |              | 
 Partition of: part_c FOR VALUES FROM (1) TO (10)
 Partition constraint: ((a IS NOT NULL) AND (a = 'c'::text) AND (b IS NOT NULL) AND (b >= 1) AND (b < 10))
+Access method: heap
 
 -- Show partition count in the parent's describe output
 -- Tempted to include \d+ output listing partitions with bound info but
@@ -839,6 +844,7 @@ CREATE TABLE unbounded_range_part PARTITION OF range_parted4 FOR VALUES FROM (MI
  c      | integer |           |          |         | plain   |              | 
 Partition of: range_parted4 FOR VALUES FROM (MINVALUE, MINVALUE, MINVALUE) TO (MAXVALUE, MAXVALUE, MAXVALUE)
 Partition constraint: ((abs(a) IS NOT NULL) AND (abs(b) IS NOT NULL) AND (c IS NOT NULL))
+Access method: heap
 
 DROP TABLE unbounded_range_part;
 CREATE TABLE range_parted4_1 PARTITION OF range_parted4 FOR VALUES FROM (MINVALUE, MINVALUE, MINVALUE) TO (1, MAXVALUE, MAXVALUE);
@@ -851,6 +857,7 @@ CREATE TABLE range_parted4_1 PARTITION OF range_parted4 FOR VALUES FROM (MINVALU
  c      | integer |           |          |         | plain   |              | 
 Partition of: range_parted4 FOR VALUES FROM (MINVALUE, MINVALUE, MINVALUE) TO (1, MAXVALUE, MAXVALUE)
 Partition constraint: ((abs(a) IS NOT NULL) AND (abs(b) IS NOT NULL) AND (c IS NOT NULL) AND (abs(a) <= 1))
+Access method: heap
 
 CREATE TABLE range_parted4_2 PARTITION OF range_parted4 FOR VALUES FROM (3, 4, 5) TO (6, 7, MAXVALUE);
 \d+ range_parted4_2
@@ -862,6 +869,7 @@ CREATE TABLE range_parted4_2 PARTITION OF range_parted4 FOR VALUES FROM (3, 4, 5
  c      | integer |           |          |         | plain   |              | 
 Partition of: range_parted4 FOR VALUES FROM (3, 4, 5) TO (6, 7, MAXVALUE)
 Partition constraint: ((abs(a) IS NOT NULL) AND (abs(b) IS NOT NULL) AND (c IS NOT NULL) AND ((abs(a) > 3) OR ((abs(a) = 3) AND (abs(b) > 4)) OR ((abs(a) = 3) AND (abs(b) = 4) AND (c >= 5))) AND ((abs(a) < 6) OR ((abs(a) = 6) AND (abs(b) <= 7))))
+Access method: heap
 
 CREATE TABLE range_parted4_3 PARTITION OF range_parted4 FOR VALUES FROM (6, 8, MINVALUE) TO (9, MAXVALUE, MAXVALUE);
 \d+ range_parted4_3
@@ -873,6 +881,7 @@ CREATE TABLE range_parted4_3 PARTITION OF range_parted4 FOR VALUES FROM (6, 8, M
  c      | integer |           |          |         | plain   |              | 
 Partition of: range_parted4 FOR VALUES FROM (6, 8, MINVALUE) TO (9, MAXVALUE, MAXVALUE)
 Partition constraint: ((abs(a) IS NOT NULL) AND (abs(b) IS NOT NULL) AND (c IS NOT NULL) AND ((abs(a) > 6) OR ((abs(a) = 6) AND (abs(b) >= 8))) AND (abs(a) <= 9))
+Access method: heap
 
 DROP TABLE range_parted4;
 -- user-defined operator class in partition key
@@ -909,6 +918,7 @@ SELECT obj_description('parted_col_comment'::regclass);
  b      | text    |           |          |         | extended |              | 
 Partition key: LIST (a)
 Number of partitions: 0
+Access method: heap
 
 DROP TABLE parted_col_comment;
 -- list partitioning on array type column
@@ -921,6 +931,7 @@ CREATE TABLE arrlp12 PARTITION OF arrlp FOR VALUES IN ('{1}', '{2}');
  a      | integer[] |           |          |         | extended |              | 
 Partition of: arrlp FOR VALUES IN ('{1}', '{2}')
 Partition constraint: ((a IS NOT NULL) AND ((a = '{1}'::integer[]) OR (a = '{2}'::integer[])))
+Access method: heap
 
 DROP TABLE arrlp;
 -- partition on boolean column
@@ -935,6 +946,7 @@ create table boolspart_f partition of boolspart for values in (false);
 Partition key: LIST (a)
 Partitions: boolspart_f FOR VALUES IN (false),
             boolspart_t FOR VALUES IN (true)
+Access method: heap
 
 drop table boolspart;
 -- partitions mixing temporary and permanent relations
diff --git a/src/test/regress/expected/create_table_like.out b/src/test/regress/expected/create_table_like.out
index b582211270..951d876216 100644
--- a/src/test/regress/expected/create_table_like.out
+++ b/src/test/regress/expected/create_table_like.out
@@ -164,6 +164,7 @@ CREATE TABLE ctlt12_storage (LIKE ctlt1 INCLUDING STORAGE, LIKE ctlt2 INCLUDING
  a      | text |           | not null |         | main     |              | 
  b      | text |           |          |         | extended |              | 
  c      | text |           |          |         | external |              | 
+Access method: heap
 
 CREATE TABLE ctlt12_comments (LIKE ctlt1 INCLUDING COMMENTS, LIKE ctlt2 INCLUDING COMMENTS);
 \d+ ctlt12_comments
@@ -173,6 +174,7 @@ CREATE TABLE ctlt12_comments (LIKE ctlt1 INCLUDING COMMENTS, LIKE ctlt2 INCLUDIN
  a      | text |           | not null |         | extended |              | A
  b      | text |           |          |         | extended |              | B
  c      | text |           |          |         | extended |              | C
+Access method: heap
 
 CREATE TABLE ctlt1_inh (LIKE ctlt1 INCLUDING CONSTRAINTS INCLUDING COMMENTS) INHERITS (ctlt1);
 NOTICE:  merging column "a" with inherited definition
@@ -187,6 +189,7 @@ NOTICE:  merging constraint "ctlt1_a_check" with inherited definition
 Check constraints:
     "ctlt1_a_check" CHECK (length(a) > 2)
 Inherits: ctlt1
+Access method: heap
 
 SELECT description FROM pg_description, pg_constraint c WHERE classoid = 'pg_constraint'::regclass AND objoid = c.oid AND c.conrelid = 'ctlt1_inh'::regclass;
  description 
@@ -208,6 +211,7 @@ Check constraints:
     "ctlt3_a_check" CHECK (length(a) < 5)
 Inherits: ctlt1,
           ctlt3
+Access method: heap
 
 CREATE TABLE ctlt13_like (LIKE ctlt3 INCLUDING CONSTRAINTS INCLUDING COMMENTS INCLUDING STORAGE) INHERITS (ctlt1);
 NOTICE:  merging column "a" with inherited definition
@@ -222,6 +226,7 @@ Check constraints:
     "ctlt1_a_check" CHECK (length(a) > 2)
     "ctlt3_a_check" CHECK (length(a) < 5)
 Inherits: ctlt1
+Access method: heap
 
 SELECT description FROM pg_description, pg_constraint c WHERE classoid = 'pg_constraint'::regclass AND objoid = c.oid AND c.conrelid = 'ctlt13_like'::regclass;
  description 
@@ -244,6 +249,7 @@ Check constraints:
     "ctlt1_a_check" CHECK (length(a) > 2)
 Statistics objects:
     "public"."ctlt_all_a_b_stat" (ndistinct, dependencies) ON a, b FROM ctlt_all
+Access method: heap
 
 SELECT c.relname, objsubid, description FROM pg_description, pg_index i, pg_class c WHERE classoid = 'pg_class'::regclass AND objoid = i.indexrelid AND c.oid = i.indexrelid AND i.indrelid = 'ctlt_all'::regclass ORDER BY c.relname, objsubid;
     relname     | objsubid | description 
diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out
index 0b5a9041b0..976fd7446f 100644
--- a/src/test/regress/expected/domain.out
+++ b/src/test/regress/expected/domain.out
@@ -282,6 +282,7 @@ Rules:
     silly AS
     ON DELETE TO dcomptable DO INSTEAD  UPDATE dcomptable SET d1.r = (dcomptable.d1).r - 1::double precision, d1.i = (dcomptable.d1).i + 1::double precision
   WHERE (dcomptable.d1).i > 0::double precision
+Access method: heap
 
 drop table dcomptable;
 drop type comptype cascade;
@@ -419,6 +420,7 @@ Rules:
     silly AS
     ON DELETE TO dcomptable DO INSTEAD  UPDATE dcomptable SET d1[1].r = dcomptable.d1[1].r - 1::double precision, d1[1].i = dcomptable.d1[1].i + 1::double precision
   WHERE dcomptable.d1[1].i > 0::double precision
+Access method: heap
 
 drop table dcomptable;
 drop type comptype cascade;
diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out
index 4d82d3a7e8..94ab874d75 100644
--- a/src/test/regress/expected/foreign_data.out
+++ b/src/test/regress/expected/foreign_data.out
@@ -731,6 +731,7 @@ Check constraints:
     "ft1_c3_check" CHECK (c3 >= '01-01-1994'::date AND c3 <= '01-31-1994'::date)
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 \det+
                                  List of foreign tables
@@ -800,6 +801,7 @@ Check constraints:
     "ft1_c3_check" CHECK (c3 >= '01-01-1994'::date AND c3 <= '01-31-1994'::date)
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 -- can't change the column type if it's used elsewhere
 CREATE TABLE use_ft1_column_type (x ft1);
@@ -1339,6 +1341,7 @@ CREATE FOREIGN TABLE ft2 () INHERITS (fd_pt1)
  c2     | text    |           |          |         | extended |              | 
  c3     | date    |           |          |         | plain    |              | 
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1350,6 +1353,7 @@ Child tables: ft2
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 DROP FOREIGN TABLE ft2;
 \d+ fd_pt1
@@ -1359,6 +1363,7 @@ DROP FOREIGN TABLE ft2;
  c1     | integer |           | not null |         | plain    |              | 
  c2     | text    |           |          |         | extended |              | 
  c3     | date    |           |          |         | plain    |              | 
+Access method: heap
 
 CREATE FOREIGN TABLE ft2 (
 	c1 integer NOT NULL,
@@ -1374,6 +1379,7 @@ CREATE FOREIGN TABLE ft2 (
  c3     | date    |           |          |         |             | plain    |              | 
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 ALTER FOREIGN TABLE ft2 INHERIT fd_pt1;
 \d+ fd_pt1
@@ -1384,6 +1390,7 @@ ALTER FOREIGN TABLE ft2 INHERIT fd_pt1;
  c2     | text    |           |          |         | extended |              | 
  c3     | date    |           |          |         | plain    |              | 
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1395,6 +1402,7 @@ Child tables: ft2
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 CREATE TABLE ct3() INHERITS(ft2);
 CREATE FOREIGN TABLE ft3 (
@@ -1418,6 +1426,7 @@ FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
 Child tables: ct3,
               ft3
+Access method: 
 
 \d+ ct3
                                     Table "public.ct3"
@@ -1427,6 +1436,7 @@ Child tables: ct3,
  c2     | text    |           |          |         | extended |              | 
  c3     | date    |           |          |         | plain    |              | 
 Inherits: ft2
+Access method: heap
 
 \d+ ft3
                                        Foreign table "public.ft3"
@@ -1437,6 +1447,7 @@ Inherits: ft2
  c3     | date    |           |          |         |             | plain    |              | 
 Server: s0
 Inherits: ft2
+Access method: 
 
 -- add attributes recursively
 ALTER TABLE fd_pt1 ADD COLUMN c4 integer;
@@ -1457,6 +1468,7 @@ ALTER TABLE fd_pt1 ADD COLUMN c8 integer;
  c7     | integer |           | not null |         | plain    |              | 
  c8     | integer |           |          |         | plain    |              | 
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1475,6 +1487,7 @@ FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
 Child tables: ct3,
               ft3
+Access method: 
 
 \d+ ct3
                                     Table "public.ct3"
@@ -1489,6 +1502,7 @@ Child tables: ct3,
  c7     | integer |           | not null |         | plain    |              | 
  c8     | integer |           |          |         | plain    |              | 
 Inherits: ft2
+Access method: heap
 
 \d+ ft3
                                        Foreign table "public.ft3"
@@ -1504,6 +1518,7 @@ Inherits: ft2
  c8     | integer |           |          |         |             | plain    |              | 
 Server: s0
 Inherits: ft2
+Access method: 
 
 -- alter attributes recursively
 ALTER TABLE fd_pt1 ALTER COLUMN c4 SET DEFAULT 0;
@@ -1531,6 +1546,7 @@ ALTER TABLE fd_pt1 ALTER COLUMN c8 SET STORAGE EXTERNAL;
  c7     | integer |           |          |         | plain    |              | 
  c8     | text    |           |          |         | external |              | 
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1549,6 +1565,7 @@ FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
 Child tables: ct3,
               ft3
+Access method: 
 
 -- drop attributes recursively
 ALTER TABLE fd_pt1 DROP COLUMN c4;
@@ -1564,6 +1581,7 @@ ALTER TABLE fd_pt1 DROP COLUMN c8;
  c2     | text    |           |          |         | extended |              | 
  c3     | date    |           |          |         | plain    |              | 
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1577,6 +1595,7 @@ FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
 Child tables: ct3,
               ft3
+Access method: 
 
 -- add constraints recursively
 ALTER TABLE fd_pt1 ADD CONSTRAINT fd_pt1chk1 CHECK (c1 > 0) NO INHERIT;
@@ -1604,6 +1623,7 @@ Check constraints:
     "fd_pt1chk1" CHECK (c1 > 0) NO INHERIT
     "fd_pt1chk2" CHECK (c2 <> ''::text)
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1619,6 +1639,7 @@ FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
 Child tables: ct3,
               ft3
+Access method: 
 
 \set VERBOSITY terse
 DROP FOREIGN TABLE ft2; -- ERROR
@@ -1648,6 +1669,7 @@ Check constraints:
     "fd_pt1chk1" CHECK (c1 > 0) NO INHERIT
     "fd_pt1chk2" CHECK (c2 <> ''::text)
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1661,6 +1683,7 @@ Check constraints:
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 -- drop constraints recursively
 ALTER TABLE fd_pt1 DROP CONSTRAINT fd_pt1chk1 CASCADE;
@@ -1678,6 +1701,7 @@ ALTER TABLE fd_pt1 ADD CONSTRAINT fd_pt1chk3 CHECK (c2 <> '') NOT VALID;
 Check constraints:
     "fd_pt1chk3" CHECK (c2 <> ''::text) NOT VALID
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1692,6 +1716,7 @@ Check constraints:
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 -- VALIDATE CONSTRAINT need do nothing on foreign tables
 ALTER TABLE fd_pt1 VALIDATE CONSTRAINT fd_pt1chk3;
@@ -1705,6 +1730,7 @@ ALTER TABLE fd_pt1 VALIDATE CONSTRAINT fd_pt1chk3;
 Check constraints:
     "fd_pt1chk3" CHECK (c2 <> ''::text)
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1719,6 +1745,7 @@ Check constraints:
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 -- changes name of an attribute recursively
 ALTER TABLE fd_pt1 RENAME COLUMN c1 TO f1;
@@ -1736,6 +1763,7 @@ ALTER TABLE fd_pt1 RENAME CONSTRAINT fd_pt1chk3 TO f2_check;
 Check constraints:
     "f2_check" CHECK (f2 <> ''::text)
 Child tables: ft2
+Access method: heap
 
 \d+ ft2
                                        Foreign table "public.ft2"
@@ -1750,6 +1778,7 @@ Check constraints:
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
 Inherits: fd_pt1
+Access method: 
 
 -- TRUNCATE doesn't work on foreign tables, either directly or recursively
 TRUNCATE ft2;  -- ERROR
@@ -1799,6 +1828,7 @@ CREATE FOREIGN TABLE fd_pt2_1 PARTITION OF fd_pt2 FOR VALUES IN (1)
  c3     | date    |           |          |         | plain    |              | 
 Partition key: LIST (c1)
 Partitions: fd_pt2_1 FOR VALUES IN (1)
+Access method: heap
 
 \d+ fd_pt2_1
                                      Foreign table "public.fd_pt2_1"
@@ -1811,6 +1841,7 @@ Partition of: fd_pt2 FOR VALUES IN (1)
 Partition constraint: ((c1 IS NOT NULL) AND (c1 = 1))
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 -- partition cannot have additional columns
 DROP FOREIGN TABLE fd_pt2_1;
@@ -1830,6 +1861,7 @@ CREATE FOREIGN TABLE fd_pt2_1 (
  c4     | character(1) |           |          |         |             | extended |              | 
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 ALTER TABLE fd_pt2 ATTACH PARTITION fd_pt2_1 FOR VALUES IN (1);       -- ERROR
 ERROR:  table "fd_pt2_1" contains column "c4" not found in parent "fd_pt2"
@@ -1844,6 +1876,7 @@ DROP FOREIGN TABLE fd_pt2_1;
  c3     | date    |           |          |         | plain    |              | 
 Partition key: LIST (c1)
 Number of partitions: 0
+Access method: heap
 
 CREATE FOREIGN TABLE fd_pt2_1 (
 	c1 integer NOT NULL,
@@ -1859,6 +1892,7 @@ CREATE FOREIGN TABLE fd_pt2_1 (
  c3     | date    |           |          |         |             | plain    |              | 
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 -- no attach partition validation occurs for foreign tables
 ALTER TABLE fd_pt2 ATTACH PARTITION fd_pt2_1 FOR VALUES IN (1);
@@ -1871,6 +1905,7 @@ ALTER TABLE fd_pt2 ATTACH PARTITION fd_pt2_1 FOR VALUES IN (1);
  c3     | date    |           |          |         | plain    |              | 
 Partition key: LIST (c1)
 Partitions: fd_pt2_1 FOR VALUES IN (1)
+Access method: heap
 
 \d+ fd_pt2_1
                                      Foreign table "public.fd_pt2_1"
@@ -1883,6 +1918,7 @@ Partition of: fd_pt2 FOR VALUES IN (1)
 Partition constraint: ((c1 IS NOT NULL) AND (c1 = 1))
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 -- cannot add column to a partition
 ALTER TABLE fd_pt2_1 ADD c4 char;
@@ -1899,6 +1935,7 @@ ALTER TABLE fd_pt2_1 ADD CONSTRAINT p21chk CHECK (c2 <> '');
  c3     | date    |           |          |         | plain    |              | 
 Partition key: LIST (c1)
 Partitions: fd_pt2_1 FOR VALUES IN (1)
+Access method: heap
 
 \d+ fd_pt2_1
                                      Foreign table "public.fd_pt2_1"
@@ -1913,6 +1950,7 @@ Check constraints:
     "p21chk" CHECK (c2 <> ''::text)
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 -- cannot drop inherited NOT NULL constraint from a partition
 ALTER TABLE fd_pt2_1 ALTER c1 DROP NOT NULL;
@@ -1929,6 +1967,7 @@ ALTER TABLE fd_pt2 ALTER c2 SET NOT NULL;
  c3     | date    |           |          |         | plain    |              | 
 Partition key: LIST (c1)
 Number of partitions: 0
+Access method: heap
 
 \d+ fd_pt2_1
                                      Foreign table "public.fd_pt2_1"
@@ -1941,6 +1980,7 @@ Check constraints:
     "p21chk" CHECK (c2 <> ''::text)
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 ALTER TABLE fd_pt2 ATTACH PARTITION fd_pt2_1 FOR VALUES IN (1);       -- ERROR
 ERROR:  column "c2" in child table must be marked NOT NULL
@@ -1959,6 +1999,7 @@ Partition key: LIST (c1)
 Check constraints:
     "fd_pt2chk1" CHECK (c1 > 0)
 Number of partitions: 0
+Access method: heap
 
 \d+ fd_pt2_1
                                      Foreign table "public.fd_pt2_1"
@@ -1971,6 +2012,7 @@ Check constraints:
     "p21chk" CHECK (c2 <> ''::text)
 Server: s0
 FDW options: (delimiter ',', quote '"', "be quoted" 'value')
+Access method: 
 
 ALTER TABLE fd_pt2 ATTACH PARTITION fd_pt2_1 FOR VALUES IN (1);       -- ERROR
 ERROR:  child table is missing constraint "fd_pt2chk1"
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index f259d07535..7bfc11c770 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1001,6 +1001,7 @@ ALTER TABLE inhts RENAME d TO dd;
  dd     | integer |           |          |         | plain   |              | 
 Inherits: inht1,
           inhs1
+Access method: heap
 
 DROP TABLE inhts;
 -- Test for renaming in diamond inheritance
@@ -1021,6 +1022,7 @@ ALTER TABLE inht1 RENAME aa TO aaa;
  z      | integer |           |          |         | plain   |              | 
 Inherits: inht2,
           inht3
+Access method: heap
 
 CREATE TABLE inhts (d int) INHERITS (inht2, inhs1);
 NOTICE:  merging multiple inherited definitions of column "b"
@@ -1038,6 +1040,7 @@ ERROR:  cannot rename inherited column "b"
  d      | integer |           |          |         | plain   |              | 
 Inherits: inht2,
           inhs1
+Access method: heap
 
 WITH RECURSIVE r AS (
   SELECT 'inht1'::regclass AS inhrelid
@@ -1084,6 +1087,7 @@ CREATE TABLE test_constraints_inh () INHERITS (test_constraints);
 Indexes:
     "test_constraints_val1_val2_key" UNIQUE CONSTRAINT, btree (val1, val2)
 Child tables: test_constraints_inh
+Access method: heap
 
 ALTER TABLE ONLY test_constraints DROP CONSTRAINT test_constraints_val1_val2_key;
 \d+ test_constraints
@@ -1094,6 +1098,7 @@ ALTER TABLE ONLY test_constraints DROP CONSTRAINT test_constraints_val1_val2_key
  val1   | character varying |           |          |         | extended |              | 
  val2   | integer           |           |          |         | plain    |              | 
 Child tables: test_constraints_inh
+Access method: heap
 
 \d+ test_constraints_inh
                                  Table "public.test_constraints_inh"
@@ -1103,6 +1108,7 @@ Child tables: test_constraints_inh
  val1   | character varying |           |          |         | extended |              | 
  val2   | integer           |           |          |         | plain    |              | 
 Inherits: test_constraints
+Access method: heap
 
 DROP TABLE test_constraints_inh;
 DROP TABLE test_constraints;
@@ -1119,6 +1125,7 @@ CREATE TABLE test_ex_constraints_inh () INHERITS (test_ex_constraints);
 Indexes:
     "test_ex_constraints_c_excl" EXCLUDE USING gist (c WITH &&)
 Child tables: test_ex_constraints_inh
+Access method: heap
 
 ALTER TABLE test_ex_constraints DROP CONSTRAINT test_ex_constraints_c_excl;
 \d+ test_ex_constraints
@@ -1127,6 +1134,7 @@ ALTER TABLE test_ex_constraints DROP CONSTRAINT test_ex_constraints_c_excl;
 --------+--------+-----------+----------+---------+---------+--------------+-------------
  c      | circle |           |          |         | plain   |              | 
 Child tables: test_ex_constraints_inh
+Access method: heap
 
 \d+ test_ex_constraints_inh
                          Table "public.test_ex_constraints_inh"
@@ -1134,6 +1142,7 @@ Child tables: test_ex_constraints_inh
 --------+--------+-----------+----------+---------+---------+--------------+-------------
  c      | circle |           |          |         | plain   |              | 
 Inherits: test_ex_constraints
+Access method: heap
 
 DROP TABLE test_ex_constraints_inh;
 DROP TABLE test_ex_constraints;
@@ -1150,6 +1159,7 @@ Indexes:
     "test_primary_constraints_pkey" PRIMARY KEY, btree (id)
 Referenced by:
     TABLE "test_foreign_constraints" CONSTRAINT "test_foreign_constraints_id1_fkey" FOREIGN KEY (id1) REFERENCES test_primary_constraints(id)
+Access method: heap
 
 \d+ test_foreign_constraints
                          Table "public.test_foreign_constraints"
@@ -1159,6 +1169,7 @@ Referenced by:
 Foreign-key constraints:
     "test_foreign_constraints_id1_fkey" FOREIGN KEY (id1) REFERENCES test_primary_constraints(id)
 Child tables: test_foreign_constraints_inh
+Access method: heap
 
 ALTER TABLE test_foreign_constraints DROP CONSTRAINT test_foreign_constraints_id1_fkey;
 \d+ test_foreign_constraints
@@ -1167,6 +1178,7 @@ ALTER TABLE test_foreign_constraints DROP CONSTRAINT test_foreign_constraints_id
 --------+---------+-----------+----------+---------+---------+--------------+-------------
  id1    | integer |           |          |         | plain   |              | 
 Child tables: test_foreign_constraints_inh
+Access method: heap
 
 \d+ test_foreign_constraints_inh
                        Table "public.test_foreign_constraints_inh"
@@ -1174,6 +1186,7 @@ Child tables: test_foreign_constraints_inh
 --------+---------+-----------+----------+---------+---------+--------------+-------------
  id1    | integer |           |          |         | plain   |              | 
 Inherits: test_foreign_constraints
+Access method: heap
 
 DROP TABLE test_foreign_constraints_inh;
 DROP TABLE test_foreign_constraints;
diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
index 1cf6531c01..48ad462e3d 100644
--- a/src/test/regress/expected/insert.out
+++ b/src/test/regress/expected/insert.out
@@ -156,6 +156,7 @@ Rules:
     irule3 AS
     ON INSERT TO inserttest2 DO  INSERT INTO inserttest (f4[1].if1, f4[1].if2[2])  SELECT new.f1,
             new.f2
+Access method: heap
 
 drop table inserttest2;
 drop table inserttest;
@@ -461,6 +462,7 @@ Partitions: part_aa_bb FOR VALUES IN ('aa', 'bb'),
             part_null FOR VALUES IN (NULL),
             part_xx_yy FOR VALUES IN ('xx', 'yy'), PARTITIONED,
             part_default DEFAULT, PARTITIONED
+Access method: heap
 
 -- cleanup
 drop table range_parted, list_parted;
@@ -476,6 +478,7 @@ create table part_default partition of list_parted default;
  a      | integer |           |          |         | plain   |              | 
 Partition of: list_parted DEFAULT
 No partition constraint
+Access method: heap
 
 insert into part_default values (null);
 insert into part_default values (1);
@@ -813,6 +816,7 @@ Partitions: mcrparted1_lt_b FOR VALUES FROM (MINVALUE, MINVALUE) TO ('b', MINVAL
             mcrparted6_common_ge_10 FOR VALUES FROM ('common', 10) TO ('common', MAXVALUE),
             mcrparted7_gt_common_lt_d FOR VALUES FROM ('common', MAXVALUE) TO ('d', MINVALUE),
             mcrparted8_ge_d FOR VALUES FROM ('d', MINVALUE) TO (MAXVALUE, MAXVALUE)
+Access method: heap
 
 \d+ mcrparted1_lt_b
                               Table "public.mcrparted1_lt_b"
@@ -822,6 +826,7 @@ Partitions: mcrparted1_lt_b FOR VALUES FROM (MINVALUE, MINVALUE) TO ('b', MINVAL
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM (MINVALUE, MINVALUE) TO ('b', MINVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a < 'b'::text))
+Access method: heap
 
 \d+ mcrparted2_b
                                 Table "public.mcrparted2_b"
@@ -831,6 +836,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a < 'b'::text))
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('b', MINVALUE) TO ('c', MINVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a >= 'b'::text) AND (a < 'c'::text))
+Access method: heap
 
 \d+ mcrparted3_c_to_common
                            Table "public.mcrparted3_c_to_common"
@@ -840,6 +846,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a >= 'b'::text)
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('c', MINVALUE) TO ('common', MINVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a >= 'c'::text) AND (a < 'common'::text))
+Access method: heap
 
 \d+ mcrparted4_common_lt_0
                            Table "public.mcrparted4_common_lt_0"
@@ -849,6 +856,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a >= 'c'::text)
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('common', MINVALUE) TO ('common', 0)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::text) AND (b < 0))
+Access method: heap
 
 \d+ mcrparted5_common_0_to_10
                          Table "public.mcrparted5_common_0_to_10"
@@ -858,6 +866,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::te
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('common', 0) TO ('common', 10)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::text) AND (b >= 0) AND (b < 10))
+Access method: heap
 
 \d+ mcrparted6_common_ge_10
                           Table "public.mcrparted6_common_ge_10"
@@ -867,6 +876,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::te
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('common', 10) TO ('common', MAXVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::text) AND (b >= 10))
+Access method: heap
 
 \d+ mcrparted7_gt_common_lt_d
                          Table "public.mcrparted7_gt_common_lt_d"
@@ -876,6 +886,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a = 'common'::te
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('common', MAXVALUE) TO ('d', MINVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a > 'common'::text) AND (a < 'd'::text))
+Access method: heap
 
 \d+ mcrparted8_ge_d
                               Table "public.mcrparted8_ge_d"
@@ -885,6 +896,7 @@ Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a > 'common'::te
  b      | integer |           |          |         | plain    |              | 
 Partition of: mcrparted FOR VALUES FROM ('d', MINVALUE) TO (MAXVALUE, MAXVALUE)
 Partition constraint: ((a IS NOT NULL) AND (b IS NOT NULL) AND (a >= 'd'::text))
+Access method: heap
 
 insert into mcrparted values ('aaa', 0), ('b', 0), ('bz', 10), ('c', -10),
     ('comm', -10), ('common', -10), ('common', 0), ('common', 10),
diff --git a/src/test/regress/expected/matview.out b/src/test/regress/expected/matview.out
index 08cd4bea48..af943ea430 100644
--- a/src/test/regress/expected/matview.out
+++ b/src/test/regress/expected/matview.out
@@ -104,6 +104,7 @@ View definition:
     mvtest_tv.totamt
    FROM mvtest_tv
   ORDER BY mvtest_tv.type;
+Access method: heap
 
 \d+ mvtest_tvm
                            Materialized view "public.mvtest_tvm"
@@ -116,6 +117,7 @@ View definition:
     mvtest_tv.totamt
    FROM mvtest_tv
   ORDER BY mvtest_tv.type;
+Access method: heap
 
 \d+ mvtest_tvvm
                            Materialized view "public.mvtest_tvvm"
@@ -125,6 +127,7 @@ View definition:
 View definition:
  SELECT mvtest_tvv.grandtot
    FROM mvtest_tvv;
+Access method: heap
 
 \d+ mvtest_bb
                             Materialized view "public.mvtest_bb"
@@ -136,6 +139,7 @@ Indexes:
 View definition:
  SELECT mvtest_tvvmv.grandtot
    FROM mvtest_tvvmv;
+Access method: heap
 
 -- test schema behavior
 CREATE SCHEMA mvtest_mvschema;
@@ -152,6 +156,7 @@ Indexes:
 View definition:
  SELECT sum(mvtest_tvm.totamt) AS grandtot
    FROM mvtest_mvschema.mvtest_tvm;
+Access method: heap
 
 SET search_path = mvtest_mvschema, public;
 \d+ mvtest_tvm
@@ -165,6 +170,7 @@ View definition:
     mvtest_tv.totamt
    FROM mvtest_tv
   ORDER BY mvtest_tv.type;
+Access method: heap
 
 -- modify the underlying table data
 INSERT INTO mvtest_t VALUES (6, 'z', 13);
@@ -369,6 +375,7 @@ UNION ALL
  SELECT mvtest_vt2.moo,
     3 * mvtest_vt2.moo
    FROM mvtest_vt2;
+Access method: heap
 
 CREATE MATERIALIZED VIEW mv_test3 AS SELECT * FROM mv_test2 WHERE moo = 12345;
 SELECT relispopulated FROM pg_class WHERE oid = 'mv_test3'::regclass;
@@ -507,6 +514,7 @@ View definition:
     'foo'::text AS u,
     'foo'::text AS u2,
     NULL::text AS n;
+Access method: heap
 
 SELECT * FROM mv_unspecified_types;
  i  | num  |  u  | u2  | n 
diff --git a/src/test/regress/expected/publication.out b/src/test/regress/expected/publication.out
index afbbdd543d..439a592778 100644
--- a/src/test/regress/expected/publication.out
+++ b/src/test/regress/expected/publication.out
@@ -74,6 +74,7 @@ Indexes:
     "testpub_tbl2_pkey" PRIMARY KEY, btree (id)
 Publications:
     "testpub_foralltables"
+Access method: heap
 
 \dRp+ testpub_foralltables
                         Publication testpub_foralltables
@@ -150,6 +151,7 @@ Publications:
     "testpib_ins_trunct"
     "testpub_default"
     "testpub_fortbl"
+Access method: heap
 
 \d+ testpub_tbl1
                                                 Table "public.testpub_tbl1"
@@ -163,6 +165,7 @@ Publications:
     "testpib_ins_trunct"
     "testpub_default"
     "testpub_fortbl"
+Access method: heap
 
 \dRp+ testpub_default
                            Publication testpub_default
@@ -188,6 +191,7 @@ Indexes:
 Publications:
     "testpib_ins_trunct"
     "testpub_fortbl"
+Access method: heap
 
 -- permissions
 SET ROLE regress_publication_user2;
diff --git a/src/test/regress/expected/replica_identity.out b/src/test/regress/expected/replica_identity.out
index 175ecd2879..9ae7a090b4 100644
--- a/src/test/regress/expected/replica_identity.out
+++ b/src/test/regress/expected/replica_identity.out
@@ -171,6 +171,7 @@ Indexes:
     "test_replica_identity_hash" hash (nonkey)
     "test_replica_identity_keyab" btree (keya, keyb)
 Replica Identity: FULL
+Access method: heap
 
 ALTER TABLE test_replica_identity REPLICA IDENTITY NOTHING;
 SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
diff --git a/src/test/regress/expected/rowsecurity.out b/src/test/regress/expected/rowsecurity.out
index 1d12b01068..b01ff58c41 100644
--- a/src/test/regress/expected/rowsecurity.out
+++ b/src/test/regress/expected/rowsecurity.out
@@ -958,6 +958,7 @@ Policies:
 Partitions: part_document_fiction FOR VALUES FROM (11) TO (12),
             part_document_nonfiction FOR VALUES FROM (99) TO (100),
             part_document_satire FOR VALUES FROM (55) TO (56)
+Access method: heap
 
 SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%part_document%' ORDER BY policyname;
      schemaname     |   tablename   | policyname | permissive  |       roles        | cmd |                    qual                    | with_check 
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index b68b8d273f..22c38ae2e8 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -2817,6 +2817,7 @@ Rules:
     r3 AS
     ON DELETE TO rules_src DO
  NOTIFY rules_src_deletion
+Access method: heap
 
 --
 -- Ensure an aliased target relation for insert is correctly deparsed.
@@ -2845,6 +2846,7 @@ Rules:
     r5 AS
     ON UPDATE TO rules_src DO INSTEAD  UPDATE rules_log trgt SET tag = 'updated'::text
   WHERE trgt.f1 = new.f1
+Access method: heap
 
 --
 -- check alter rename rule
diff --git a/src/test/regress/expected/update.out b/src/test/regress/expected/update.out
index d09326c182..6b857bbc14 100644
--- a/src/test/regress/expected/update.out
+++ b/src/test/regress/expected/update.out
@@ -669,6 +669,7 @@ create table part_def partition of range_parted default;
  e      | character varying |           |          |         | extended |              | 
 Partition of: range_parted DEFAULT
 Partition constraint: (NOT ((a IS NOT NULL) AND (b IS NOT NULL) AND (((a = 'a'::text) AND (b >= '1'::bigint) AND (b < '10'::bigint)) OR ((a = 'a'::text) AND (b >= '10'::bigint) AND (b < '20'::bigint)) OR ((a = 'b'::text) AND (b >= '1'::bigint) AND (b < '10'::bigint)) OR ((a = 'b'::text) AND (b >= '10'::bigint) AND (b < '20'::bigint)) OR ((a = 'b'::text) AND (b >= '20'::bigint) AND (b < '30'::bigint)))))
+Access method: heap
 
 insert into range_parted values ('c', 9);
 -- ok

commit 37cfd7cf84fcdaeff7ba5ed6e56c6692377e9b37
Author: erthalion <9erthalion6@gmail.com>
Date:   Sun Dec 16 20:31:33 2018 +0100

    pg_dump support

diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..fca00d7b5c 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -5829,6 +5829,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5915,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname AS amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5946,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6414,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6484,10 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
 
 		/* other fields were zeroed above */
 
@@ -12546,6 +12553,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -15601,6 +15611,9 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 			if (tbinfo->relkind == RELKIND_PARTITIONED_TABLE)
 				appendPQExpBuffer(q, "\nPARTITION BY %s", tbinfo->partkeydef);
 
+			if (tbinfo->amname != NULL && strcmp(tbinfo->amname, "heap") != 0)
+				appendPQExpBuffer(q, "\nUSING %s", tbinfo->amname);
+
 			if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
 				appendPQExpBuffer(q, "\nSERVER %s", fmtId(srvname));
 		}
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4ca6a802f3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname;			/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index 58bd3805f4..f9bae43132 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -85,6 +85,7 @@ static void _becomeUser(ArchiveHandle *AH, const char *user);
 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
+static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tablespace);
 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
@@ -1072,6 +1073,7 @@ ArchiveEntry(Archive *AHX,
 			 const char *namespace,
 			 const char *tablespace,
 			 const char *owner,
+			 const char *tableam,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
@@ -1099,6 +1101,7 @@ ArchiveEntry(Archive *AHX,
 	newToc->tag = pg_strdup(tag);
 	newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
 	newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+	newToc->tableam = tableam ? pg_strdup(tableam) : NULL;
 	newToc->owner = pg_strdup(owner);
 	newToc->desc = pg_strdup(desc);
 	newToc->defn = pg_strdup(defn);
@@ -2367,6 +2370,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt,
 	AH->currUser = NULL;		/* unknown */
 	AH->currSchema = NULL;		/* ditto */
 	AH->currTablespace = NULL;	/* ditto */
+	AH->currTableAm = NULL;	/* ditto */
 
 	AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
@@ -2594,6 +2598,7 @@ WriteToc(ArchiveHandle *AH)
 		WriteStr(AH, te->namespace);
 		WriteStr(AH, te->tablespace);
 		WriteStr(AH, te->owner);
+		WriteStr(AH, te->tableam);
 		WriteStr(AH, "false");
 
 		/* Dump list of dependencies */
@@ -2696,6 +2701,7 @@ ReadToc(ArchiveHandle *AH)
 			te->tablespace = ReadStr(AH);
 
 		te->owner = ReadStr(AH);
+		te->tableam = ReadStr(AH);
 		if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
 			write_msg(modulename,
 					  "WARNING: restoring tables WITH OIDS is not supported anymore");
@@ -3288,6 +3294,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 
 	/* re-establish fixed state */
 	_doSetFixedOutputState(AH);
@@ -3448,6 +3457,48 @@ _selectTablespace(ArchiveHandle *AH, const char *tablespace)
 	destroyPQExpBuffer(qry);
 }
 
+/*
+ * Set the proper default_table_access_method value for the table.
+ */
+static void
+_selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
+{
+	PQExpBuffer cmd = createPQExpBuffer();
+	const char *want, *have;
+
+	have = AH->currTableAm;
+	want = tableam;
+
+	if (!want)
+		return;
+
+	if (have && strcmp(want, have) == 0)
+		return;
+
+
+	appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", tableam);
+
+	if (RestoringToDB(AH))
+	{
+		PGresult   *res;
+
+		res = PQexec(AH->connection, cmd->data);
+
+		if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
+			warn_or_exit_horribly(AH, modulename,
+								  "could not set default_table_access_method: %s",
+								  PQerrorMessage(AH->connection));
+
+		PQclear(res);
+	}
+	else
+		ahprintf(AH, "%s\n\n", cmd->data);
+
+	destroyPQExpBuffer(cmd);
+
+	AH->currTableAm = pg_strdup(want);
+}
+
 /*
  * Extract an object description for a TOC entry, and append it to buf.
  *
@@ -3547,6 +3598,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
 	_becomeOwner(AH, te);
 	_selectOutputSchema(AH, te->namespace);
 	_selectTablespace(AH, te->tablespace);
+	_selectTableAccessMethod(AH, te->tableam);
 
 	/* Emit header comment for item */
 	if (!AH->noTocComments)
@@ -4021,6 +4073,9 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 }
 
 /*
@@ -4816,6 +4871,7 @@ CloneArchive(ArchiveHandle *AH)
 	clone->currUser = NULL;
 	clone->currSchema = NULL;
 	clone->currTablespace = NULL;
+	clone->currTableAm = NULL;
 
 	/* savedPassword must be local in case we change it while connecting */
 	if (clone->savedPassword)
@@ -4906,6 +4962,8 @@ DeCloneArchive(ArchiveHandle *AH)
 		free(AH->currSchema);
 	if (AH->currTablespace)
 		free(AH->currTablespace);
+	if (AH->currTableAm)
+		free(AH->currTableAm);
 	if (AH->savedPassword)
 		free(AH->savedPassword);
 
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 306d2ceba9..719065565b 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -347,6 +347,7 @@ struct _archiveHandle
 	char	   *currUser;		/* current username, or NULL if unknown */
 	char	   *currSchema;		/* current schema, or NULL */
 	char	   *currTablespace; /* current tablespace, or NULL */
+	char	   *currTableAm; 	/* current table access method, or NULL */
 
 	void	   *lo_buf;
 	size_t		lo_buf_used;
@@ -373,6 +374,8 @@ struct _tocEntry
 	char	   *namespace;		/* null or empty string if not in a schema */
 	char	   *tablespace;		/* null if not in a tablespace; empty string
 								 * means use database default */
+	char	   *tableam;			/* table access method, onlyt for TABLE tags */
+
 	char	   *owner;
 	char	   *desc;
 	char	   *defn;
@@ -410,7 +413,7 @@ extern TocEntry *ArchiveEntry(Archive *AHX,
 			 CatalogId catalogId, DumpId dumpId,
 			 const char *tag,
 			 const char *namespace, const char *tablespace,
-			 const char *owner,
+			 const char *owner, const char *amname,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..a3878ed9a2 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2136,7 +2136,7 @@ dumpTableData(Archive *fout, TableDataInfo *tdinfo)
 
 		te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
 						  tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
-						  NULL, tbinfo->rolname,
+						  NULL, tbinfo->rolname, NULL,
 						  "TABLE DATA", SECTION_DATA,
 						  "", "", copyStmt,
 						  &(tbinfo->dobj.dumpId), 1,
@@ -2188,6 +2188,7 @@ refreshMatViewData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name, /* Namespace */
 					 NULL,		/* Tablespace */
 					 tbinfo->rolname,	/* Owner */
+					 NULL,				/* Table access method */
 					 "MATERIALIZED VIEW DATA",	/* Desc */
 					 SECTION_POST_DATA, /* Section */
 					 q->data,	/* Create */
@@ -2726,6 +2727,7 @@ dumpDatabase(Archive *fout)
 				 NULL,			/* Namespace */
 				 NULL,			/* Tablespace */
 				 dba,			/* Owner */
+				 NULL,			/* Table access method */
 				 "DATABASE",	/* Desc */
 				 SECTION_PRE_DATA,	/* Section */
 				 creaQry->data, /* Create */
@@ -2762,7 +2764,7 @@ dumpDatabase(Archive *fout)
 			appendPQExpBufferStr(dbQry, ";\n");
 
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "COMMENT", SECTION_NONE,
 						 dbQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2789,7 +2791,7 @@ dumpDatabase(Archive *fout)
 		emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
 		if (seclabelQry->len > 0)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "SECURITY LABEL", SECTION_NONE,
 						 seclabelQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2859,7 +2861,7 @@ dumpDatabase(Archive *fout)
 
 	if (creaQry->len > 0)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 datname, NULL, NULL, dba,
+					 datname, NULL, NULL, dba, NULL,
 					 "DATABASE PROPERTIES", SECTION_PRE_DATA,
 					 creaQry->data, delQry->data, NULL,
 					 &(dbDumpId), 1,
@@ -2904,7 +2906,7 @@ dumpDatabase(Archive *fout)
 						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
 						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 "pg_largeobject", NULL, NULL, "",
+					 "pg_largeobject", NULL, NULL, "", NULL,
 					 "pg_largeobject", SECTION_PRE_DATA,
 					 loOutQry->data, "", NULL,
 					 NULL, 0,
@@ -3014,7 +3016,7 @@ dumpEncoding(Archive *AH)
 	appendPQExpBufferStr(qry, ";\n");
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "ENCODING", NULL, NULL, "",
+				 "ENCODING", NULL, NULL, "", NULL,
 				 "ENCODING", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3041,7 +3043,7 @@ dumpStdStrings(Archive *AH)
 					  stdstrings);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "STDSTRINGS", NULL, NULL, "",
+				 "STDSTRINGS", NULL, NULL, "", NULL,
 				 "STDSTRINGS", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3097,7 +3099,7 @@ dumpSearchPath(Archive *AH)
 		write_msg(NULL, "saving search_path = %s\n", path->data);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "SEARCHPATH", NULL, NULL, "",
+				 "SEARCHPATH", NULL, NULL, "", NULL,
 				 "SEARCHPATH", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3275,7 +3277,7 @@ dumpBlob(Archive *fout, BlobInfo *binfo)
 		ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
 					 binfo->dobj.name,
 					 NULL, NULL,
-					 binfo->rolname,
+					 binfo->rolname, NULL,
 					 "BLOB", SECTION_PRE_DATA,
 					 cquery->data, dquery->data, NULL,
 					 NULL, 0,
@@ -3581,6 +3583,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 						 polinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "ROW SECURITY", SECTION_POST_DATA,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -3637,6 +3640,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 					 polinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "POLICY", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -3811,6 +3815,7 @@ dumpPublication(Archive *fout, PublicationInfo *pubinfo)
 				 NULL,
 				 NULL,
 				 pubinfo->rolname,
+				 NULL,
 				 "PUBLICATION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -3954,6 +3959,7 @@ dumpPublicationTable(Archive *fout, PublicationRelInfo *pubrinfo)
 				 tbinfo->dobj.namespace->dobj.name,
 				 NULL,
 				 "",
+				 NULL,
 				 "PUBLICATION TABLE", SECTION_POST_DATA,
 				 query->data, "", NULL,
 				 NULL, 0,
@@ -4147,6 +4153,7 @@ dumpSubscription(Archive *fout, SubscriptionInfo *subinfo)
 				 NULL,
 				 NULL,
 				 subinfo->rolname,
+				 NULL,
 				 "SUBSCRIPTION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -5829,6 +5836,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5922,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname AS amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5953,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6421,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6491,11 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
+
 
 		/* other fields were zeroed above */
 
@@ -9355,7 +9370,7 @@ dumpComment(Archive *fout, const char *type, const char *name,
 		 * post-data.
 		 */
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "COMMENT", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -9423,7 +9438,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9447,7 +9462,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9728,7 +9743,7 @@ dumpDumpableObject(Archive *fout, DumpableObject *dobj)
 				TocEntry   *te;
 
 				te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
-								  dobj->name, NULL, NULL, "",
+								  dobj->name, NULL, NULL, "", NULL,
 								  "BLOBS", SECTION_DATA,
 								  "", "", NULL,
 								  NULL, 0,
@@ -9802,7 +9817,7 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
 		ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
 					 nspinfo->dobj.name,
 					 NULL, NULL,
-					 nspinfo->rolname,
+					 nspinfo->rolname, NULL,
 					 "SCHEMA", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -9938,7 +9953,7 @@ dumpExtension(Archive *fout, ExtensionInfo *extinfo)
 		ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
 					 extinfo->dobj.name,
 					 NULL, NULL,
-					 "",
+					 "", NULL,
 					 "EXTENSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10090,6 +10105,7 @@ dumpEnumType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10217,6 +10233,7 @@ dumpRangeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10290,6 +10307,7 @@ dumpUndefinedType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10572,6 +10590,7 @@ dumpBaseType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10729,6 +10748,7 @@ dumpDomain(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "DOMAIN", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10951,6 +10971,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -11085,7 +11106,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 target->data,
 						 tyinfo->dobj.namespace->dobj.name,
-						 NULL, tyinfo->rolname,
+						 NULL, tyinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tyinfo->dobj.dumpId), 1,
@@ -11142,6 +11163,7 @@ dumpShellType(Archive *fout, ShellTypeInfo *stinfo)
 					 stinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 stinfo->baseType->rolname,
+					 NULL,
 					 "SHELL TYPE", SECTION_PRE_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -11251,7 +11273,7 @@ dumpProcLang(Archive *fout, ProcLangInfo *plang)
 	if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
 					 plang->dobj.name,
-					 NULL, NULL, plang->lanowner,
+					 NULL, NULL, plang->lanowner, NULL,
 					 "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -11924,6 +11946,7 @@ dumpFunc(Archive *fout, FuncInfo *finfo)
 					 finfo->dobj.namespace->dobj.name,
 					 NULL,
 					 finfo->rolname,
+					 NULL,
 					 keyword, SECTION_PRE_DATA,
 					 q->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12056,7 +12079,7 @@ dumpCast(Archive *fout, CastInfo *cast)
 	if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "CAST", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12184,7 +12207,7 @@ dumpTransform(Archive *fout, TransformInfo *transform)
 	if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "TRANSFORM", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 transform->dobj.dependencies, transform->dobj.nDeps,
@@ -12400,6 +12423,7 @@ dumpOpr(Archive *fout, OprInfo *oprinfo)
 					 oprinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 oprinfo->rolname,
+					 NULL,
 					 "OPERATOR", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12546,6 +12570,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -12570,6 +12597,7 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 					 NULL,
 					 NULL,
 					 "",
+					 NULL,
 					 "ACCESS METHOD", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12936,6 +12964,7 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo)
 					 opcinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opcinfo->rolname,
+					 NULL,
 					 "OPERATOR CLASS", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13203,6 +13232,7 @@ dumpOpfamily(Archive *fout, OpfamilyInfo *opfinfo)
 					 opfinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opfinfo->rolname,
+					 NULL,
 					 "OPERATOR FAMILY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13346,6 +13376,7 @@ dumpCollation(Archive *fout, CollInfo *collinfo)
 					 collinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 collinfo->rolname,
+					 NULL,
 					 "COLLATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13441,6 +13472,7 @@ dumpConversion(Archive *fout, ConvInfo *convinfo)
 					 convinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 convinfo->rolname,
+					 NULL,
 					 "CONVERSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13930,6 +13962,7 @@ dumpAgg(Archive *fout, AggInfo *agginfo)
 					 agginfo->aggfn.dobj.namespace->dobj.name,
 					 NULL,
 					 agginfo->aggfn.rolname,
+					 NULL,
 					 "AGGREGATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14028,6 +14061,7 @@ dumpTSParser(Archive *fout, TSParserInfo *prsinfo)
 					 prsinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH PARSER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14108,6 +14142,7 @@ dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo)
 					 dictinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 dictinfo->rolname,
+					 NULL,
 					 "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14169,6 +14204,7 @@ dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo)
 					 tmplinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14289,6 +14325,7 @@ dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo)
 					 cfginfo->dobj.namespace->dobj.name,
 					 NULL,
 					 cfginfo->rolname,
+					 NULL,
 					 "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14355,6 +14392,7 @@ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
 					 NULL,
 					 NULL,
 					 fdwinfo->rolname,
+					 NULL,
 					 "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14446,6 +14484,7 @@ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
 					 NULL,
 					 NULL,
 					 srvinfo->rolname,
+					 NULL,
 					 "SERVER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14564,6 +14603,7 @@ dumpUserMappings(Archive *fout,
 					 namespace,
 					 NULL,
 					 owner,
+					 NULL,
 					 "USER MAPPING", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 &dumpId, 1,
@@ -14643,6 +14683,7 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo)
 					 daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
 					 NULL,
 					 daclinfo->defaclrole,
+					 NULL,
 					 "DEFAULT ACL", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -14741,6 +14782,7 @@ dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
 					 tag->data, nspname,
 					 NULL,
 					 owner ? owner : "",
+					 NULL,
 					 "ACL", SECTION_NONE,
 					 sql->data, "", NULL,
 					 &(objDumpId), 1,
@@ -14826,7 +14868,7 @@ dumpSecLabel(Archive *fout, const char *type, const char *name,
 
 		appendPQExpBuffer(tag, "%s %s", type, name);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -14908,7 +14950,7 @@ dumpTableSecLabel(Archive *fout, TableInfo *tbinfo, const char *reltypename)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 target->data,
 					 tbinfo->dobj.namespace->dobj.name,
-					 NULL, tbinfo->rolname,
+					 NULL, tbinfo->rolname, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -15994,6 +16036,8 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
 					 tbinfo->rolname,
+					 (tbinfo->relkind == RELKIND_RELATION) ?
+					 tbinfo->amname : NULL,
 					 reltypename,
 					 tbinfo->postponed_def ?
 					 SECTION_POST_DATA : SECTION_PRE_DATA,
@@ -16074,6 +16118,7 @@ dumpAttrDef(Archive *fout, AttrDefInfo *adinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "DEFAULT", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16190,6 +16235,7 @@ dumpIndex(Archive *fout, IndxInfo *indxinfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "INDEX", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16234,6 +16280,7 @@ dumpIndexAttach(Archive *fout, IndexAttachInfo *attachinfo)
 					 attachinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "INDEX ATTACH", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -16289,6 +16336,7 @@ dumpStatisticsExt(Archive *fout, StatsExtInfo *statsextinfo)
 					 statsextinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 statsextinfo->rolname,
+					 NULL,
 					 "STATISTICS", SECTION_POST_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16450,6 +16498,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16490,6 +16539,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "FK CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16522,6 +16572,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16555,6 +16606,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tyinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tyinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16829,6 +16881,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE", SECTION_PRE_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -16870,6 +16923,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "SEQUENCE OWNED BY", SECTION_PRE_DATA,
 							 query->data, "", NULL,
 							 &(tbinfo->dobj.dumpId), 1,
@@ -16938,6 +16992,7 @@ dumpSequenceData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE SET", SECTION_DATA,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -17137,6 +17192,7 @@ dumpTrigger(Archive *fout, TriggerInfo *tginfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17223,7 +17279,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo)
 	if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
 					 evtinfo->dobj.name, NULL, NULL,
-					 evtinfo->evtowner,
+					 evtinfo->evtowner, NULL,
 					 "EVENT TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17384,6 +17440,7 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "RULE", SECTION_POST_DATA,
 					 cmd->data, delcmd->data, NULL,
 					 NULL, 0,
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4024d0c1e3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname; 		/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index 58bd3805f4..6f1b717e06 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -85,6 +85,7 @@ static void _becomeUser(ArchiveHandle *AH, const char *user);
 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
+static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tablespace);
 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
@@ -1072,6 +1073,7 @@ ArchiveEntry(Archive *AHX,
 			 const char *namespace,
 			 const char *tablespace,
 			 const char *owner,
+			 const char *tableam,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
@@ -1099,6 +1101,7 @@ ArchiveEntry(Archive *AHX,
 	newToc->tag = pg_strdup(tag);
 	newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
 	newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+	newToc->tableam = tableam ? pg_strdup(tableam) : NULL;
 	newToc->owner = pg_strdup(owner);
 	newToc->desc = pg_strdup(desc);
 	newToc->defn = pg_strdup(defn);
@@ -2367,6 +2370,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt,
 	AH->currUser = NULL;		/* unknown */
 	AH->currSchema = NULL;		/* ditto */
 	AH->currTablespace = NULL;	/* ditto */
+	AH->currTableAm = NULL;	/* ditto */
 
 	AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
@@ -2594,6 +2598,7 @@ WriteToc(ArchiveHandle *AH)
 		WriteStr(AH, te->namespace);
 		WriteStr(AH, te->tablespace);
 		WriteStr(AH, te->owner);
+		WriteStr(AH, te->tableam);
 		WriteStr(AH, "false");
 
 		/* Dump list of dependencies */
@@ -2696,6 +2701,7 @@ ReadToc(ArchiveHandle *AH)
 			te->tablespace = ReadStr(AH);
 
 		te->owner = ReadStr(AH);
+		te->tableam = ReadStr(AH);
 		if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
 			write_msg(modulename,
 					  "WARNING: restoring tables WITH OIDS is not supported anymore");
@@ -3288,6 +3294,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 
 	/* re-establish fixed state */
 	_doSetFixedOutputState(AH);
@@ -3448,6 +3457,48 @@ _selectTablespace(ArchiveHandle *AH, const char *tablespace)
 	destroyPQExpBuffer(qry);
 }
 
+/*
+ * Set the proper default_table_access_method value for the table.
+ */
+static void
+_selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
+{
+	PQExpBuffer cmd = createPQExpBuffer();
+	const char *want, *have;
+
+	have = AH->currTableAm;
+	want = tableam;
+
+	if (!want)
+		return;
+
+	if (have && strcmp(want, have) == 0)
+		return;
+
+
+	appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
+
+	if (RestoringToDB(AH))
+	{
+		PGresult   *res;
+
+		res = PQexec(AH->connection, cmd->data);
+
+		if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
+			warn_or_exit_horribly(AH, modulename,
+								  "could not set default_table_access_method: %s",
+								  PQerrorMessage(AH->connection));
+
+		PQclear(res);
+	}
+	else
+		ahprintf(AH, "%s\n\n", cmd->data);
+
+	destroyPQExpBuffer(cmd);
+
+	AH->currTableAm = pg_strdup(want);
+}
+
 /*
  * Extract an object description for a TOC entry, and append it to buf.
  *
@@ -3547,6 +3598,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
 	_becomeOwner(AH, te);
 	_selectOutputSchema(AH, te->namespace);
 	_selectTablespace(AH, te->tablespace);
+	_selectTableAccessMethod(AH, te->tableam);
 
 	/* Emit header comment for item */
 	if (!AH->noTocComments)
@@ -4021,6 +4073,9 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 }
 
 /*
@@ -4816,6 +4871,7 @@ CloneArchive(ArchiveHandle *AH)
 	clone->currUser = NULL;
 	clone->currSchema = NULL;
 	clone->currTablespace = NULL;
+	clone->currTableAm = NULL;
 
 	/* savedPassword must be local in case we change it while connecting */
 	if (clone->savedPassword)
@@ -4906,6 +4962,8 @@ DeCloneArchive(ArchiveHandle *AH)
 		free(AH->currSchema);
 	if (AH->currTablespace)
 		free(AH->currTablespace);
+	if (AH->currTableAm)
+		free(AH->currTableAm);
 	if (AH->savedPassword)
 		free(AH->savedPassword);
 
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 306d2ceba9..719065565b 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -347,6 +347,7 @@ struct _archiveHandle
 	char	   *currUser;		/* current username, or NULL if unknown */
 	char	   *currSchema;		/* current schema, or NULL */
 	char	   *currTablespace; /* current tablespace, or NULL */
+	char	   *currTableAm; 	/* current table access method, or NULL */
 
 	void	   *lo_buf;
 	size_t		lo_buf_used;
@@ -373,6 +374,8 @@ struct _tocEntry
 	char	   *namespace;		/* null or empty string if not in a schema */
 	char	   *tablespace;		/* null if not in a tablespace; empty string
 								 * means use database default */
+	char	   *tableam;			/* table access method, onlyt for TABLE tags */
+
 	char	   *owner;
 	char	   *desc;
 	char	   *defn;
@@ -410,7 +413,7 @@ extern TocEntry *ArchiveEntry(Archive *AHX,
 			 CatalogId catalogId, DumpId dumpId,
 			 const char *tag,
 			 const char *namespace, const char *tablespace,
-			 const char *owner,
+			 const char *owner, const char *amname,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..512c486546 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2136,7 +2136,7 @@ dumpTableData(Archive *fout, TableDataInfo *tdinfo)
 
 		te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
 						  tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
-						  NULL, tbinfo->rolname,
+						  NULL, tbinfo->rolname, NULL,
 						  "TABLE DATA", SECTION_DATA,
 						  "", "", copyStmt,
 						  &(tbinfo->dobj.dumpId), 1,
@@ -2188,6 +2188,7 @@ refreshMatViewData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name, /* Namespace */
 					 NULL,		/* Tablespace */
 					 tbinfo->rolname,	/* Owner */
+					 NULL,				/* Table access method */
 					 "MATERIALIZED VIEW DATA",	/* Desc */
 					 SECTION_POST_DATA, /* Section */
 					 q->data,	/* Create */
@@ -2726,6 +2727,7 @@ dumpDatabase(Archive *fout)
 				 NULL,			/* Namespace */
 				 NULL,			/* Tablespace */
 				 dba,			/* Owner */
+				 NULL,			/* Table access method */
 				 "DATABASE",	/* Desc */
 				 SECTION_PRE_DATA,	/* Section */
 				 creaQry->data, /* Create */
@@ -2762,7 +2764,7 @@ dumpDatabase(Archive *fout)
 			appendPQExpBufferStr(dbQry, ";\n");
 
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "COMMENT", SECTION_NONE,
 						 dbQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2789,7 +2791,7 @@ dumpDatabase(Archive *fout)
 		emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
 		if (seclabelQry->len > 0)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "SECURITY LABEL", SECTION_NONE,
 						 seclabelQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2859,7 +2861,7 @@ dumpDatabase(Archive *fout)
 
 	if (creaQry->len > 0)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 datname, NULL, NULL, dba,
+					 datname, NULL, NULL, dba, NULL,
 					 "DATABASE PROPERTIES", SECTION_PRE_DATA,
 					 creaQry->data, delQry->data, NULL,
 					 &(dbDumpId), 1,
@@ -2904,7 +2906,7 @@ dumpDatabase(Archive *fout)
 						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
 						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 "pg_largeobject", NULL, NULL, "",
+					 "pg_largeobject", NULL, NULL, "", NULL,
 					 "pg_largeobject", SECTION_PRE_DATA,
 					 loOutQry->data, "", NULL,
 					 NULL, 0,
@@ -3014,7 +3016,7 @@ dumpEncoding(Archive *AH)
 	appendPQExpBufferStr(qry, ";\n");
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "ENCODING", NULL, NULL, "",
+				 "ENCODING", NULL, NULL, "", NULL,
 				 "ENCODING", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3041,7 +3043,7 @@ dumpStdStrings(Archive *AH)
 					  stdstrings);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "STDSTRINGS", NULL, NULL, "",
+				 "STDSTRINGS", NULL, NULL, "", NULL,
 				 "STDSTRINGS", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3097,7 +3099,7 @@ dumpSearchPath(Archive *AH)
 		write_msg(NULL, "saving search_path = %s\n", path->data);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "SEARCHPATH", NULL, NULL, "",
+				 "SEARCHPATH", NULL, NULL, "", NULL,
 				 "SEARCHPATH", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3275,7 +3277,7 @@ dumpBlob(Archive *fout, BlobInfo *binfo)
 		ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
 					 binfo->dobj.name,
 					 NULL, NULL,
-					 binfo->rolname,
+					 binfo->rolname, NULL,
 					 "BLOB", SECTION_PRE_DATA,
 					 cquery->data, dquery->data, NULL,
 					 NULL, 0,
@@ -3581,6 +3583,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 						 polinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "ROW SECURITY", SECTION_POST_DATA,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -3637,6 +3640,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 					 polinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "POLICY", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -3811,6 +3815,7 @@ dumpPublication(Archive *fout, PublicationInfo *pubinfo)
 				 NULL,
 				 NULL,
 				 pubinfo->rolname,
+				 NULL,
 				 "PUBLICATION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -3954,6 +3959,7 @@ dumpPublicationTable(Archive *fout, PublicationRelInfo *pubrinfo)
 				 tbinfo->dobj.namespace->dobj.name,
 				 NULL,
 				 "",
+				 NULL,
 				 "PUBLICATION TABLE", SECTION_POST_DATA,
 				 query->data, "", NULL,
 				 NULL, 0,
@@ -4147,6 +4153,7 @@ dumpSubscription(Archive *fout, SubscriptionInfo *subinfo)
 				 NULL,
 				 NULL,
 				 subinfo->rolname,
+				 NULL,
 				 "SUBSCRIPTION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -5829,6 +5836,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5922,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5953,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6421,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6491,11 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
+
 
 		/* other fields were zeroed above */
 
@@ -9355,7 +9370,7 @@ dumpComment(Archive *fout, const char *type, const char *name,
 		 * post-data.
 		 */
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "COMMENT", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -9423,7 +9438,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9447,7 +9462,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9728,7 +9743,7 @@ dumpDumpableObject(Archive *fout, DumpableObject *dobj)
 				TocEntry   *te;
 
 				te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
-								  dobj->name, NULL, NULL, "",
+								  dobj->name, NULL, NULL, "", NULL,
 								  "BLOBS", SECTION_DATA,
 								  "", "", NULL,
 								  NULL, 0,
@@ -9802,7 +9817,7 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
 		ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
 					 nspinfo->dobj.name,
 					 NULL, NULL,
-					 nspinfo->rolname,
+					 nspinfo->rolname, NULL,
 					 "SCHEMA", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -9938,7 +9953,7 @@ dumpExtension(Archive *fout, ExtensionInfo *extinfo)
 		ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
 					 extinfo->dobj.name,
 					 NULL, NULL,
-					 "",
+					 "", NULL,
 					 "EXTENSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10090,6 +10105,7 @@ dumpEnumType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10217,6 +10233,7 @@ dumpRangeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10290,6 +10307,7 @@ dumpUndefinedType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10572,6 +10590,7 @@ dumpBaseType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10729,6 +10748,7 @@ dumpDomain(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "DOMAIN", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10951,6 +10971,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -11085,7 +11106,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 target->data,
 						 tyinfo->dobj.namespace->dobj.name,
-						 NULL, tyinfo->rolname,
+						 NULL, tyinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tyinfo->dobj.dumpId), 1,
@@ -11142,6 +11163,7 @@ dumpShellType(Archive *fout, ShellTypeInfo *stinfo)
 					 stinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 stinfo->baseType->rolname,
+					 NULL,
 					 "SHELL TYPE", SECTION_PRE_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -11251,7 +11273,7 @@ dumpProcLang(Archive *fout, ProcLangInfo *plang)
 	if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
 					 plang->dobj.name,
-					 NULL, NULL, plang->lanowner,
+					 NULL, NULL, plang->lanowner, NULL,
 					 "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -11924,6 +11946,7 @@ dumpFunc(Archive *fout, FuncInfo *finfo)
 					 finfo->dobj.namespace->dobj.name,
 					 NULL,
 					 finfo->rolname,
+					 NULL,
 					 keyword, SECTION_PRE_DATA,
 					 q->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12056,7 +12079,7 @@ dumpCast(Archive *fout, CastInfo *cast)
 	if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "CAST", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12184,7 +12207,7 @@ dumpTransform(Archive *fout, TransformInfo *transform)
 	if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "TRANSFORM", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 transform->dobj.dependencies, transform->dobj.nDeps,
@@ -12400,6 +12423,7 @@ dumpOpr(Archive *fout, OprInfo *oprinfo)
 					 oprinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 oprinfo->rolname,
+					 NULL,
 					 "OPERATOR", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12546,6 +12570,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -12570,6 +12597,7 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 					 NULL,
 					 NULL,
 					 "",
+					 NULL,
 					 "ACCESS METHOD", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12936,6 +12964,7 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo)
 					 opcinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opcinfo->rolname,
+					 NULL,
 					 "OPERATOR CLASS", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13203,6 +13232,7 @@ dumpOpfamily(Archive *fout, OpfamilyInfo *opfinfo)
 					 opfinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opfinfo->rolname,
+					 NULL,
 					 "OPERATOR FAMILY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13346,6 +13376,7 @@ dumpCollation(Archive *fout, CollInfo *collinfo)
 					 collinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 collinfo->rolname,
+					 NULL,
 					 "COLLATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13441,6 +13472,7 @@ dumpConversion(Archive *fout, ConvInfo *convinfo)
 					 convinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 convinfo->rolname,
+					 NULL,
 					 "CONVERSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13930,6 +13962,7 @@ dumpAgg(Archive *fout, AggInfo *agginfo)
 					 agginfo->aggfn.dobj.namespace->dobj.name,
 					 NULL,
 					 agginfo->aggfn.rolname,
+					 NULL,
 					 "AGGREGATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14028,6 +14061,7 @@ dumpTSParser(Archive *fout, TSParserInfo *prsinfo)
 					 prsinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH PARSER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14108,6 +14142,7 @@ dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo)
 					 dictinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 dictinfo->rolname,
+					 NULL,
 					 "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14169,6 +14204,7 @@ dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo)
 					 tmplinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14289,6 +14325,7 @@ dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo)
 					 cfginfo->dobj.namespace->dobj.name,
 					 NULL,
 					 cfginfo->rolname,
+					 NULL,
 					 "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14355,6 +14392,7 @@ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
 					 NULL,
 					 NULL,
 					 fdwinfo->rolname,
+					 NULL,
 					 "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14446,6 +14484,7 @@ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
 					 NULL,
 					 NULL,
 					 srvinfo->rolname,
+					 NULL,
 					 "SERVER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14564,6 +14603,7 @@ dumpUserMappings(Archive *fout,
 					 namespace,
 					 NULL,
 					 owner,
+					 NULL,
 					 "USER MAPPING", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 &dumpId, 1,
@@ -14643,6 +14683,7 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo)
 					 daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
 					 NULL,
 					 daclinfo->defaclrole,
+					 NULL,
 					 "DEFAULT ACL", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -14741,6 +14782,7 @@ dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
 					 tag->data, nspname,
 					 NULL,
 					 owner ? owner : "",
+					 NULL,
 					 "ACL", SECTION_NONE,
 					 sql->data, "", NULL,
 					 &(objDumpId), 1,
@@ -14826,7 +14868,7 @@ dumpSecLabel(Archive *fout, const char *type, const char *name,
 
 		appendPQExpBuffer(tag, "%s %s", type, name);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -14908,7 +14950,7 @@ dumpTableSecLabel(Archive *fout, TableInfo *tbinfo, const char *reltypename)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 target->data,
 					 tbinfo->dobj.namespace->dobj.name,
-					 NULL, tbinfo->rolname,
+					 NULL, tbinfo->rolname, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -15994,6 +16036,8 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
 					 tbinfo->rolname,
+					 (tbinfo->relkind == RELKIND_RELATION) ?
+					 tbinfo->amname : NULL,
 					 reltypename,
 					 tbinfo->postponed_def ?
 					 SECTION_POST_DATA : SECTION_PRE_DATA,
@@ -16074,6 +16118,7 @@ dumpAttrDef(Archive *fout, AttrDefInfo *adinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "DEFAULT", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16190,6 +16235,7 @@ dumpIndex(Archive *fout, IndxInfo *indxinfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "INDEX", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16234,6 +16280,7 @@ dumpIndexAttach(Archive *fout, IndexAttachInfo *attachinfo)
 					 attachinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "INDEX ATTACH", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -16289,6 +16336,7 @@ dumpStatisticsExt(Archive *fout, StatsExtInfo *statsextinfo)
 					 statsextinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 statsextinfo->rolname,
+					 NULL,
 					 "STATISTICS", SECTION_POST_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16450,6 +16498,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16490,6 +16539,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "FK CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16522,6 +16572,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16555,6 +16606,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tyinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tyinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16829,6 +16881,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE", SECTION_PRE_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -16870,6 +16923,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "SEQUENCE OWNED BY", SECTION_PRE_DATA,
 							 query->data, "", NULL,
 							 &(tbinfo->dobj.dumpId), 1,
@@ -16938,6 +16992,7 @@ dumpSequenceData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE SET", SECTION_DATA,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -17137,6 +17192,7 @@ dumpTrigger(Archive *fout, TriggerInfo *tginfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17223,7 +17279,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo)
 	if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
 					 evtinfo->dobj.name, NULL, NULL,
-					 evtinfo->evtowner,
+					 evtinfo->evtowner, NULL,
 					 "EVENT TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17384,6 +17440,7 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "RULE", SECTION_POST_DATA,
 					 cmd->data, delcmd->data, NULL,
 					 NULL, 0,
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4024d0c1e3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname; 		/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index 58bd3805f4..aadeacf95d 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -85,6 +85,7 @@ static void _becomeUser(ArchiveHandle *AH, const char *user);
 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
+static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tablespace);
 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
@@ -1072,6 +1073,7 @@ ArchiveEntry(Archive *AHX,
 			 const char *namespace,
 			 const char *tablespace,
 			 const char *owner,
+			 const char *tableam,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
@@ -1099,6 +1101,7 @@ ArchiveEntry(Archive *AHX,
 	newToc->tag = pg_strdup(tag);
 	newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
 	newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+	newToc->tableam = tableam ? pg_strdup(tableam) : NULL;
 	newToc->owner = pg_strdup(owner);
 	newToc->desc = pg_strdup(desc);
 	newToc->defn = pg_strdup(defn);
@@ -2367,6 +2370,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt,
 	AH->currUser = NULL;		/* unknown */
 	AH->currSchema = NULL;		/* ditto */
 	AH->currTablespace = NULL;	/* ditto */
+	AH->currTableAm = NULL;	/* ditto */
 
 	AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
@@ -2594,6 +2598,7 @@ WriteToc(ArchiveHandle *AH)
 		WriteStr(AH, te->namespace);
 		WriteStr(AH, te->tablespace);
 		WriteStr(AH, te->owner);
+		WriteStr(AH, te->tableam);
 		WriteStr(AH, "false");
 
 		/* Dump list of dependencies */
@@ -2696,6 +2701,9 @@ ReadToc(ArchiveHandle *AH)
 			te->tablespace = ReadStr(AH);
 
 		te->owner = ReadStr(AH);
+		if (AH->version >= K_VERS_1_14)
+			te->tableam = ReadStr(AH);
+
 		if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
 			write_msg(modulename,
 					  "WARNING: restoring tables WITH OIDS is not supported anymore");
@@ -3288,6 +3296,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 
 	/* re-establish fixed state */
 	_doSetFixedOutputState(AH);
@@ -3448,6 +3459,48 @@ _selectTablespace(ArchiveHandle *AH, const char *tablespace)
 	destroyPQExpBuffer(qry);
 }
 
+/*
+ * Set the proper default_table_access_method value for the table.
+ */
+static void
+_selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
+{
+	PQExpBuffer cmd;
+	const char *want, *have;
+
+	have = AH->currTableAm;
+	want = tableam;
+
+	if (!want)
+		return;
+
+	if (have && strcmp(want, have) == 0)
+		return;
+
+	cmd = createPQExpBuffer();
+	appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
+
+	if (RestoringToDB(AH))
+	{
+		PGresult   *res;
+
+		res = PQexec(AH->connection, cmd->data);
+
+		if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
+			warn_or_exit_horribly(AH, modulename,
+								  "could not set default_table_access_method: %s",
+								  PQerrorMessage(AH->connection));
+
+		PQclear(res);
+	}
+	else
+		ahprintf(AH, "%s\n\n", cmd->data);
+
+	destroyPQExpBuffer(cmd);
+
+	AH->currTableAm = pg_strdup(want);
+}
+
 /*
  * Extract an object description for a TOC entry, and append it to buf.
  *
@@ -3547,6 +3600,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
 	_becomeOwner(AH, te);
 	_selectOutputSchema(AH, te->namespace);
 	_selectTablespace(AH, te->tablespace);
+	_selectTableAccessMethod(AH, te->tableam);
 
 	/* Emit header comment for item */
 	if (!AH->noTocComments)
@@ -4021,6 +4075,9 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 }
 
 /*
@@ -4816,6 +4873,7 @@ CloneArchive(ArchiveHandle *AH)
 	clone->currUser = NULL;
 	clone->currSchema = NULL;
 	clone->currTablespace = NULL;
+	clone->currTableAm = NULL;
 
 	/* savedPassword must be local in case we change it while connecting */
 	if (clone->savedPassword)
@@ -4906,6 +4964,8 @@ DeCloneArchive(ArchiveHandle *AH)
 		free(AH->currSchema);
 	if (AH->currTablespace)
 		free(AH->currTablespace);
+	if (AH->currTableAm)
+		free(AH->currTableAm);
 	if (AH->savedPassword)
 		free(AH->savedPassword);
 
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 306d2ceba9..8131ff0a3d 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -94,6 +94,7 @@ typedef z_stream *z_streamp;
 													 * entries */
 #define K_VERS_1_13 MAKE_ARCHIVE_VERSION(1, 13, 0)	/* change search_path
 													 * behavior */
+#define K_VERS_1_14 MAKE_ARCHIVE_VERSION(1, 14, 0)	/* add tableam */
 
 /* Current archive version number (the format we can output) */
 #define K_VERS_MAJOR 1
@@ -347,6 +348,7 @@ struct _archiveHandle
 	char	   *currUser;		/* current username, or NULL if unknown */
 	char	   *currSchema;		/* current schema, or NULL */
 	char	   *currTablespace; /* current tablespace, or NULL */
+	char	   *currTableAm; 	/* current table access method, or NULL */
 
 	void	   *lo_buf;
 	size_t		lo_buf_used;
@@ -373,6 +375,8 @@ struct _tocEntry
 	char	   *namespace;		/* null or empty string if not in a schema */
 	char	   *tablespace;		/* null if not in a tablespace; empty string
 								 * means use database default */
+	char	   *tableam;		/* table access method, only for TABLE tags */
+
 	char	   *owner;
 	char	   *desc;
 	char	   *defn;
@@ -410,7 +414,7 @@ extern TocEntry *ArchiveEntry(Archive *AHX,
 			 CatalogId catalogId, DumpId dumpId,
 			 const char *tag,
 			 const char *namespace, const char *tablespace,
-			 const char *owner,
+			 const char *owner, const char *amname,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..512c486546 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2136,7 +2136,7 @@ dumpTableData(Archive *fout, TableDataInfo *tdinfo)
 
 		te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
 						  tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
-						  NULL, tbinfo->rolname,
+						  NULL, tbinfo->rolname, NULL,
 						  "TABLE DATA", SECTION_DATA,
 						  "", "", copyStmt,
 						  &(tbinfo->dobj.dumpId), 1,
@@ -2188,6 +2188,7 @@ refreshMatViewData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name, /* Namespace */
 					 NULL,		/* Tablespace */
 					 tbinfo->rolname,	/* Owner */
+					 NULL,				/* Table access method */
 					 "MATERIALIZED VIEW DATA",	/* Desc */
 					 SECTION_POST_DATA, /* Section */
 					 q->data,	/* Create */
@@ -2726,6 +2727,7 @@ dumpDatabase(Archive *fout)
 				 NULL,			/* Namespace */
 				 NULL,			/* Tablespace */
 				 dba,			/* Owner */
+				 NULL,			/* Table access method */
 				 "DATABASE",	/* Desc */
 				 SECTION_PRE_DATA,	/* Section */
 				 creaQry->data, /* Create */
@@ -2762,7 +2764,7 @@ dumpDatabase(Archive *fout)
 			appendPQExpBufferStr(dbQry, ";\n");
 
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "COMMENT", SECTION_NONE,
 						 dbQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2789,7 +2791,7 @@ dumpDatabase(Archive *fout)
 		emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
 		if (seclabelQry->len > 0)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "SECURITY LABEL", SECTION_NONE,
 						 seclabelQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2859,7 +2861,7 @@ dumpDatabase(Archive *fout)
 
 	if (creaQry->len > 0)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 datname, NULL, NULL, dba,
+					 datname, NULL, NULL, dba, NULL,
 					 "DATABASE PROPERTIES", SECTION_PRE_DATA,
 					 creaQry->data, delQry->data, NULL,
 					 &(dbDumpId), 1,
@@ -2904,7 +2906,7 @@ dumpDatabase(Archive *fout)
 						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
 						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 "pg_largeobject", NULL, NULL, "",
+					 "pg_largeobject", NULL, NULL, "", NULL,
 					 "pg_largeobject", SECTION_PRE_DATA,
 					 loOutQry->data, "", NULL,
 					 NULL, 0,
@@ -3014,7 +3016,7 @@ dumpEncoding(Archive *AH)
 	appendPQExpBufferStr(qry, ";\n");
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "ENCODING", NULL, NULL, "",
+				 "ENCODING", NULL, NULL, "", NULL,
 				 "ENCODING", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3041,7 +3043,7 @@ dumpStdStrings(Archive *AH)
 					  stdstrings);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "STDSTRINGS", NULL, NULL, "",
+				 "STDSTRINGS", NULL, NULL, "", NULL,
 				 "STDSTRINGS", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3097,7 +3099,7 @@ dumpSearchPath(Archive *AH)
 		write_msg(NULL, "saving search_path = %s\n", path->data);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "SEARCHPATH", NULL, NULL, "",
+				 "SEARCHPATH", NULL, NULL, "", NULL,
 				 "SEARCHPATH", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3275,7 +3277,7 @@ dumpBlob(Archive *fout, BlobInfo *binfo)
 		ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
 					 binfo->dobj.name,
 					 NULL, NULL,
-					 binfo->rolname,
+					 binfo->rolname, NULL,
 					 "BLOB", SECTION_PRE_DATA,
 					 cquery->data, dquery->data, NULL,
 					 NULL, 0,
@@ -3581,6 +3583,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 						 polinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "ROW SECURITY", SECTION_POST_DATA,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -3637,6 +3640,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 					 polinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "POLICY", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -3811,6 +3815,7 @@ dumpPublication(Archive *fout, PublicationInfo *pubinfo)
 				 NULL,
 				 NULL,
 				 pubinfo->rolname,
+				 NULL,
 				 "PUBLICATION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -3954,6 +3959,7 @@ dumpPublicationTable(Archive *fout, PublicationRelInfo *pubrinfo)
 				 tbinfo->dobj.namespace->dobj.name,
 				 NULL,
 				 "",
+				 NULL,
 				 "PUBLICATION TABLE", SECTION_POST_DATA,
 				 query->data, "", NULL,
 				 NULL, 0,
@@ -4147,6 +4153,7 @@ dumpSubscription(Archive *fout, SubscriptionInfo *subinfo)
 				 NULL,
 				 NULL,
 				 subinfo->rolname,
+				 NULL,
 				 "SUBSCRIPTION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -5829,6 +5836,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5922,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5953,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6421,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6491,11 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
+
 
 		/* other fields were zeroed above */
 
@@ -9355,7 +9370,7 @@ dumpComment(Archive *fout, const char *type, const char *name,
 		 * post-data.
 		 */
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "COMMENT", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -9423,7 +9438,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9447,7 +9462,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9728,7 +9743,7 @@ dumpDumpableObject(Archive *fout, DumpableObject *dobj)
 				TocEntry   *te;
 
 				te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
-								  dobj->name, NULL, NULL, "",
+								  dobj->name, NULL, NULL, "", NULL,
 								  "BLOBS", SECTION_DATA,
 								  "", "", NULL,
 								  NULL, 0,
@@ -9802,7 +9817,7 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
 		ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
 					 nspinfo->dobj.name,
 					 NULL, NULL,
-					 nspinfo->rolname,
+					 nspinfo->rolname, NULL,
 					 "SCHEMA", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -9938,7 +9953,7 @@ dumpExtension(Archive *fout, ExtensionInfo *extinfo)
 		ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
 					 extinfo->dobj.name,
 					 NULL, NULL,
-					 "",
+					 "", NULL,
 					 "EXTENSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10090,6 +10105,7 @@ dumpEnumType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10217,6 +10233,7 @@ dumpRangeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10290,6 +10307,7 @@ dumpUndefinedType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10572,6 +10590,7 @@ dumpBaseType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10729,6 +10748,7 @@ dumpDomain(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "DOMAIN", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10951,6 +10971,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -11085,7 +11106,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 target->data,
 						 tyinfo->dobj.namespace->dobj.name,
-						 NULL, tyinfo->rolname,
+						 NULL, tyinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tyinfo->dobj.dumpId), 1,
@@ -11142,6 +11163,7 @@ dumpShellType(Archive *fout, ShellTypeInfo *stinfo)
 					 stinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 stinfo->baseType->rolname,
+					 NULL,
 					 "SHELL TYPE", SECTION_PRE_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -11251,7 +11273,7 @@ dumpProcLang(Archive *fout, ProcLangInfo *plang)
 	if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
 					 plang->dobj.name,
-					 NULL, NULL, plang->lanowner,
+					 NULL, NULL, plang->lanowner, NULL,
 					 "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -11924,6 +11946,7 @@ dumpFunc(Archive *fout, FuncInfo *finfo)
 					 finfo->dobj.namespace->dobj.name,
 					 NULL,
 					 finfo->rolname,
+					 NULL,
 					 keyword, SECTION_PRE_DATA,
 					 q->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12056,7 +12079,7 @@ dumpCast(Archive *fout, CastInfo *cast)
 	if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "CAST", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12184,7 +12207,7 @@ dumpTransform(Archive *fout, TransformInfo *transform)
 	if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "TRANSFORM", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 transform->dobj.dependencies, transform->dobj.nDeps,
@@ -12400,6 +12423,7 @@ dumpOpr(Archive *fout, OprInfo *oprinfo)
 					 oprinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 oprinfo->rolname,
+					 NULL,
 					 "OPERATOR", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12546,6 +12570,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -12570,6 +12597,7 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 					 NULL,
 					 NULL,
 					 "",
+					 NULL,
 					 "ACCESS METHOD", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12936,6 +12964,7 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo)
 					 opcinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opcinfo->rolname,
+					 NULL,
 					 "OPERATOR CLASS", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13203,6 +13232,7 @@ dumpOpfamily(Archive *fout, OpfamilyInfo *opfinfo)
 					 opfinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opfinfo->rolname,
+					 NULL,
 					 "OPERATOR FAMILY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13346,6 +13376,7 @@ dumpCollation(Archive *fout, CollInfo *collinfo)
 					 collinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 collinfo->rolname,
+					 NULL,
 					 "COLLATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13441,6 +13472,7 @@ dumpConversion(Archive *fout, ConvInfo *convinfo)
 					 convinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 convinfo->rolname,
+					 NULL,
 					 "CONVERSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13930,6 +13962,7 @@ dumpAgg(Archive *fout, AggInfo *agginfo)
 					 agginfo->aggfn.dobj.namespace->dobj.name,
 					 NULL,
 					 agginfo->aggfn.rolname,
+					 NULL,
 					 "AGGREGATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14028,6 +14061,7 @@ dumpTSParser(Archive *fout, TSParserInfo *prsinfo)
 					 prsinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH PARSER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14108,6 +14142,7 @@ dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo)
 					 dictinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 dictinfo->rolname,
+					 NULL,
 					 "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14169,6 +14204,7 @@ dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo)
 					 tmplinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14289,6 +14325,7 @@ dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo)
 					 cfginfo->dobj.namespace->dobj.name,
 					 NULL,
 					 cfginfo->rolname,
+					 NULL,
 					 "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14355,6 +14392,7 @@ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
 					 NULL,
 					 NULL,
 					 fdwinfo->rolname,
+					 NULL,
 					 "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14446,6 +14484,7 @@ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
 					 NULL,
 					 NULL,
 					 srvinfo->rolname,
+					 NULL,
 					 "SERVER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14564,6 +14603,7 @@ dumpUserMappings(Archive *fout,
 					 namespace,
 					 NULL,
 					 owner,
+					 NULL,
 					 "USER MAPPING", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 &dumpId, 1,
@@ -14643,6 +14683,7 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo)
 					 daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
 					 NULL,
 					 daclinfo->defaclrole,
+					 NULL,
 					 "DEFAULT ACL", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -14741,6 +14782,7 @@ dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
 					 tag->data, nspname,
 					 NULL,
 					 owner ? owner : "",
+					 NULL,
 					 "ACL", SECTION_NONE,
 					 sql->data, "", NULL,
 					 &(objDumpId), 1,
@@ -14826,7 +14868,7 @@ dumpSecLabel(Archive *fout, const char *type, const char *name,
 
 		appendPQExpBuffer(tag, "%s %s", type, name);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -14908,7 +14950,7 @@ dumpTableSecLabel(Archive *fout, TableInfo *tbinfo, const char *reltypename)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 target->data,
 					 tbinfo->dobj.namespace->dobj.name,
-					 NULL, tbinfo->rolname,
+					 NULL, tbinfo->rolname, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -15994,6 +16036,8 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
 					 tbinfo->rolname,
+					 (tbinfo->relkind == RELKIND_RELATION) ?
+					 tbinfo->amname : NULL,
 					 reltypename,
 					 tbinfo->postponed_def ?
 					 SECTION_POST_DATA : SECTION_PRE_DATA,
@@ -16074,6 +16118,7 @@ dumpAttrDef(Archive *fout, AttrDefInfo *adinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "DEFAULT", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16190,6 +16235,7 @@ dumpIndex(Archive *fout, IndxInfo *indxinfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "INDEX", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16234,6 +16280,7 @@ dumpIndexAttach(Archive *fout, IndexAttachInfo *attachinfo)
 					 attachinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "INDEX ATTACH", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -16289,6 +16336,7 @@ dumpStatisticsExt(Archive *fout, StatsExtInfo *statsextinfo)
 					 statsextinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 statsextinfo->rolname,
+					 NULL,
 					 "STATISTICS", SECTION_POST_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16450,6 +16498,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16490,6 +16539,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "FK CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16522,6 +16572,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16555,6 +16606,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tyinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tyinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16829,6 +16881,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE", SECTION_PRE_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -16870,6 +16923,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "SEQUENCE OWNED BY", SECTION_PRE_DATA,
 							 query->data, "", NULL,
 							 &(tbinfo->dobj.dumpId), 1,
@@ -16938,6 +16992,7 @@ dumpSequenceData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE SET", SECTION_DATA,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -17137,6 +17192,7 @@ dumpTrigger(Archive *fout, TriggerInfo *tginfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17223,7 +17279,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo)
 	if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
 					 evtinfo->dobj.name, NULL, NULL,
-					 evtinfo->evtowner,
+					 evtinfo->evtowner, NULL,
 					 "EVENT TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17384,6 +17440,7 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "RULE", SECTION_POST_DATA,
 					 cmd->data, delcmd->data, NULL,
 					 NULL, 0,
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4024d0c1e3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname; 		/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index 58bd3805f4..38f24ba1bf 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -85,6 +85,7 @@ static void _becomeUser(ArchiveHandle *AH, const char *user);
 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
+static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam);
 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
@@ -1072,6 +1073,7 @@ ArchiveEntry(Archive *AHX,
 			 const char *namespace,
 			 const char *tablespace,
 			 const char *owner,
+			 const char *tableam,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
@@ -1099,6 +1101,7 @@ ArchiveEntry(Archive *AHX,
 	newToc->tag = pg_strdup(tag);
 	newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
 	newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+	newToc->tableam = tableam ? pg_strdup(tableam) : NULL;
 	newToc->owner = pg_strdup(owner);
 	newToc->desc = pg_strdup(desc);
 	newToc->defn = pg_strdup(defn);
@@ -2367,6 +2370,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt,
 	AH->currUser = NULL;		/* unknown */
 	AH->currSchema = NULL;		/* ditto */
 	AH->currTablespace = NULL;	/* ditto */
+	AH->currTableAm = NULL;	/* ditto */
 
 	AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
@@ -2594,6 +2598,7 @@ WriteToc(ArchiveHandle *AH)
 		WriteStr(AH, te->namespace);
 		WriteStr(AH, te->tablespace);
 		WriteStr(AH, te->owner);
+		WriteStr(AH, te->tableam);
 		WriteStr(AH, "false");
 
 		/* Dump list of dependencies */
@@ -2696,6 +2701,9 @@ ReadToc(ArchiveHandle *AH)
 			te->tablespace = ReadStr(AH);
 
 		te->owner = ReadStr(AH);
+		if (AH->version >= K_VERS_1_14)
+			te->tableam = ReadStr(AH);
+
 		if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
 			write_msg(modulename,
 					  "WARNING: restoring tables WITH OIDS is not supported anymore");
@@ -3288,6 +3296,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 
 	/* re-establish fixed state */
 	_doSetFixedOutputState(AH);
@@ -3448,6 +3459,48 @@ _selectTablespace(ArchiveHandle *AH, const char *tablespace)
 	destroyPQExpBuffer(qry);
 }
 
+/*
+ * Set the proper default_table_access_method value for the table.
+ */
+static void
+_selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
+{
+	PQExpBuffer cmd;
+	const char *want, *have;
+
+	have = AH->currTableAm;
+	want = tableam;
+
+	if (!want)
+		return;
+
+	if (have && strcmp(want, have) == 0)
+		return;
+
+	cmd = createPQExpBuffer();
+	appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
+
+	if (RestoringToDB(AH))
+	{
+		PGresult   *res;
+
+		res = PQexec(AH->connection, cmd->data);
+
+		if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
+			warn_or_exit_horribly(AH, modulename,
+								  "could not set default_table_access_method: %s",
+								  PQerrorMessage(AH->connection));
+
+		PQclear(res);
+	}
+	else
+		ahprintf(AH, "%s\n\n", cmd->data);
+
+	destroyPQExpBuffer(cmd);
+
+	AH->currTableAm = pg_strdup(want);
+}
+
 /*
  * Extract an object description for a TOC entry, and append it to buf.
  *
@@ -3547,6 +3600,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
 	_becomeOwner(AH, te);
 	_selectOutputSchema(AH, te->namespace);
 	_selectTablespace(AH, te->tablespace);
+	_selectTableAccessMethod(AH, te->tableam);
 
 	/* Emit header comment for item */
 	if (!AH->noTocComments)
@@ -4021,6 +4075,9 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 }
 
 /*
@@ -4816,6 +4873,7 @@ CloneArchive(ArchiveHandle *AH)
 	clone->currUser = NULL;
 	clone->currSchema = NULL;
 	clone->currTablespace = NULL;
+	clone->currTableAm = NULL;
 
 	/* savedPassword must be local in case we change it while connecting */
 	if (clone->savedPassword)
@@ -4906,6 +4964,8 @@ DeCloneArchive(ArchiveHandle *AH)
 		free(AH->currSchema);
 	if (AH->currTablespace)
 		free(AH->currTablespace);
+	if (AH->currTableAm)
+		free(AH->currTableAm);
 	if (AH->savedPassword)
 		free(AH->savedPassword);
 
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 306d2ceba9..c719fca0ad 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -94,10 +94,11 @@ typedef z_stream *z_streamp;
 													 * entries */
 #define K_VERS_1_13 MAKE_ARCHIVE_VERSION(1, 13, 0)	/* change search_path
 													 * behavior */
+#define K_VERS_1_14 MAKE_ARCHIVE_VERSION(1, 14, 0)	/* add tableam */
 
 /* Current archive version number (the format we can output) */
 #define K_VERS_MAJOR 1
-#define K_VERS_MINOR 13
+#define K_VERS_MINOR 14
 #define K_VERS_REV 0
 #define K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV);
 
@@ -347,6 +348,7 @@ struct _archiveHandle
 	char	   *currUser;		/* current username, or NULL if unknown */
 	char	   *currSchema;		/* current schema, or NULL */
 	char	   *currTablespace; /* current tablespace, or NULL */
+	char	   *currTableAm; 	/* current table access method, or NULL */
 
 	void	   *lo_buf;
 	size_t		lo_buf_used;
@@ -373,6 +375,8 @@ struct _tocEntry
 	char	   *namespace;		/* null or empty string if not in a schema */
 	char	   *tablespace;		/* null if not in a tablespace; empty string
 								 * means use database default */
+	char	   *tableam;		/* table access method, only for TABLE tags */
+
 	char	   *owner;
 	char	   *desc;
 	char	   *defn;
@@ -410,7 +414,7 @@ extern TocEntry *ArchiveEntry(Archive *AHX,
 			 CatalogId catalogId, DumpId dumpId,
 			 const char *tag,
 			 const char *namespace, const char *tablespace,
-			 const char *owner,
+			 const char *owner, const char *amname,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..512c486546 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2136,7 +2136,7 @@ dumpTableData(Archive *fout, TableDataInfo *tdinfo)
 
 		te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
 						  tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
-						  NULL, tbinfo->rolname,
+						  NULL, tbinfo->rolname, NULL,
 						  "TABLE DATA", SECTION_DATA,
 						  "", "", copyStmt,
 						  &(tbinfo->dobj.dumpId), 1,
@@ -2188,6 +2188,7 @@ refreshMatViewData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name, /* Namespace */
 					 NULL,		/* Tablespace */
 					 tbinfo->rolname,	/* Owner */
+					 NULL,				/* Table access method */
 					 "MATERIALIZED VIEW DATA",	/* Desc */
 					 SECTION_POST_DATA, /* Section */
 					 q->data,	/* Create */
@@ -2726,6 +2727,7 @@ dumpDatabase(Archive *fout)
 				 NULL,			/* Namespace */
 				 NULL,			/* Tablespace */
 				 dba,			/* Owner */
+				 NULL,			/* Table access method */
 				 "DATABASE",	/* Desc */
 				 SECTION_PRE_DATA,	/* Section */
 				 creaQry->data, /* Create */
@@ -2762,7 +2764,7 @@ dumpDatabase(Archive *fout)
 			appendPQExpBufferStr(dbQry, ";\n");
 
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "COMMENT", SECTION_NONE,
 						 dbQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2789,7 +2791,7 @@ dumpDatabase(Archive *fout)
 		emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
 		if (seclabelQry->len > 0)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "SECURITY LABEL", SECTION_NONE,
 						 seclabelQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2859,7 +2861,7 @@ dumpDatabase(Archive *fout)
 
 	if (creaQry->len > 0)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 datname, NULL, NULL, dba,
+					 datname, NULL, NULL, dba, NULL,
 					 "DATABASE PROPERTIES", SECTION_PRE_DATA,
 					 creaQry->data, delQry->data, NULL,
 					 &(dbDumpId), 1,
@@ -2904,7 +2906,7 @@ dumpDatabase(Archive *fout)
 						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
 						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 "pg_largeobject", NULL, NULL, "",
+					 "pg_largeobject", NULL, NULL, "", NULL,
 					 "pg_largeobject", SECTION_PRE_DATA,
 					 loOutQry->data, "", NULL,
 					 NULL, 0,
@@ -3014,7 +3016,7 @@ dumpEncoding(Archive *AH)
 	appendPQExpBufferStr(qry, ";\n");
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "ENCODING", NULL, NULL, "",
+				 "ENCODING", NULL, NULL, "", NULL,
 				 "ENCODING", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3041,7 +3043,7 @@ dumpStdStrings(Archive *AH)
 					  stdstrings);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "STDSTRINGS", NULL, NULL, "",
+				 "STDSTRINGS", NULL, NULL, "", NULL,
 				 "STDSTRINGS", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3097,7 +3099,7 @@ dumpSearchPath(Archive *AH)
 		write_msg(NULL, "saving search_path = %s\n", path->data);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "SEARCHPATH", NULL, NULL, "",
+				 "SEARCHPATH", NULL, NULL, "", NULL,
 				 "SEARCHPATH", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3275,7 +3277,7 @@ dumpBlob(Archive *fout, BlobInfo *binfo)
 		ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
 					 binfo->dobj.name,
 					 NULL, NULL,
-					 binfo->rolname,
+					 binfo->rolname, NULL,
 					 "BLOB", SECTION_PRE_DATA,
 					 cquery->data, dquery->data, NULL,
 					 NULL, 0,
@@ -3581,6 +3583,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 						 polinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "ROW SECURITY", SECTION_POST_DATA,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -3637,6 +3640,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 					 polinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "POLICY", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -3811,6 +3815,7 @@ dumpPublication(Archive *fout, PublicationInfo *pubinfo)
 				 NULL,
 				 NULL,
 				 pubinfo->rolname,
+				 NULL,
 				 "PUBLICATION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -3954,6 +3959,7 @@ dumpPublicationTable(Archive *fout, PublicationRelInfo *pubrinfo)
 				 tbinfo->dobj.namespace->dobj.name,
 				 NULL,
 				 "",
+				 NULL,
 				 "PUBLICATION TABLE", SECTION_POST_DATA,
 				 query->data, "", NULL,
 				 NULL, 0,
@@ -4147,6 +4153,7 @@ dumpSubscription(Archive *fout, SubscriptionInfo *subinfo)
 				 NULL,
 				 NULL,
 				 subinfo->rolname,
+				 NULL,
 				 "SUBSCRIPTION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -5829,6 +5836,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5922,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5953,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6421,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6491,11 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
+
 
 		/* other fields were zeroed above */
 
@@ -9355,7 +9370,7 @@ dumpComment(Archive *fout, const char *type, const char *name,
 		 * post-data.
 		 */
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "COMMENT", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -9423,7 +9438,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9447,7 +9462,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9728,7 +9743,7 @@ dumpDumpableObject(Archive *fout, DumpableObject *dobj)
 				TocEntry   *te;
 
 				te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
-								  dobj->name, NULL, NULL, "",
+								  dobj->name, NULL, NULL, "", NULL,
 								  "BLOBS", SECTION_DATA,
 								  "", "", NULL,
 								  NULL, 0,
@@ -9802,7 +9817,7 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
 		ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
 					 nspinfo->dobj.name,
 					 NULL, NULL,
-					 nspinfo->rolname,
+					 nspinfo->rolname, NULL,
 					 "SCHEMA", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -9938,7 +9953,7 @@ dumpExtension(Archive *fout, ExtensionInfo *extinfo)
 		ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
 					 extinfo->dobj.name,
 					 NULL, NULL,
-					 "",
+					 "", NULL,
 					 "EXTENSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10090,6 +10105,7 @@ dumpEnumType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10217,6 +10233,7 @@ dumpRangeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10290,6 +10307,7 @@ dumpUndefinedType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10572,6 +10590,7 @@ dumpBaseType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10729,6 +10748,7 @@ dumpDomain(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "DOMAIN", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10951,6 +10971,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -11085,7 +11106,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 target->data,
 						 tyinfo->dobj.namespace->dobj.name,
-						 NULL, tyinfo->rolname,
+						 NULL, tyinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tyinfo->dobj.dumpId), 1,
@@ -11142,6 +11163,7 @@ dumpShellType(Archive *fout, ShellTypeInfo *stinfo)
 					 stinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 stinfo->baseType->rolname,
+					 NULL,
 					 "SHELL TYPE", SECTION_PRE_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -11251,7 +11273,7 @@ dumpProcLang(Archive *fout, ProcLangInfo *plang)
 	if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
 					 plang->dobj.name,
-					 NULL, NULL, plang->lanowner,
+					 NULL, NULL, plang->lanowner, NULL,
 					 "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -11924,6 +11946,7 @@ dumpFunc(Archive *fout, FuncInfo *finfo)
 					 finfo->dobj.namespace->dobj.name,
 					 NULL,
 					 finfo->rolname,
+					 NULL,
 					 keyword, SECTION_PRE_DATA,
 					 q->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12056,7 +12079,7 @@ dumpCast(Archive *fout, CastInfo *cast)
 	if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "CAST", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12184,7 +12207,7 @@ dumpTransform(Archive *fout, TransformInfo *transform)
 	if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "TRANSFORM", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 transform->dobj.dependencies, transform->dobj.nDeps,
@@ -12400,6 +12423,7 @@ dumpOpr(Archive *fout, OprInfo *oprinfo)
 					 oprinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 oprinfo->rolname,
+					 NULL,
 					 "OPERATOR", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12546,6 +12570,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -12570,6 +12597,7 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 					 NULL,
 					 NULL,
 					 "",
+					 NULL,
 					 "ACCESS METHOD", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12936,6 +12964,7 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo)
 					 opcinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opcinfo->rolname,
+					 NULL,
 					 "OPERATOR CLASS", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13203,6 +13232,7 @@ dumpOpfamily(Archive *fout, OpfamilyInfo *opfinfo)
 					 opfinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opfinfo->rolname,
+					 NULL,
 					 "OPERATOR FAMILY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13346,6 +13376,7 @@ dumpCollation(Archive *fout, CollInfo *collinfo)
 					 collinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 collinfo->rolname,
+					 NULL,
 					 "COLLATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13441,6 +13472,7 @@ dumpConversion(Archive *fout, ConvInfo *convinfo)
 					 convinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 convinfo->rolname,
+					 NULL,
 					 "CONVERSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13930,6 +13962,7 @@ dumpAgg(Archive *fout, AggInfo *agginfo)
 					 agginfo->aggfn.dobj.namespace->dobj.name,
 					 NULL,
 					 agginfo->aggfn.rolname,
+					 NULL,
 					 "AGGREGATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14028,6 +14061,7 @@ dumpTSParser(Archive *fout, TSParserInfo *prsinfo)
 					 prsinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH PARSER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14108,6 +14142,7 @@ dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo)
 					 dictinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 dictinfo->rolname,
+					 NULL,
 					 "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14169,6 +14204,7 @@ dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo)
 					 tmplinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14289,6 +14325,7 @@ dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo)
 					 cfginfo->dobj.namespace->dobj.name,
 					 NULL,
 					 cfginfo->rolname,
+					 NULL,
 					 "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14355,6 +14392,7 @@ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
 					 NULL,
 					 NULL,
 					 fdwinfo->rolname,
+					 NULL,
 					 "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14446,6 +14484,7 @@ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
 					 NULL,
 					 NULL,
 					 srvinfo->rolname,
+					 NULL,
 					 "SERVER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14564,6 +14603,7 @@ dumpUserMappings(Archive *fout,
 					 namespace,
 					 NULL,
 					 owner,
+					 NULL,
 					 "USER MAPPING", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 &dumpId, 1,
@@ -14643,6 +14683,7 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo)
 					 daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
 					 NULL,
 					 daclinfo->defaclrole,
+					 NULL,
 					 "DEFAULT ACL", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -14741,6 +14782,7 @@ dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
 					 tag->data, nspname,
 					 NULL,
 					 owner ? owner : "",
+					 NULL,
 					 "ACL", SECTION_NONE,
 					 sql->data, "", NULL,
 					 &(objDumpId), 1,
@@ -14826,7 +14868,7 @@ dumpSecLabel(Archive *fout, const char *type, const char *name,
 
 		appendPQExpBuffer(tag, "%s %s", type, name);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -14908,7 +14950,7 @@ dumpTableSecLabel(Archive *fout, TableInfo *tbinfo, const char *reltypename)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 target->data,
 					 tbinfo->dobj.namespace->dobj.name,
-					 NULL, tbinfo->rolname,
+					 NULL, tbinfo->rolname, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -15994,6 +16036,8 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
 					 tbinfo->rolname,
+					 (tbinfo->relkind == RELKIND_RELATION) ?
+					 tbinfo->amname : NULL,
 					 reltypename,
 					 tbinfo->postponed_def ?
 					 SECTION_POST_DATA : SECTION_PRE_DATA,
@@ -16074,6 +16118,7 @@ dumpAttrDef(Archive *fout, AttrDefInfo *adinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "DEFAULT", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16190,6 +16235,7 @@ dumpIndex(Archive *fout, IndxInfo *indxinfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "INDEX", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16234,6 +16280,7 @@ dumpIndexAttach(Archive *fout, IndexAttachInfo *attachinfo)
 					 attachinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "INDEX ATTACH", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -16289,6 +16336,7 @@ dumpStatisticsExt(Archive *fout, StatsExtInfo *statsextinfo)
 					 statsextinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 statsextinfo->rolname,
+					 NULL,
 					 "STATISTICS", SECTION_POST_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16450,6 +16498,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16490,6 +16539,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "FK CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16522,6 +16572,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16555,6 +16606,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tyinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tyinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16829,6 +16881,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE", SECTION_PRE_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -16870,6 +16923,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "SEQUENCE OWNED BY", SECTION_PRE_DATA,
 							 query->data, "", NULL,
 							 &(tbinfo->dobj.dumpId), 1,
@@ -16938,6 +16992,7 @@ dumpSequenceData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE SET", SECTION_DATA,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -17137,6 +17192,7 @@ dumpTrigger(Archive *fout, TriggerInfo *tginfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17223,7 +17279,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo)
 	if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
 					 evtinfo->dobj.name, NULL, NULL,
-					 evtinfo->evtowner,
+					 evtinfo->evtowner, NULL,
 					 "EVENT TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17384,6 +17440,7 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "RULE", SECTION_POST_DATA,
 					 cmd->data, delcmd->data, NULL,
 					 NULL, 0,
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4024d0c1e3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname; 		/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.

diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 0a181b01d9..3eef06ab7d 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1484,6 +1484,8 @@ describeOneTableDetails(const char *schemaname,
 		char	   *reloftype;
 		char		relpersistence;
 		char		relreplident;
+		char	   *relam;
+		bool	    relam_is_default;
 	}			tableinfo;
 	bool		show_column_details = false;
 
@@ -1503,9 +1505,11 @@ describeOneTableDetails(const char *schemaname,
 						  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
 						  "false AS relhasoids, %s, c.reltablespace, "
 						  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
-						  "c.relpersistence, c.relreplident\n"
+						  "c.relpersistence, c.relreplident, am.amname,"
+						  "am.amname = current_setting('default_table_access_method') \n"
 						  "FROM pg_catalog.pg_class c\n "
 						  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
+						  "LEFT JOIN pg_catalog.pg_am am ON (c.relam = am.oid)\n"
 						  "WHERE c.oid = '%s';",
 						  (verbose ?
 						   "pg_catalog.array_to_string(c.reloptions || "
@@ -1656,6 +1660,17 @@ describeOneTableDetails(const char *schemaname,
 		*(PQgetvalue(res, 0, 11)) : 0;
 	tableinfo.relreplident = (pset.sversion >= 90400) ?
 		*(PQgetvalue(res, 0, 12)) : 'd';
+	if (pset.sversion >= 120000)
+	{
+		tableinfo.relam = PQgetisnull(res, 0, 13) ?
+			(char *) NULL : pg_strdup(PQgetvalue(res, 0, 13));
+		tableinfo.relam_is_default = strcmp(PQgetvalue(res, 0, 14), "t") == 0;
+	}
+	else
+	{
+		tableinfo.relam = NULL;
+		tableinfo.relam_is_default = false;
+	}
 	PQclear(res);
 	res = NULL;
 
@@ -3141,6 +3156,16 @@ describeOneTableDetails(const char *schemaname,
 		/* Tablespace info */
 		add_tablespace_footer(&cont, tableinfo.relkind, tableinfo.tablespace,
 							  true);
+
+		/* Access method info */
+		if (pset.sversion >= 120000 && verbose && tableinfo.relam != NULL &&
+		   !(pset.hide_tableam && tableinfo.relam_is_default))
+		{
+			printfPQExpBuffer(&buf, _("Access method: %s"), fmtId(tableinfo.relam));
+			printTableAddFooter(&cont, buf.data);
+		}
+
+
 	}
 
 	/* reloptions, if verbose */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 176c85afd0..0c62dfac30 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -140,6 +140,7 @@ typedef struct _psqlSettings
 	const char *prompt3;
 	PGVerbosity verbosity;		/* current error verbosity level */
 	PGContextVisibility show_context;	/* current context display level */
+	bool		hide_tableam;
 } PsqlSettings;
 
 extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index e7536a8a06..b757febcc5 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -1128,6 +1128,11 @@ show_context_hook(const char *newval)
 	return true;
 }
 
+static bool
+hide_tableam_hook(const char *newval)
+{
+	return ParseVariableBool(newval, "HIDE_TABLEAM", &pset.hide_tableam);
+}
 
 static void
 EstablishVariableSpace(void)
@@ -1191,4 +1196,7 @@ EstablishVariableSpace(void)
 	SetVariableHooks(pset.vars, "SHOW_CONTEXT",
 					 show_context_substitute_hook,
 					 show_context_hook);
+	SetVariableHooks(pset.vars, "HIDE_TABLEAM",
+					 bool_substitute_hook,
+					 hide_tableam_hook);
 }
diff --git a/src/test/regress/expected/copy2.out b/src/test/regress/expected/copy2.out
index 19bb538411..031c09422c 100644
--- a/src/test/regress/expected/copy2.out
+++ b/src/test/regress/expected/copy2.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 CREATE TEMP TABLE x (
 	a serial,
 	b int,
diff --git a/src/test/regress/expected/create_table.out b/src/test/regress/expected/create_table.out
index 7e52c27e3f..15c4474235 100644
--- a/src/test/regress/expected/create_table.out
+++ b/src/test/regress/expected/create_table.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- CREATE_TABLE
 --
diff --git a/src/test/regress/expected/create_table_like.out b/src/test/regress/expected/create_table_like.out
index b582211270..08cbeadf0c 100644
--- a/src/test/regress/expected/create_table_like.out
+++ b/src/test/regress/expected/create_table_like.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 /* Test inheritance of structure (LIKE) */
 CREATE TABLE inhx (xx text DEFAULT 'text');
 /*
diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out
index 0b5a9041b0..e2568008d9 100644
--- a/src/test/regress/expected/domain.out
+++ b/src/test/regress/expected/domain.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test domains.
 --
diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out
index 4d82d3a7e8..60a28c09fb 100644
--- a/src/test/regress/expected/foreign_data.out
+++ b/src/test/regress/expected/foreign_data.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test foreign-data wrapper and server management.
 --
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index f259d07535..5236af2744 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test inheritance features
 --
diff --git a/src/test/regress/expected/insert.out b/src/test/regress/expected/insert.out
index 1cf6531c01..ab90db4d66 100644
--- a/src/test/regress/expected/insert.out
+++ b/src/test/regress/expected/insert.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- insert with DEFAULT in the target_list
 --
diff --git a/src/test/regress/expected/matview.out b/src/test/regress/expected/matview.out
index 08cd4bea48..ff9ade106d 100644
--- a/src/test/regress/expected/matview.out
+++ b/src/test/regress/expected/matview.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 -- create a table to use as a basis for views and materialized views in various combinations
 CREATE TABLE mvtest_t (id int NOT NULL PRIMARY KEY, type text NOT NULL, amt numeric NOT NULL);
 INSERT INTO mvtest_t VALUES
diff --git a/src/test/regress/expected/publication.out b/src/test/regress/expected/publication.out
index afbbdd543d..cc5d42dbf2 100644
--- a/src/test/regress/expected/publication.out
+++ b/src/test/regress/expected/publication.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- PUBLICATION
 --
diff --git a/src/test/regress/expected/replica_identity.out b/src/test/regress/expected/replica_identity.out
index 175ecd2879..f3331ee833 100644
--- a/src/test/regress/expected/replica_identity.out
+++ b/src/test/regress/expected/replica_identity.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 CREATE TABLE test_replica_identity (
        id serial primary key,
        keya text not null,
diff --git a/src/test/regress/expected/rowsecurity.out b/src/test/regress/expected/rowsecurity.out
index 1d12b01068..a3c3befb04 100644
--- a/src/test/regress/expected/rowsecurity.out
+++ b/src/test/regress/expected/rowsecurity.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test of Row-level security feature
 --
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index b68b8d273f..feb7cd95b1 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- RULES
 -- From Jan's original setup_ruletest.sql and run_ruletest.sql
diff --git a/src/test/regress/expected/update.out b/src/test/regress/expected/update.out
index d09326c182..bf209c14b0 100644
--- a/src/test/regress/expected/update.out
+++ b/src/test/regress/expected/update.out
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- UPDATE syntax tests
 --
diff --git a/src/test/regress/sql/copy2.sql b/src/test/regress/sql/copy2.sql
index e36df8858e..bec93af438 100644
--- a/src/test/regress/sql/copy2.sql
+++ b/src/test/regress/sql/copy2.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 CREATE TEMP TABLE x (
 	a serial,
 	b int,
diff --git a/src/test/regress/sql/create_table.sql b/src/test/regress/sql/create_table.sql
index a2cae9663c..fb1e9083a4 100644
--- a/src/test/regress/sql/create_table.sql
+++ b/src/test/regress/sql/create_table.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- CREATE_TABLE
 --
diff --git a/src/test/regress/sql/create_table_like.sql b/src/test/regress/sql/create_table_like.sql
index 65c3880792..46889a5b1f 100644
--- a/src/test/regress/sql/create_table_like.sql
+++ b/src/test/regress/sql/create_table_like.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 /* Test inheritance of structure (LIKE) */
 CREATE TABLE inhx (xx text DEFAULT 'text');
 
diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql
index 68da27de22..c12f0b3093 100644
--- a/src/test/regress/sql/domain.sql
+++ b/src/test/regress/sql/domain.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test domains.
 --
diff --git a/src/test/regress/sql/foreign_data.sql b/src/test/regress/sql/foreign_data.sql
index d6fb3fae4e..3aba5a9236 100644
--- a/src/test/regress/sql/foreign_data.sql
+++ b/src/test/regress/sql/foreign_data.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test foreign-data wrapper and server management.
 --
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 425052c1f4..40dffccc7d 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test inheritance features
 --
diff --git a/src/test/regress/sql/insert.sql b/src/test/regress/sql/insert.sql
index a7f659bc2b..85b5ca909c 100644
--- a/src/test/regress/sql/insert.sql
+++ b/src/test/regress/sql/insert.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- insert with DEFAULT in the target_list
 --
diff --git a/src/test/regress/sql/matview.sql b/src/test/regress/sql/matview.sql
index d96175aa26..2ce509581d 100644
--- a/src/test/regress/sql/matview.sql
+++ b/src/test/regress/sql/matview.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 -- create a table to use as a basis for views and materialized views in various combinations
 CREATE TABLE mvtest_t (id int NOT NULL PRIMARY KEY, type text NOT NULL, amt numeric NOT NULL);
 INSERT INTO mvtest_t VALUES
diff --git a/src/test/regress/sql/publication.sql b/src/test/regress/sql/publication.sql
index 815410b3c5..d5a1370c74 100644
--- a/src/test/regress/sql/publication.sql
+++ b/src/test/regress/sql/publication.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- PUBLICATION
 --
diff --git a/src/test/regress/sql/replica_identity.sql b/src/test/regress/sql/replica_identity.sql
index b08a3623b8..90db4a7c40 100644
--- a/src/test/regress/sql/replica_identity.sql
+++ b/src/test/regress/sql/replica_identity.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 CREATE TABLE test_replica_identity (
        id serial primary key,
        keya text not null,
diff --git a/src/test/regress/sql/rowsecurity.sql b/src/test/regress/sql/rowsecurity.sql
index 38e9b38bc4..4b1c2ee619 100644
--- a/src/test/regress/sql/rowsecurity.sql
+++ b/src/test/regress/sql/rowsecurity.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- Test of Row-level security feature
 --
diff --git a/src/test/regress/sql/rules.sql b/src/test/regress/sql/rules.sql
index f4ee30ec8f..a54038f3a2 100644
--- a/src/test/regress/sql/rules.sql
+++ b/src/test/regress/sql/rules.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- RULES
 -- From Jan's original setup_ruletest.sql and run_ruletest.sql
diff --git a/src/test/regress/sql/update.sql b/src/test/regress/sql/update.sql
index c9bb3b53d3..837b6d1871 100644
--- a/src/test/regress/sql/update.sql
+++ b/src/test/regress/sql/update.sql
@@ -1,3 +1,4 @@
+\set HIDE_TABLEAM on
 --
 -- UPDATE syntax tests
 --

diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 0a181b01d9..f76c734a28 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1484,6 +1484,8 @@ describeOneTableDetails(const char *schemaname,
 		char	   *reloftype;
 		char		relpersistence;
 		char		relreplident;
+		char	   *relam;
+		bool	    relam_is_default;
 	}			tableinfo;
 	bool		show_column_details = false;
 
@@ -1503,9 +1505,11 @@ describeOneTableDetails(const char *schemaname,
 						  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
 						  "false AS relhasoids, %s, c.reltablespace, "
 						  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
-						  "c.relpersistence, c.relreplident\n"
+						  "c.relpersistence, c.relreplident, am.amname,"
+						  "am.amname = current_setting('default_table_access_method') \n"
 						  "FROM pg_catalog.pg_class c\n "
 						  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
+						  "LEFT JOIN pg_catalog.pg_am am ON (c.relam = am.oid)\n"
 						  "WHERE c.oid = '%s';",
 						  (verbose ?
 						   "pg_catalog.array_to_string(c.reloptions || "
@@ -1656,6 +1660,17 @@ describeOneTableDetails(const char *schemaname,
 		*(PQgetvalue(res, 0, 11)) : 0;
 	tableinfo.relreplident = (pset.sversion >= 90400) ?
 		*(PQgetvalue(res, 0, 12)) : 'd';
+	if (pset.sversion >= 120000)
+	{
+		tableinfo.relam = PQgetisnull(res, 0, 13) ?
+			(char *) NULL : pg_strdup(PQgetvalue(res, 0, 13));
+		tableinfo.relam_is_default = strcmp(PQgetvalue(res, 0, 14), "t") == 0;
+	}
+	else
+	{
+		tableinfo.relam = NULL;
+		tableinfo.relam_is_default = false;
+	}
 	PQclear(res);
 	res = NULL;
 
@@ -3141,6 +3156,14 @@ describeOneTableDetails(const char *schemaname,
 		/* Tablespace info */
 		add_tablespace_footer(&cont, tableinfo.relkind, tableinfo.tablespace,
 							  true);
+
+		/* Access method info */
+		if (verbose && tableinfo.relam != NULL &&
+		   !(pset.hide_tableam && tableinfo.relam_is_default))
+		{
+			printfPQExpBuffer(&buf, _("Access method: %s"), tableinfo.relam);
+			printTableAddFooter(&cont, buf.data);
+		}
 	}
 
 	/* reloptions, if verbose */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 176c85afd0..058233b348 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -127,6 +127,7 @@ typedef struct _psqlSettings
 	bool		quiet;
 	bool		singleline;
 	bool		singlestep;
+	bool		hide_tableam;
 	int			fetch_count;
 	int			histsize;
 	int			ignoreeof;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index e7536a8a06..b757febcc5 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -1128,6 +1128,11 @@ show_context_hook(const char *newval)
 	return true;
 }
 
+static bool
+hide_tableam_hook(const char *newval)
+{
+	return ParseVariableBool(newval, "HIDE_TABLEAM", &pset.hide_tableam);
+}
 
 static void
 EstablishVariableSpace(void)
@@ -1191,4 +1196,7 @@ EstablishVariableSpace(void)
 	SetVariableHooks(pset.vars, "SHOW_CONTEXT",
 					 show_context_substitute_hook,
 					 show_context_hook);
+	SetVariableHooks(pset.vars, "HIDE_TABLEAM",
+					 bool_substitute_hook,
+					 hide_tableam_hook);
 }
diff --git a/src/test/regress/pg_regress_main.c b/src/test/regress/pg_regress_main.c
index bd613e4fda..1b4bca704b 100644
--- a/src/test/regress/pg_regress_main.c
+++ b/src/test/regress/pg_regress_main.c
@@ -74,10 +74,11 @@ psql_start_test(const char *testname,
 	}
 
 	offset += snprintf(psql_cmd + offset, sizeof(psql_cmd) - offset,
-					   "\"%s%spsql\" -X -a -q -d \"%s\" < \"%s\" > \"%s\" 2>&1",
+					   "\"%s%spsql\" -X -a -q -d \"%s\" -v %s < \"%s\" > \"%s\" 2>&1",
 					   bindir ? bindir : "",
 					   bindir ? "/" : "",
 					   dblist->str,
+					   "HIDE_TABLEAM=\"on\"",
 					   infile,
 					   outfile);
 	if (offset >= sizeof(psql_cmd))

From 58ee84b870221a70f8995fd27f1de0e83ec5602a Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 16 Jan 2019 18:43:47 +1100
Subject: [PATCH] Reduce the use of HeapTuple t_tableOid

Except trigger and where the HeapTuple is generated
and passed from slots, still the t_tableOid is used.
This needs to be replaced when the t_tableOid is stored
as a seperate variable/parameter.
---
 contrib/hstore/hstore_io.c                    |  2 -
 contrib/pg_visibility/pg_visibility.c         |  1 -
 contrib/pgstattuple/pgstatapprox.c            |  1 -
 contrib/pgstattuple/pgstattuple.c             |  3 +-
 contrib/postgres_fdw/postgres_fdw.c           | 14 ++++++-
 src/backend/access/common/heaptuple.c         |  7 ----
 src/backend/access/heap/heapam.c              | 41 ++++++-------------
 src/backend/access/heap/heapam_handler.c      | 29 ++++++-------
 src/backend/access/heap/heapam_visibility.c   | 20 ++++-----
 src/backend/access/heap/pruneheap.c           |  2 -
 src/backend/access/heap/tuptoaster.c          |  3 --
 src/backend/access/heap/vacuumlazy.c          |  2 -
 src/backend/access/index/genam.c              |  4 +-
 src/backend/catalog/indexing.c                |  2 +-
 src/backend/commands/analyze.c                |  2 +-
 src/backend/commands/functioncmds.c           |  3 +-
 src/backend/commands/schemacmds.c             |  1 -
 src/backend/commands/trigger.c                | 21 +++++-----
 src/backend/executor/execExprInterp.c         |  1 -
 src/backend/executor/execTuples.c             | 25 +++++++----
 src/backend/executor/execUtils.c              |  2 -
 src/backend/executor/nodeAgg.c                |  3 +-
 src/backend/executor/nodeGather.c             |  1 +
 src/backend/executor/nodeGatherMerge.c        |  1 +
 src/backend/executor/nodeIndexonlyscan.c      |  4 +-
 src/backend/executor/nodeIndexscan.c          |  3 +-
 src/backend/executor/nodeModifyTable.c        |  6 +--
 src/backend/executor/nodeSetOp.c              |  1 +
 src/backend/executor/spi.c                    |  1 -
 src/backend/executor/tqueue.c                 |  1 -
 src/backend/replication/logical/decode.c      |  9 ----
 .../replication/logical/reorderbuffer.c       |  4 +-
 src/backend/utils/adt/expandedrecord.c        |  1 -
 src/backend/utils/adt/jsonfuncs.c             |  2 -
 src/backend/utils/adt/rowtypes.c              | 10 -----
 src/backend/utils/cache/catcache.c            |  1 -
 src/backend/utils/sort/tuplesort.c            |  7 ++--
 src/include/access/heapam.h                   |  2 +-
 src/include/executor/tuptable.h               |  5 +--
 src/include/utils/tqual.h                     |  1 +
 src/pl/plpgsql/src/pl_exec.c                  |  2 -
 src/test/regress/regress.c                    |  1 -
 42 files changed, 98 insertions(+), 154 deletions(-)

diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
index 745497c76f..05244e77ef 100644
--- a/contrib/hstore/hstore_io.c
+++ b/contrib/hstore/hstore_io.c
@@ -845,7 +845,6 @@ hstore_from_record(PG_FUNCTION_ARGS)
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = rec;
 
 		values = (Datum *) palloc(ncolumns * sizeof(Datum));
@@ -998,7 +997,6 @@ hstore_populate_record(PG_FUNCTION_ARGS)
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = rec;
 	}
 
diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index ce9ca704f6..1b1e00d724 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -655,7 +655,6 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 			ItemPointerSet(&(tuple.t_self), blkno, offnum);
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = relid;
 
 			/*
 			 * If we're checking whether the page is all-visible, we expect
diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
index c59fd10dc1..cef8606550 100644
--- a/contrib/pgstattuple/pgstatapprox.c
+++ b/contrib/pgstattuple/pgstatapprox.c
@@ -152,7 +152,6 @@ statapprox_heap(Relation rel, output_type *stat)
 
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = RelationGetRelid(rel);
 
 			/*
 			 * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c
index 520438d779..a39b03bde5 100644
--- a/contrib/pgstattuple/pgstattuple.c
+++ b/contrib/pgstattuple/pgstattuple.c
@@ -344,7 +344,8 @@ pgstat_heap(Relation rel, FunctionCallInfo fcinfo)
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
 		LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
-		if (HeapTupleSatisfies(tuple, &SnapshotDirty, hscan->rs_cbuf))
+		if (HeapTupleSatisfies(tuple, RelationGetRelid(hscan->rs_scan.rs_rd),
+								&SnapshotDirty, hscan->rs_cbuf))
 		{
 			stat.tuple_len += tuple->t_len;
 			stat.tuple_count++;
diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index cc5b928950..5355e0e00e 100644
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -1445,6 +1445,8 @@ postgresIterateForeignScan(ForeignScanState *node)
 	 */
 	ExecStoreHeapTuple(fsstate->tuples[fsstate->next_tuple++],
 					   slot,
+					   fsstate->rel ?
+							   RelationGetRelid(fsstate->rel) : InvalidOid,
 					   false);
 
 	return slot;
@@ -3538,7 +3540,11 @@ store_returning_result(PgFdwModifyState *fmstate,
 											NULL,
 											fmstate->temp_cxt);
 		/* tuple will be deleted when it is cleared from the slot */
-		ExecStoreHeapTuple(newtup, slot, true);
+		ExecStoreHeapTuple(newtup,
+							slot,
+							fmstate->rel ?
+								RelationGetRelid(fmstate->rel) : InvalidOid,
+							true);
 	}
 	PG_CATCH();
 	{
@@ -3810,7 +3816,11 @@ get_returning_data(ForeignScanState *node)
 												dmstate->retrieved_attrs,
 												node,
 												dmstate->temp_cxt);
-			ExecStoreHeapTuple(newtup, slot, false);
+			ExecStoreHeapTuple(newtup,
+								slot,
+								dmstate->rel ?
+								RelationGetRelid(dmstate->rel) : InvalidOid,
+								false);
 		}
 		PG_CATCH();
 		{
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index 06dd628a5b..5beef33291 100644
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -689,7 +689,6 @@ heap_copytuple(HeapTuple tuple)
 	newTuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple->t_len);
 	newTuple->t_len = tuple->t_len;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 	newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
 	memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
 	return newTuple;
@@ -715,7 +714,6 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
 
 	dest->t_len = src->t_len;
 	dest->t_self = src->t_self;
-	dest->t_tableOid = src->t_tableOid;
 	dest->t_data = (HeapTupleHeader) palloc(src->t_len);
 	memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
 }
@@ -850,7 +848,6 @@ expand_tuple(HeapTuple *targetHeapTuple,
 			= targetTHeader
 			= (HeapTupleHeader) ((char *) *targetHeapTuple + HEAPTUPLESIZE);
 		(*targetHeapTuple)->t_len = len;
-		(*targetHeapTuple)->t_tableOid = sourceTuple->t_tableOid;
 		(*targetHeapTuple)->t_self = sourceTuple->t_self;
 
 		targetTHeader->t_infomask = sourceTHeader->t_infomask;
@@ -1078,7 +1075,6 @@ heap_form_tuple(TupleDesc tupleDescriptor,
 	 */
 	tuple->t_len = len;
 	ItemPointerSetInvalid(&(tuple->t_self));
-	tuple->t_tableOid = InvalidOid;
 
 	HeapTupleHeaderSetDatumLength(td, len);
 	HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
@@ -1162,7 +1158,6 @@ heap_modify_tuple(HeapTuple tuple,
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 
 	return newTuple;
 }
@@ -1225,7 +1220,6 @@ heap_modify_tuple_by_cols(HeapTuple tuple,
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 
 	return newTuple;
 }
@@ -1465,7 +1459,6 @@ heap_tuple_from_minimal_tuple(MinimalTuple mtup)
 	result = (HeapTuple) palloc(HEAPTUPLESIZE + len);
 	result->t_len = len;
 	ItemPointerSetInvalid(&(result->t_self));
-	result->t_tableOid = InvalidOid;
 	result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
 	memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
 	memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index f769d828ff..22080fc5bc 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -423,7 +423,6 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
 			HeapTupleData loctup;
 			bool		valid;
 
-			loctup.t_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 			loctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lpp);
 			loctup.t_len = ItemIdGetLength(lpp);
 			ItemPointerSet(&(loctup.t_self), page, lineoff);
@@ -431,7 +430,8 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
 			if (all_visible)
 				valid = true;
 			else
-				valid = HeapTupleSatisfies(&loctup, snapshot, buffer);
+				valid = HeapTupleSatisfies(&loctup, RelationGetRelid(scan->rs_scan.rs_rd),
+											snapshot, buffer);
 
 			CheckForSerializableConflictOut(valid, scan->rs_scan.rs_rd, &loctup,
 											buffer, snapshot);
@@ -646,7 +646,8 @@ heapgettup(HeapScanDesc scan,
 				/*
 				 * if current tuple qualifies, return it.
 				 */
-				valid = HeapTupleSatisfies(tuple, snapshot, scan->rs_cbuf);
+				valid = HeapTupleSatisfies(tuple, RelationGetRelid(scan->rs_scan.rs_rd),
+											snapshot, scan->rs_cbuf);
 
 				CheckForSerializableConflictOut(valid, scan->rs_scan.rs_rd, tuple,
 												scan->rs_cbuf, snapshot);
@@ -1442,9 +1443,6 @@ heap_beginscan(Relation relation, Snapshot snapshot,
 	if (!is_bitmapscan && snapshot)
 		PredicateLockRelation(relation, snapshot);
 
-	/* we only need to set this up once */
-	scan->rs_ctup.t_tableOid = RelationGetRelid(relation);
-
 	/*
 	 * we do this here instead of in initscan() because heap_rescan also calls
 	 * initscan() and we don't want to allocate memory again
@@ -1657,6 +1655,7 @@ heap_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *s
 
 	pgstat_count_heap_getnext(scan->rs_scan.rs_rd);
 
+	slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 	return ExecStoreBufferHeapTuple(&scan->rs_ctup, slot,
 									scan->rs_cbuf);
 }
@@ -1760,12 +1759,11 @@ heap_fetch(Relation relation,
 	ItemPointerCopy(tid, &(tuple->t_self));
 	tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tuple->t_len = ItemIdGetLength(lp);
-	tuple->t_tableOid = RelationGetRelid(relation);
 
 	/*
 	 * check time qualification of tuple, then release lock
 	 */
-	valid = HeapTupleSatisfies(tuple, snapshot, buffer);
+	valid = HeapTupleSatisfies(tuple, RelationGetRelid(relation), snapshot, buffer);
 
 	if (valid)
 		PredicateLockTuple(relation, tuple, snapshot);
@@ -1870,7 +1868,6 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
 
 		heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp);
 		heapTuple->t_len = ItemIdGetLength(lp);
-		heapTuple->t_tableOid = RelationGetRelid(relation);
 		ItemPointerSetOffsetNumber(&heapTuple->t_self, offnum);
 
 		/*
@@ -1907,7 +1904,8 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
 			ItemPointerSet(&(heapTuple->t_self), BufferGetBlockNumber(buffer), offnum);
 
 			/* If it's visible per the snapshot, we must return it */
-			valid = HeapTupleSatisfies(heapTuple, snapshot, buffer);
+			valid = HeapTupleSatisfies(heapTuple, RelationGetRelid(relation),
+										snapshot, buffer);
 			CheckForSerializableConflictOut(valid, relation, heapTuple,
 											buffer, snapshot);
 			/* reset to original, non-redirected, tid */
@@ -2064,7 +2062,6 @@ heap_get_latest_tid(Relation relation,
 		tp.t_self = ctid;
 		tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 		tp.t_len = ItemIdGetLength(lp);
-		tp.t_tableOid = RelationGetRelid(relation);
 
 		/*
 		 * After following a t_ctid link, we might arrive at an unrelated
@@ -2081,7 +2078,7 @@ heap_get_latest_tid(Relation relation,
 		 * Check time qualification of tuple; if visible, set it as the new
 		 * result candidate.
 		 */
-		valid = HeapTupleSatisfies(&tp, snapshot, buffer);
+		valid = HeapTupleSatisfies(&tp, RelationGetRelid(relation), snapshot, buffer);
 		CheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
 		if (valid)
 			*tid = ctid;
@@ -2433,7 +2430,6 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
 
 	HeapTupleHeaderSetCmin(tup->t_data, cid);
 	HeapTupleHeaderSetXmax(tup->t_data, 0); /* for cleanliness */
-	tup->t_tableOid = RelationGetRelid(relation);
 
 	/*
 	 * If the new tuple is too big for storage or contains already toasted
@@ -2491,9 +2487,6 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
 	{
 		heaptuples[i] = heap_prepare_insert(relation, ExecFetchSlotHeapTuple(slots[i], true, NULL),
 											xid, cid, options);
-
-		if (slots[i]->tts_tableOid != InvalidOid)
-			heaptuples[i]->t_tableOid = slots[i]->tts_tableOid;
 	}
 
 	/*
@@ -2883,7 +2876,6 @@ heap_delete(Relation relation, ItemPointer tid,
 	lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
 	Assert(ItemIdIsNormal(lp));
 
-	tp.t_tableOid = RelationGetRelid(relation);
 	tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tp.t_len = ItemIdGetLength(lp);
 	tp.t_self = *tid;
@@ -3000,7 +2992,7 @@ l1:
 	if (crosscheck != InvalidSnapshot && result == HeapTupleMayBeUpdated)
 	{
 		/* Perform additional check for transaction-snapshot mode RI updates */
-		if (!HeapTupleSatisfies(&tp, crosscheck, buffer))
+		if (!HeapTupleSatisfies(&tp, RelationGetRelid(relation), crosscheck, buffer))
 			result = HeapTupleUpdated;
 	}
 
@@ -3404,14 +3396,10 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
 	 * Fill in enough data in oldtup for HeapDetermineModifiedColumns to work
 	 * properly.
 	 */
-	oldtup.t_tableOid = RelationGetRelid(relation);
 	oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	oldtup.t_len = ItemIdGetLength(lp);
 	oldtup.t_self = *otid;
 
-	/* the new tuple is ready, except for this: */
-	newtup->t_tableOid = RelationGetRelid(relation);
-
 	/* Determine columns modified by the update. */
 	modified_attrs = HeapDetermineModifiedColumns(relation, interesting_attrs,
 												  &oldtup, newtup);
@@ -3642,7 +3630,7 @@ l2:
 	if (crosscheck != InvalidSnapshot && result == HeapTupleMayBeUpdated)
 	{
 		/* Perform additional check for transaction-snapshot mode RI updates */
-		if (!HeapTupleSatisfies(&oldtup, crosscheck, buffer))
+		if (!HeapTupleSatisfies(&oldtup, RelationGetRelid(relation), crosscheck, buffer))
 			result = HeapTupleUpdated;
 	}
 
@@ -4267,14 +4255,14 @@ ProjIndexIsUnchanged(Relation relation, HeapTuple oldtup, HeapTuple newtup)
 			int			i;
 
 			ResetExprContext(econtext);
-			ExecStoreHeapTuple(oldtup, slot, false);
+			ExecStoreHeapTuple(oldtup, slot, RelationGetRelid(relation),false);
 			FormIndexDatum(indexInfo,
 						   slot,
 						   estate,
 						   old_values,
 						   old_isnull);
 
-			ExecStoreHeapTuple(newtup, slot, false);
+			ExecStoreHeapTuple(newtup, slot, RelationGetRelid(relation), false);
 			FormIndexDatum(indexInfo,
 						   slot,
 						   estate,
@@ -4486,7 +4474,6 @@ heap_lock_tuple(Relation relation, ItemPointer tid,
 
 	tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tuple->t_len = ItemIdGetLength(lp);
-	tuple->t_tableOid = RelationGetRelid(relation);
 	tuple->t_self = *tid;
 
 l3:
@@ -6044,7 +6031,6 @@ heap_abort_speculative(Relation relation, HeapTuple tuple)
 	lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
 	Assert(ItemIdIsNormal(lp));
 
-	tp.t_tableOid = RelationGetRelid(relation);
 	tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tp.t_len = ItemIdGetLength(lp);
 	tp.t_self = *tid;
@@ -7747,7 +7733,6 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
 	HeapTupleHeader hdr = tup->t_data;
 
 	Assert(ItemPointerIsValid(&tup->t_self));
-	Assert(tup->t_tableOid != InvalidOid);
 
 	xlrec.top_xid = GetTopTransactionId();
 	xlrec.target_node = relation->rd_node;
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 95513dfec8..9119bdf162 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -90,8 +90,6 @@ heapam_heap_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
 
 	/* Update the tuple with table oid */
 	slot->tts_tableOid = RelationGetRelid(relation);
-	if (slot->tts_tableOid != InvalidOid)
-		tuple->t_tableOid = slot->tts_tableOid;
 
 	/* Perform the insertion, and copy the resulting ItemPointer */
 	heap_insert(relation, tuple, cid, options, bistate);
@@ -110,8 +108,6 @@ heapam_heap_insert_speculative(Relation relation, TupleTableSlot *slot, CommandI
 
 	/* Update the tuple with table oid */
 	slot->tts_tableOid = RelationGetRelid(relation);
-	if (slot->tts_tableOid != InvalidOid)
-		tuple->t_tableOid = slot->tts_tableOid;
 
 	HeapTupleHeaderSetSpeculativeToken(tuple->t_data, specToken);
 
@@ -386,10 +382,6 @@ heapam_heap_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
 	HeapTuple	tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);
 	HTSU_Result result;
 
-	/* Update the tuple with table oid */
-	if (slot->tts_tableOid != InvalidOid)
-		tuple->t_tableOid = slot->tts_tableOid;
-
 	result = heap_update(relation, otid, tuple, cid, crosscheck, wait,
 						 hufd, lockmode);
 	ItemPointerCopy(&tuple->t_self, &slot->tts_tid);
@@ -450,7 +442,7 @@ heapam_satisfies(Relation rel, TupleTableSlot *slot, Snapshot snapshot)
 	 * Caller should be holding pin, but not lock.
 	 */
 	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfies(bslot->base.tuple, snapshot, bslot->buffer);
+	res = HeapTupleSatisfies(bslot->base.tuple, RelationGetRelid(rel), snapshot, bslot->buffer);
 	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
 
 	return res;
@@ -984,7 +976,7 @@ IndexBuildHeapRangeScan(Relation heapRelation,
 		MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
 		/* Set up for predicate or expression evaluation */
-		ExecStoreHeapTuple(heapTuple, slot, false);
+		ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(sscan->rs_rd), false);
 
 		/*
 		 * In a partial index, discard tuples that don't satisfy the
@@ -1240,7 +1232,7 @@ validate_index_heapscan(Relation heapRelation,
 			MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
 			/* Set up for predicate or expression evaluation */
-			ExecStoreHeapTuple(heapTuple, slot, false);
+			ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(sscan->rs_rd), false);
 
 			/*
 			 * In a partial index, discard tuples that don't satisfy the
@@ -1393,9 +1385,11 @@ heapam_scan_bitmap_pagescan(TableScanDesc sscan,
 				continue;
 			loctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
 			loctup.t_len = ItemIdGetLength(lp);
-			loctup.t_tableOid = scan->rs_scan.rs_rd->rd_id;
 			ItemPointerSet(&loctup.t_self, page, offnum);
-			valid = HeapTupleSatisfies(&loctup, snapshot, buffer);
+			valid = HeapTupleSatisfies(&loctup,
+							RelationGetRelid(scan->rs_scan.rs_rd),
+							snapshot,
+							buffer);
 			if (valid)
 			{
 				scan->rs_vistuples[ntup++] = offnum;
@@ -1432,7 +1426,6 @@ heapam_scan_bitmap_pagescan_next(TableScanDesc sscan, TupleTableSlot *slot)
 
 	scan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
 	scan->rs_ctup.t_len = ItemIdGetLength(lp);
-	scan->rs_ctup.t_tableOid = scan->rs_scan.rs_rd->rd_id;
 	ItemPointerSet(&scan->rs_ctup.t_self, scan->rs_cblock, targoffset);
 
 	pgstat_count_heap_fetch(scan->rs_scan.rs_rd);
@@ -1444,6 +1437,7 @@ heapam_scan_bitmap_pagescan_next(TableScanDesc sscan, TupleTableSlot *slot)
 	ExecStoreBufferHeapTuple(&scan->rs_ctup,
 							 slot,
 							 scan->rs_cbuf);
+	slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 
 	scan->rs_cindex++;
 
@@ -1490,7 +1484,9 @@ SampleHeapTupleVisible(HeapScanDesc scan, Buffer buffer,
 	else
 	{
 		/* Otherwise, we have to check the tuple individually. */
-		return HeapTupleSatisfies(tuple, scan->rs_scan.rs_snapshot, buffer);
+		return HeapTupleSatisfies(tuple,
+									RelationGetRelid(scan->rs_scan.rs_rd),
+									scan->rs_scan.rs_snapshot, buffer);
 	}
 }
 
@@ -1635,6 +1631,7 @@ heapam_scan_sample_next_tuple(TableScanDesc sscan, struct SampleScanState *scans
 				continue;
 
 			ExecStoreBufferHeapTuple(tuple, slot, scan->rs_cbuf);
+			slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 
 			/* Found visible tuple, return it. */
 			if (!pagemode)
@@ -1720,7 +1717,6 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 
 		ItemPointerSet(&targtuple->t_self, scan->rs_cblock, scan->rs_cindex);
 
-		targtuple->t_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 		targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
 		targtuple->t_len = ItemIdGetLength(itemid);
 
@@ -1792,6 +1788,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 		if (sample_it)
 		{
 			ExecStoreBufferHeapTuple(targtuple, slot, scan->rs_cbuf);
+			slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 			scan->rs_cindex++;
 
 			/* note that we leave the buffer locked here! */
diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
index 1ac1a20c1d..cd4d3af3c3 100644
--- a/src/backend/access/heap/heapam_visibility.c
+++ b/src/backend/access/heap/heapam_visibility.c
@@ -179,7 +179,6 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -370,7 +369,6 @@ HeapTupleSatisfiesToast(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -464,7 +462,6 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -757,7 +754,6 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	snapshot->xmin = snapshot->xmax = InvalidTransactionId;
 	snapshot->speculativeToken = 0;
@@ -981,7 +977,6 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -1183,7 +1178,6 @@ HeapTupleSatisfiesVacuum(HeapTuple stup, TransactionId OldestXmin,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/*
 	 * Has inserting transaction committed?
@@ -1611,7 +1605,6 @@ HeapTupleIsSurelyDead(HeapTuple htup, TransactionId OldestXmin)
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/*
 	 * If the inserting transaction is marked invalid, then it aborted, and
@@ -1675,7 +1668,7 @@ TransactionIdInArray(TransactionId xid, TransactionId *xip, Size num)
  * complicated than when dealing "only" with the present.
  */
 static bool
-HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Oid relid, Snapshot snapshot,
 							   Buffer buffer)
 {
 	HeapTupleHeader tuple = htup->t_data;
@@ -1683,7 +1676,6 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 	TransactionId xmax = HeapTupleHeaderGetRawXmax(tuple);
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/* inserting transaction aborted */
 	if (HeapTupleHeaderXminInvalid(tuple))
@@ -1704,7 +1696,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 		 * values externally.
 		 */
 		resolved = ResolveCminCmaxDuringDecoding(HistoricSnapshotGetTupleCids(), snapshot,
-												 htup, buffer,
+												 htup, relid, buffer,
 												 &cmin, &cmax);
 
 		if (!resolved)
@@ -1775,7 +1767,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 
 		/* Lookup actual cmin/cmax values */
 		resolved = ResolveCminCmaxDuringDecoding(HistoricSnapshotGetTupleCids(), snapshot,
-												 htup, buffer,
+												 htup, relid, buffer,
 												 &cmin, &cmax);
 
 		if (!resolved)
@@ -1813,8 +1805,10 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 }
 
 bool
-HeapTupleSatisfies(HeapTuple stup, Snapshot snapshot, Buffer buffer)
+HeapTupleSatisfies(HeapTuple stup, Oid relid, Snapshot snapshot, Buffer buffer)
 {
+	Assert(relid != InvalidOid);
+
 	switch (snapshot->visibility_type)
 	{
 		case MVCC_VISIBILITY:
@@ -1833,7 +1827,7 @@ HeapTupleSatisfies(HeapTuple stup, Snapshot snapshot, Buffer buffer)
 			return HeapTupleSatisfiesDirty(stup, snapshot, buffer);
 			break;
 		case HISTORIC_MVCC_VISIBILITY:
-			return HeapTupleSatisfiesHistoricMVCC(stup, snapshot, buffer);
+			return HeapTupleSatisfiesHistoricMVCC(stup, relid, snapshot, buffer);
 			break;
 		case NON_VACUUMABLE_VISIBILTY:
 			return HeapTupleSatisfiesNonVacuumable(stup, snapshot, buffer);
diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
index c2f5343dac..79964e157a 100644
--- a/src/backend/access/heap/pruneheap.c
+++ b/src/backend/access/heap/pruneheap.c
@@ -367,8 +367,6 @@ heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
 				i;
 	HeapTupleData tup;
 
-	tup.t_tableOid = RelationGetRelid(relation);
-
 	rootlp = PageGetItemId(dp, rootoffnum);
 
 	/*
diff --git a/src/backend/access/heap/tuptoaster.c b/src/backend/access/heap/tuptoaster.c
index 486cde4aff..5349dbf805 100644
--- a/src/backend/access/heap/tuptoaster.c
+++ b/src/backend/access/heap/tuptoaster.c
@@ -1023,7 +1023,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
 		result_tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + new_tuple_len);
 		result_tuple->t_len = new_tuple_len;
 		result_tuple->t_self = newtup->t_self;
-		result_tuple->t_tableOid = newtup->t_tableOid;
 		new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);
 		result_tuple->t_data = new_data;
 
@@ -1124,7 +1123,6 @@ toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
 	 * a syscache entry.
 	 */
 	new_tuple->t_self = tup->t_self;
-	new_tuple->t_tableOid = tup->t_tableOid;
 
 	new_tuple->t_data->t_choice = tup->t_data->t_choice;
 	new_tuple->t_data->t_ctid = tup->t_data->t_ctid;
@@ -1195,7 +1193,6 @@ toast_flatten_tuple_to_datum(HeapTupleHeader tup,
 	/* Build a temporary HeapTuple control structure */
 	tmptup.t_len = tup_len;
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tup;
 
 	/*
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 429f9ad52a..87589a927e 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -1004,7 +1004,6 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats,
 
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = RelationGetRelid(onerel);
 
 			tupgone = false;
 
@@ -2238,7 +2237,6 @@ heap_page_is_all_visible(Relation rel, Buffer buf,
 
 		tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 		tuple.t_len = ItemIdGetLength(itemid);
-		tuple.t_tableOid = RelationGetRelid(rel);
 
 		switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
 		{
diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index 5f033c5ee4..02afc191b6 100644
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -462,7 +462,7 @@ systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
 		Assert(BufferIsValid(hscan->xs_cbuf));
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
 		LockBuffer(hscan->xs_cbuf, BUFFER_LOCK_SHARE);
-		result = HeapTupleSatisfies(tup, freshsnap, hscan->xs_cbuf);
+		result = HeapTupleSatisfies(tup, RelationGetRelid(sysscan->heap_rel), freshsnap, hscan->xs_cbuf);
 		LockBuffer(hscan->xs_cbuf, BUFFER_LOCK_UNLOCK);
 	}
 	else
@@ -474,7 +474,7 @@ systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
 		Assert(BufferIsValid(scan->rs_cbuf));
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
 		LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
-		result = HeapTupleSatisfies(tup, freshsnap, scan->rs_cbuf);
+		result = HeapTupleSatisfies(tup, RelationGetRelid(sysscan->heap_rel), freshsnap, scan->rs_cbuf);
 		LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 	}
 	return result;
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index 52a2ccb40f..88b8df0b7a 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -97,7 +97,7 @@ CatalogIndexInsert(CatalogIndexState indstate, HeapTuple heapTuple)
 	/* Need a slot to hold the tuple being examined */
 	slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
 									&TTSOpsHeapTuple);
-	ExecStoreHeapTuple(heapTuple, slot, false);
+	ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(heapRelation), false);
 
 	/*
 	 * for each index, form and insert the index tuple
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 29e2377b52..b2697dae44 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -758,7 +758,7 @@ compute_index_stats(Relation onerel, double totalrows,
 			ResetExprContext(econtext);
 
 			/* Set up for predicate or expression evaluation */
-			ExecStoreHeapTuple(heapTuple, slot, false);
+			ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(onerel), false);
 
 			/* If index is partial, check predicate */
 			if (predicate != NULL)
diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
index ebece4d1d7..a9f7d55940 100644
--- a/src/backend/commands/functioncmds.c
+++ b/src/backend/commands/functioncmds.c
@@ -2360,10 +2360,9 @@ ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver
 
 		rettupdata.t_len = HeapTupleHeaderGetDatumLength(td);
 		ItemPointerSetInvalid(&(rettupdata.t_self));
-		rettupdata.t_tableOid = InvalidOid;
 		rettupdata.t_data = td;
 
-		slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, false);
+		slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, InvalidOid, false);
 		tstate->dest->receiveSlot(slot, tstate->dest);
 
 		end_tup_output(tstate);
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index f0ebe2d1c3..ba31f46019 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -355,7 +355,6 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
 {
 	Form_pg_namespace nspForm;
 
-	Assert(tup->t_tableOid == NamespaceRelationId);
 	Assert(RelationGetRelid(rel) == NamespaceRelationId);
 
 	nspForm = (Form_pg_namespace) GETSTRUCT(tup);
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 6a00a96f59..313222008d 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -2573,7 +2573,7 @@ ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		if (newtuple != oldtuple)
 		{
-			ExecForceStoreHeapTuple(newtuple, slot);
+			ExecForceStoreHeapTuple(newtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 			newtuple = ExecFetchSlotHeapTuple(slot, true, NULL);
 		}
 	}
@@ -2653,7 +2653,8 @@ ExecIRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		if (oldtuple != newtuple)
 		{
-			ExecForceStoreHeapTuple(newtuple, LocTriggerData.tg_trigslot);
+			ExecForceStoreHeapTuple(newtuple, LocTriggerData.tg_trigslot,
+									RelationGetRelid(relinfo->ri_RelationDesc));
 			newtuple = ExecFetchSlotHeapTuple(slot, true, NULL);
 		}
 	}
@@ -2777,7 +2778,7 @@ ExecBRDeleteTriggers(EState *estate, EPQState *epqstate,
 	else
 	{
 		trigtuple = fdw_trigtuple;
-		ExecForceStoreHeapTuple(trigtuple, slot);
+		ExecForceStoreHeapTuple(trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 
 	LocTriggerData.type = T_TriggerData;
@@ -2854,7 +2855,7 @@ ExecARDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		else
 		{
-			ExecForceStoreHeapTuple(fdw_trigtuple, slot);
+			ExecForceStoreHeapTuple(fdw_trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 		}
 
 		AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_DELETE,
@@ -2884,7 +2885,7 @@ ExecIRDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
 	LocTriggerData.tg_oldtable = NULL;
 	LocTriggerData.tg_newtable = NULL;
 
-	ExecForceStoreHeapTuple(trigtuple, slot);
+	ExecForceStoreHeapTuple(trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 	for (i = 0; i < trigdesc->numtriggers; i++)
 	{
@@ -3044,7 +3045,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
 	}
 	else
 	{
-		ExecForceStoreHeapTuple(fdw_trigtuple, oldslot);
+		ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 		trigtuple = fdw_trigtuple;
 	}
 
@@ -3090,7 +3091,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
 		}
 
 		if (newtuple != oldtuple)
-			ExecForceStoreHeapTuple(newtuple, newslot);
+			ExecForceStoreHeapTuple(newtuple, newslot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 	if (false && trigtuple != fdw_trigtuple && trigtuple != newtuple)
 		heap_freetuple(trigtuple);
@@ -3132,7 +3133,7 @@ ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 							   NULL,
 							   NULL);
 		else if (fdw_trigtuple != NULL)
-			ExecForceStoreHeapTuple(fdw_trigtuple, oldslot);
+			ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 		AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE,
 							  true, oldslot, newslot, recheckIndexes,
@@ -3161,7 +3162,7 @@ ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 	LocTriggerData.tg_oldtable = NULL;
 	LocTriggerData.tg_newtable = NULL;
 
-	ExecForceStoreHeapTuple(trigtuple, oldslot);
+	ExecForceStoreHeapTuple(trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 	for (i = 0; i < trigdesc->numtriggers; i++)
 	{
@@ -3193,7 +3194,7 @@ ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 			return false;		/* "do nothing" */
 
 		if (oldtuple != newtuple)
-			ExecForceStoreHeapTuple(newtuple, newslot);
+			ExecForceStoreHeapTuple(newtuple, newslot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 
 	return true;
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index 6cac1cf99c..b2a70bc07d 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -3004,7 +3004,6 @@ ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econte
 		tuphdr = DatumGetHeapTupleHeader(tupDatum);
 		tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
 		ItemPointerSetInvalid(&(tmptup.t_self));
-		tmptup.t_tableOid = InvalidOid;
 		tmptup.t_data = tuphdr;
 
 		heap_deform_tuple(&tmptup, tupDesc,
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index d91a71a7c1..ac8e8dc8cd 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -383,7 +383,7 @@ tts_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 	tuple = ExecCopySlotHeapTuple(srcslot);
 	MemoryContextSwitchTo(oldcontext);
 
-	ExecStoreHeapTuple(tuple, dstslot, true);
+	ExecStoreHeapTuple(tuple, dstslot, srcslot->tts_tableOid, true);
 }
 
 static HeapTuple
@@ -1126,6 +1126,7 @@ MakeTupleTableSlot(TupleDesc tupleDesc,
 	slot->tts_tupleDescriptor = tupleDesc;
 	slot->tts_mcxt = CurrentMemoryContext;
 	slot->tts_nvalid = 0;
+	slot->tts_tableOid = InvalidOid;
 
 	if (tupleDesc != NULL)
 	{
@@ -1388,6 +1389,7 @@ ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
 TupleTableSlot *
 ExecStoreHeapTuple(HeapTuple tuple,
 				   TupleTableSlot *slot,
+				   Oid relid,
 				   bool shouldFree)
 {
 	/*
@@ -1405,7 +1407,7 @@ ExecStoreHeapTuple(HeapTuple tuple,
 	else
 		elog(ERROR, "trying to store a heap tuple into wrong type of slot");
 
-	slot->tts_tableOid = tuple->t_tableOid;
+	slot->tts_tableOid = relid;
 
 	return slot;
 }
@@ -1446,8 +1448,6 @@ ExecStoreBufferHeapTuple(HeapTuple tuple,
 		elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
 	tts_buffer_heap_store_tuple(slot, tuple, buffer);
 
-	slot->tts_tableOid = tuple->t_tableOid;
-
 	return slot;
 }
 
@@ -1482,11 +1482,12 @@ ExecStoreMinimalTuple(MinimalTuple mtup,
  */
 void
 ExecForceStoreHeapTuple(HeapTuple tuple,
-						TupleTableSlot *slot)
+						TupleTableSlot *slot,
+						Oid relid)
 {
 	if (TTS_IS_HEAPTUPLE(slot))
 	{
-		ExecStoreHeapTuple(tuple, slot, false);
+		ExecStoreHeapTuple(tuple, slot, relid, false);
 	}
 	else if (TTS_IS_BUFFERTUPLE(slot))
 	{
@@ -1499,6 +1500,7 @@ ExecForceStoreHeapTuple(HeapTuple tuple,
 		oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
 		bslot->base.tuple = heap_copytuple(tuple);
 		MemoryContextSwitchTo(oldContext);
+		slot->tts_tableOid = relid;
 	}
 	else
 	{
@@ -1506,6 +1508,7 @@ ExecForceStoreHeapTuple(HeapTuple tuple,
 		heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
 						  slot->tts_values, slot->tts_isnull);
 		ExecStoreVirtualTuple(slot);
+		slot->tts_tableOid = relid;
 	}
 }
 
@@ -1639,6 +1642,8 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 HeapTuple
 ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
 {
+	HeapTuple htup;
+
 	/*
 	 * sanity checks
 	 */
@@ -1653,14 +1658,18 @@ ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
 	{
 		if (shouldFree)
 			*shouldFree = true;
-		return slot->tts_ops->copy_heap_tuple(slot);
+		htup = slot->tts_ops->copy_heap_tuple(slot);
 	}
 	else
 	{
 		if (shouldFree)
 			*shouldFree = false;
-		return slot->tts_ops->get_heap_tuple(slot);
+		htup = slot->tts_ops->get_heap_tuple(slot);
 	}
+
+	htup->t_tableOid = slot->tts_tableOid;
+
+	return htup;
 }
 
 /* --------------------------------
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 4031642b80..db2020bd0d 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -1070,7 +1070,6 @@ GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
 	 */
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuple;
 
 	result = heap_getattr(&tmptup,
@@ -1118,7 +1117,6 @@ GetAttributeByNum(HeapTupleHeader tuple,
 	 */
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuple;
 
 	result = heap_getattr(&tmptup,
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index daf56cd3d1..ced48bb791 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -1801,7 +1801,8 @@ agg_retrieve_direct(AggState *aggstate)
 				 * cleared from the slot.
 				 */
 				ExecForceStoreHeapTuple(aggstate->grp_firstTuple,
-								   firstSlot);
+								   firstSlot,
+								   InvalidOid);
 				aggstate->grp_firstTuple = NULL;	/* don't keep two pointers */
 
 				/* set up for first advance_aggregates call */
diff --git a/src/backend/executor/nodeGather.c b/src/backend/executor/nodeGather.c
index 1dd8bb3f3a..1d4d79a3ab 100644
--- a/src/backend/executor/nodeGather.c
+++ b/src/backend/executor/nodeGather.c
@@ -280,6 +280,7 @@ gather_getnext(GatherState *gatherstate)
 			{
 				ExecStoreHeapTuple(tup, /* tuple to store */
 								   fslot,	/* slot to store the tuple */
+								   InvalidOid,
 								   true);	/* pfree tuple when done with it */
 				return fslot;
 			}
diff --git a/src/backend/executor/nodeGatherMerge.c b/src/backend/executor/nodeGatherMerge.c
index 54ef0ca7b7..73625965b2 100644
--- a/src/backend/executor/nodeGatherMerge.c
+++ b/src/backend/executor/nodeGatherMerge.c
@@ -703,6 +703,7 @@ gather_merge_readnext(GatherMergeState *gm_state, int reader, bool nowait)
 	ExecStoreHeapTuple(tup,			/* tuple to store */
 					   gm_state->gm_slots[reader],	/* slot in which to store
 													 * the tuple */
+					   InvalidOid,
 					   true);		/* pfree tuple when done with it */
 
 	return true;
diff --git a/src/backend/executor/nodeIndexonlyscan.c b/src/backend/executor/nodeIndexonlyscan.c
index c39c4f453d..3c51c4f635 100644
--- a/src/backend/executor/nodeIndexonlyscan.c
+++ b/src/backend/executor/nodeIndexonlyscan.c
@@ -203,8 +203,8 @@ IndexOnlyNext(IndexOnlyScanState *node)
 			 */
 			Assert(slot->tts_tupleDescriptor->natts ==
 				   scandesc->xs_hitupdesc->natts);
-			ExecForceStoreHeapTuple(scandesc->xs_hitup, slot);
-			slot->tts_tableOid = RelationGetRelid(scandesc->heapRelation);
+			ExecForceStoreHeapTuple(scandesc->xs_hitup, slot,
+					RelationGetRelid(scandesc->heapRelation));
 		}
 		else if (scandesc->xs_itup)
 			StoreIndexTuple(slot, scandesc->xs_itup, scandesc->xs_itupdesc);
diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c
index b38dadaa9a..28b3bdb4d4 100644
--- a/src/backend/executor/nodeIndexscan.c
+++ b/src/backend/executor/nodeIndexscan.c
@@ -247,8 +247,7 @@ IndexNextWithReorder(IndexScanState *node)
 				tuple = reorderqueue_pop(node);
 
 				/* Pass 'true', as the tuple in the queue is a palloc'd copy */
-				slot->tts_tableOid = RelationGetRelid(scandesc->heapRelation);
-				ExecStoreHeapTuple(tuple, slot, true);
+				ExecStoreHeapTuple(tuple, slot, RelationGetRelid(scandesc->heapRelation), true);
 				return slot;
 			}
 		}
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index d1ac9fc2e9..8aa7501830 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -842,7 +842,7 @@ ldelete:;
 			slot = ExecTriggerGetReturnSlot(estate, resultRelationDesc);
 			if (oldtuple != NULL)
 			{
-				ExecForceStoreHeapTuple(oldtuple, slot);
+				ExecForceStoreHeapTuple(oldtuple, slot, RelationGetRelid(resultRelationDesc));
 			}
 			else
 			{
@@ -2035,10 +2035,6 @@ ExecModifyTable(PlanState *pstate)
 					oldtupdata.t_len =
 						HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
 					ItemPointerSetInvalid(&(oldtupdata.t_self));
-					/* Historically, view triggers see invalid t_tableOid. */
-					oldtupdata.t_tableOid =
-						(relkind == RELKIND_VIEW) ? InvalidOid :
-						RelationGetRelid(resultRelInfo->ri_RelationDesc);
 
 					oldtuple = &oldtupdata;
 				}
diff --git a/src/backend/executor/nodeSetOp.c b/src/backend/executor/nodeSetOp.c
index 48b7aa9b8b..4f7da00d82 100644
--- a/src/backend/executor/nodeSetOp.c
+++ b/src/backend/executor/nodeSetOp.c
@@ -269,6 +269,7 @@ setop_retrieve_direct(SetOpState *setopstate)
 		 */
 		ExecStoreHeapTuple(setopstate->grp_firstTuple,
 						   resultTupleSlot,
+						   InvalidOid,
 						   true);
 		setopstate->grp_firstTuple = NULL;	/* don't keep two pointers */
 
diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index 34664e76d1..d9398ed527 100644
--- a/src/backend/executor/spi.c
+++ b/src/backend/executor/spi.c
@@ -870,7 +870,6 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
 		 */
 		mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
 		mtuple->t_self = tuple->t_self;
-		mtuple->t_tableOid = tuple->t_tableOid;
 	}
 	else
 	{
diff --git a/src/backend/executor/tqueue.c b/src/backend/executor/tqueue.c
index e2b596cf74..d3ef18e264 100644
--- a/src/backend/executor/tqueue.c
+++ b/src/backend/executor/tqueue.c
@@ -206,7 +206,6 @@ TupleQueueReaderNext(TupleQueueReader *reader, bool nowait, bool *done)
 	 * (which had better be sufficiently aligned).
 	 */
 	ItemPointerSetInvalid(&htup.t_self);
-	htup.t_tableOid = InvalidOid;
 	htup.t_len = nbytes;
 	htup.t_data = data;
 
diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
index e3b05657f8..a3430e1336 100644
--- a/src/backend/replication/logical/decode.c
+++ b/src/backend/replication/logical/decode.c
@@ -940,12 +940,6 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
 			/* not a disk based tuple */
 			ItemPointerSetInvalid(&tuple->tuple.t_self);
 
-			/*
-			 * We can only figure this out after reassembling the
-			 * transactions.
-			 */
-			tuple->tuple.t_tableOid = InvalidOid;
-
 			tuple->tuple.t_len = datalen + SizeofHeapTupleHeader;
 
 			memset(header, 0, SizeofHeapTupleHeader);
@@ -1033,9 +1027,6 @@ DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
 	/* not a disk based tuple */
 	ItemPointerSetInvalid(&tuple->tuple.t_self);
 
-	/* we can only figure this out after reassembling the transactions */
-	tuple->tuple.t_tableOid = InvalidOid;
-
 	/* data is not stored aligned, copy to aligned storage */
 	memcpy((char *) &xlhdr,
 		   data,
diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index 23466bade2..60ee12b91a 100644
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -3482,7 +3482,7 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
 bool
 ResolveCminCmaxDuringDecoding(HTAB *tuplecid_data,
 							  Snapshot snapshot,
-							  HeapTuple htup, Buffer buffer,
+							  HeapTuple htup, Oid relid, Buffer buffer,
 							  CommandId *cmin, CommandId *cmax)
 {
 	ReorderBufferTupleCidKey key;
@@ -3524,7 +3524,7 @@ restart:
 	 */
 	if (ent == NULL && !updated_mapping)
 	{
-		UpdateLogicalMappings(tuplecid_data, htup->t_tableOid, snapshot);
+		UpdateLogicalMappings(tuplecid_data, relid, snapshot);
 		/* now check but don't update for a mapping again */
 		updated_mapping = true;
 		goto restart;
diff --git a/src/backend/utils/adt/expandedrecord.c b/src/backend/utils/adt/expandedrecord.c
index 5561b741e9..fbf26b0891 100644
--- a/src/backend/utils/adt/expandedrecord.c
+++ b/src/backend/utils/adt/expandedrecord.c
@@ -610,7 +610,6 @@ make_expanded_record_from_datum(Datum recorddatum, MemoryContext parentcontext)
 
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuphdr;
 
 	oldcxt = MemoryContextSwitchTo(objcxt);
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index fc1581c92b..5fe0659dcf 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -3147,7 +3147,6 @@ populate_record(TupleDesc tupdesc,
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = defaultval;
 
 		/* Break down the tuple into fields */
@@ -3546,7 +3545,6 @@ populate_recordset_record(PopulateRecordsetState *state, JsObject *obj)
 	/* ok, save into tuplestore */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = tuphead;
 
 	tuplestore_puttuple(state->tuple_store, &tuple);
diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
index 5f729342f8..060ee6c6ca 100644
--- a/src/backend/utils/adt/rowtypes.c
+++ b/src/backend/utils/adt/rowtypes.c
@@ -324,7 +324,6 @@ record_out(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	/*
@@ -671,7 +670,6 @@ record_send(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	/*
@@ -821,11 +819,9 @@ record_cmp(FunctionCallInfo fcinfo)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1063,11 +1059,9 @@ record_eq(PG_FUNCTION_ARGS)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1326,11 +1320,9 @@ record_image_cmp(FunctionCallInfo fcinfo)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1570,11 +1562,9 @@ record_image_eq(PG_FUNCTION_ARGS)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index b31fd5acea..7bf2f4617f 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -1846,7 +1846,6 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, Datum *arguments,
 								MAXIMUM_ALIGNOF + dtp->t_len);
 		ct->tuple.t_len = dtp->t_len;
 		ct->tuple.t_self = dtp->t_self;
-		ct->tuple.t_tableOid = dtp->t_tableOid;
 		ct->tuple.t_data = (HeapTupleHeader)
 			MAXALIGN(((char *) ct) + sizeof(CatCTup));
 		/* copy tuple contents */
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 7d2b6facf2..3bd8cde14b 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -3792,11 +3792,11 @@ comparetup_cluster(const SortTuple *a, const SortTuple *b,
 
 		ecxt_scantuple = GetPerTupleExprContext(state->estate)->ecxt_scantuple;
 
-		ExecStoreHeapTuple(ltup, ecxt_scantuple, false);
+		ExecStoreHeapTuple(ltup, ecxt_scantuple, InvalidOid, false);
 		FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
 					   l_index_values, l_index_isnull);
 
-		ExecStoreHeapTuple(rtup, ecxt_scantuple, false);
+		ExecStoreHeapTuple(rtup, ecxt_scantuple, InvalidOid, false);
 		FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
 					   r_index_values, r_index_isnull);
 
@@ -3926,8 +3926,7 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 	tuple->t_len = t_len;
 	LogicalTapeReadExact(state->tapeset, tapenum,
 						 &tuple->t_self, sizeof(ItemPointerData));
-	/* We don't currently bother to reconstruct t_tableOid */
-	tuple->t_tableOid = InvalidOid;
+
 	/* Read in the tuple body */
 	LogicalTapeReadExact(state->tapeset, tapenum,
 						 tuple->t_data, tuple->t_len);
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index a309db1a1c..8dc1880925 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -218,7 +218,7 @@ extern void heap_vacuum_rel(Relation onerel, int options,
 				struct VacuumParams *params, BufferAccessStrategy bstrategy);
 
 /* in heap/heapam_visibility.c */
-extern bool HeapTupleSatisfies(HeapTuple stup, Snapshot snapshot, Buffer buffer);
+extern bool HeapTupleSatisfies(HeapTuple stup, Oid relid, Snapshot snapshot, Buffer buffer);
 extern HTSU_Result HeapTupleSatisfiesUpdate(HeapTuple stup, CommandId curcid,
 						 Buffer buffer);
 extern HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple stup, TransactionId OldestXmin,
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index c87689b3dd..b1d69ab5ea 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -306,9 +306,8 @@ extern TupleTableSlot *MakeSingleTupleTableSlot(TupleDesc tupdesc,
 extern void ExecDropSingleTupleTableSlot(TupleTableSlot *slot);
 extern void ExecSetSlotDescriptor(TupleTableSlot *slot, TupleDesc tupdesc);
 extern TupleTableSlot *ExecStoreHeapTuple(HeapTuple tuple,
-				   TupleTableSlot *slot,
-				   bool shouldFree);
-extern void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot);
+				   TupleTableSlot *slot, Oid relid, bool shouldFree);
+extern void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Oid relid);
 /* FIXME: Remove */
 extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 extern TupleTableSlot *ExecStoreBufferHeapTuple(HeapTuple tuple,
diff --git a/src/include/utils/tqual.h b/src/include/utils/tqual.h
index 1fe9cc6402..ccd81dff39 100644
--- a/src/include/utils/tqual.h
+++ b/src/include/utils/tqual.h
@@ -39,6 +39,7 @@ struct HTAB;
 extern bool ResolveCminCmaxDuringDecoding(struct HTAB *tuplecid_data,
 							  Snapshot snapshot,
 							  HeapTuple htup,
+							  Oid relid,
 							  Buffer buffer,
 							  CommandId *cmin, CommandId *cmax);
 
diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
index 1e0617322b..efce063ecd 100644
--- a/src/pl/plpgsql/src/pl_exec.c
+++ b/src/pl/plpgsql/src/pl_exec.c
@@ -7234,7 +7234,6 @@ deconstruct_composite_datum(Datum value, HeapTupleData *tmptup)
 	/* Build a temporary HeapTuple control structure */
 	tmptup->t_len = HeapTupleHeaderGetDatumLength(td);
 	ItemPointerSetInvalid(&(tmptup->t_self));
-	tmptup->t_tableOid = InvalidOid;
 	tmptup->t_data = td;
 
 	/* Extract rowtype info and find a tupdesc */
@@ -7403,7 +7402,6 @@ exec_move_row_from_datum(PLpgSQL_execstate *estate,
 		/* Build a temporary HeapTuple control structure */
 		tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
 		ItemPointerSetInvalid(&(tmptup.t_self));
-		tmptup.t_tableOid = InvalidOid;
 		tmptup.t_data = td;
 
 		/* Extract rowtype info */
diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
index a2e57768d4..76dff2a51d 100644
--- a/src/test/regress/regress.c
+++ b/src/test/regress/regress.c
@@ -524,7 +524,6 @@ make_tuple_indirect(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	values = (Datum *) palloc(ncolumns * sizeof(Datum));
-- 
2.18.0.windows.1

��'E\v12-0003-Replace-uses-of-heap_open-et-al-with-table_open-.patch�\�o�F����+
6�=���p^�����/{b{�
�I6%��Px����U���I��I��x�����>���������cC{<���`6��c������y�6z�m�H�|0����������;�������_A5����B��P$�������s����v-�����)��a��o��|����a�t�g��Y�����f|�������w��?`���h�/v/�.7K"h)��J��"X���q�=;����pEzwnw����x��������:>���_8��D���l�����dD�2����;�?���5��������>3?��{�J�N�D����o��]����?b�
R��:�u��.JMJR�������F�f%��2����>jz8(K��ED�Yb���:,���H�D�=��z���X�����u�J��L5�P/��A����py i������"����0
�P&|������#t|���y�z��^Y��-���u�(a.��j��x�K�q��u)#�(���S��8�IM�\���t���]@j�xE��T��������
������I���^k'h����'#��D��B�����Z���cGf=�2���/�����E�vU���u�������+������
!G��r�n���E�F"�_�e�����a3F@J����c�@��Wg���4�x�\.��I������'�5���bm�� ��u���l���u����
�j�W���.��[9Zi�R�V�G����.u��*o���n/b��e)�����,:�n��w��L����:��|�n~�&�q�R��D�>��G
��R�)��
R������R:���=o����(��2��ZF���Y�:�0Xkl��}Z)��X@*�\V~3�����Z\�.NZ�h�p�~��M\��%�Y�s��Rk�
A�}`�����y<���A�ryi�����}��h��u4Z��"g��F9
\�I��]�$���C�A�t��;"a�&��� �sI�f��V������@1>����f����3�r��8��VO-�S�-}��A&5nc�8<4W@�2�B��Mf��6�K"]`��?O�L�y��W�Ga&�l��-�����/I����z_-I��w'�,��E�'k�T��W�\�\�P��O�:Q\��V��w�2�r^�U
{�P�|��E���,�����`MKR~`��i��(Ii���\�$�CW'>�qI8@&G_� )�z=6p���I�	��0�Uj�D��)�
R��p����1x%q��T4�����:��
���II���8�h��3�U��a;�(�P����C����V�{�Ob��*R�z]Zq�2���a�7;x
�
�1U6g	kA
.�OZ� �KqB����o<-��I�U:L��D;%�*�9�f!O��\*t����5�J%�Hj�����T$\�R5��&;�5%��#*�����B�l#�L���H�P���J)�F��.�W�p)�K���!��h�kl��f��j���;1q#~�!��R�H�����0��id��>(�1s�KVe��:>D
�������g	W�[�����c���x����l�x0����������{�io�����h21g������F�����}H3wh��g����3e��n��:� �������c�J,��2��e	A�TN���m��
�u�����	��� �
��'oD|���A^e&��k(��[��~���@���Q=P*������Y���:^K�{M��lO���KA����
<����I=t����jt�H(�T��*Q����������Q7a�������}0�����7p��h��N����S���z�V�(���������
��"^�?����1����b4T0��t��RP(Bu����	6�B���������{�~�`q�"���vqxv2���X�'�3[#�VN��u�����Yg�H�.>����f��
�
������� �������5����������;�(�HG���*�?^��p�!y,����3D�aW�����:�S����6 ��E�H���}�`�El�t�WW�[�c����;%nL~@���48yU��Q,�0��� ����o��a7w��{wq�y������.�4����=��5N�q�x���q�
�G�v�-4q�5���qlGX��b7Iuj�d�r����v.�+���\�Z�v�Zfm��@�HO_�C����������st��F�S�=sc:��'b�!`��e����6=���)���Bd4$���HZ=d�*�b��I�����f�)���v�������X�����]�Tx'$Sa!��LK���7�Q�����z]�����D
�\���$j��0$rd�^��c��n��J�,
<���M<`�C$l�n��B���e'4��|�c��!C:L`��<����<�6-�w����v�'"���AyME
��b�OTaL�]b��*VT-��I;C`��nX�b�+0-;8@BO<(kx�;���'p �$�I��!���;$U��#T���U�A����W_�1�a�6�lh���q@L��c��lm�����6w�S���b������4�J�x��
@�P�jM�|�m%���-��T����i������g�����T

9�M���7���,����~���]���y��9��-�{<C	�.��R|��Z�_>���]\��^�<��?��Vo��)cK
e�Ao>X\��Y�k'3kd�vC�i��b}!�A�7�u�}�*�7U������(�������p_�f����cHU0k}���yC�
���@���X2����2ef�H�����5j`�(�P�`�T�n�
C���GHn{)��\,���VRVNZ*�0��@$�)�<��VLy�����Q��R�@es��e�	c��
:�6'���(��]���j<�w��7W��%���[S�����*A�����&i\��^���0��E&�G��k�l�@Z/���X*���R��A��9�h���������}�����*��Y��\�=,��_^]��A��L?����r�6��������k
��������
�7��<�%��t�W��@�����$��k1c��M�q!LF*'�*R��r>�Ft�N����
�]��HQ2Yw)?���8(e&Y���8�P���w~4D(������6�A�G��LSA��\=������_�^x�Q"
QL��
���[9w�
��T�N���,��w��l�gCn�y��h[}-A�R�e����+�C�R��DL��u����K�;Y��������/�9����������Kr?�����*!�s�
��h{B��#59�IM���5	�}h��������:
s�u�<q��aB%G���O7����r�X^+#�p�*��`��3� !/1���@�%��x�n���
/����2v���H=��C]_�G�}MJK8YPv|`�g���w�1I<��8J�q�B��kP����P��l8�f�75`�gF����f0�����2�i
��������*�H-P�y��u���L��q�,dGV,<�c,�������1�Y�!T��C��@�O>�H����H�?@��}i}�@����{����b����C�p\�L���<R����m��5�M�����i6��wb�>mk��g�A���n�i��u����6wE�6�D���������(=1XG�z�\�?7!��=CH�������jw�����O�i�k�m0�C�*��zA�&��d
�G�X�`:4�:"~��
����������.�(1�����
��/���3�$��+?@��F���4M��1+	����Q�Dz��d��AZ��h7��a�K�'���'���s���W�q7��z�5���\������������������{ou��
���h6�
y��G��������W��c[=D��)CO�\�j<����{%bHP�wS�	�7V ����!Y�E�ZB���D8���<9�����
�A����a�mYZ��v�|����u�
�����~����!`G�]bi3���X^^�����~����9�����rbz���M)�|#�pK��tgUm�j��������D�J<��������\N�d�P#tD@L|�D����A�Zq�&5�	f������g�V��i\��0�iNF��d6X>
GD4����P�=��<����>e��@���������J],�����������^�
�
��Q5����}�L����%���Z��#�5nR��73�Y:�}GI-����W��^��<OB�6�i���Y�� ����oP�_�P�a���<�p��9;��Y<���0?��?/��1_z����<B3�����A/���>LqB����q��l���6�������.,,O��4<�
��ez�������{�C����+�T����6�4�-���j����^���W��B)��E�S6]w?��_��x��<���L�e'���I|���L�B}J��E��b����)9�_��&*W�p���2)�����>��,���Ge,���a�'��~&.�^zr
S����d{�)���������Gdd^b�>�U���b���\�����`����+-�)|���A�t)(�Mc�2Wv�t����xm*#>���%h���
���MGSj?GS�r�G�2�x`Z�	�M8����5�i����Y%�L:{�� ��"A6��f�/_���E	�n{H!YQ�X������_0��FF�M{�bJ�QrN�T���|(O�}�J�3��iw	����^^^	*;��_X2�H��G�l`�&�A�b�7&���ie�wKU�5���r���!������"6���k���:r)���/��);��t~����"?D��o^e+:h�;��3�����c!��%������e�������f$��o�����R9������AUk���v�,�-n#�A������9Q�����r����
+;���!7#�s����2�|����n��?�-��G�:�N����_��?;��4�����[�	���������l�����=�zpB�����(��0�P��i@�P*������O�N1������T8m����2�%Ro��{r�x��6�aEQ�y<%�;�!����vqvs�8��A��n�\>�73��`{�o�����������|F�^S��K03ynl6/hp��\�@��pNVA�[~�c��-����������5�?q���y*Ll�l�E�������<�>�c��W���?|�
��"*����������b@�o
���Cz��tH��=���$�o�^nC�����f\�K_�D-
�_�/��K��:��j
��Z�����\�S����'�-�� ��E"o:�',j����G���������ok�7i��p��f�XwBT�G1�-\,��cm��x8����t2����gvCV��vt���
��@��
�	Qz����h\�?�
�	�e��C�TRG��)|�������y3nH���TM���,��A��*[!����Q1�Al�T�m�����6�P���O����kD��_��'���d7d_e[��r� ����m��J3�z�pu�����s5���8���R�iQxt(�*/�^�=�,��a�;�kZ��Jw��
��l.�U�:a��a��sp;H�+<������[�:���"r 8b��L���x<�c��9QS��*��z)��x�������2):1n��/p����|�P]?�RX�13%l��-�5K5^�X�r�����:�fj��'�����������$�[~���:�#sx��7��%��wl�#����;�$@	k�`��v6�����
7��Nvrf�l4�����u�����)��9���V��
GS�!_-�c35u�������G�4��	�l�������������J��B5�G��o�$��]�}����[���G�G� ���N�F�
����Q��D�RA\�O����xB�on��MA,ff��<3�
4�v�W q?b�49&M&9����XI,�#>��p���h�W��SX�����f��u��C��J�-g�|7����6J+�\�nE�G[�i2|V�k�k��Uk��d����IL�j6lN����_�F���q����\�hQH
]c~��������y�M��hP�Is2mw�F�Z�&�~���{����u����u�%���8���Fc��n���%��`Q�b��-�$��'N|7\<q��4����%����,��0� �U\iY�8�^0��|V|�YQ@<���2�:
&J�K�����}B
��id�s���V�N�mM�`�}N�������'�/���R<���z0�|��|t3<���"���L�"�.��q�Q<I��x��R������4��z��o�;������~�o5{�K"�����n��85���k�;�=��
�
E!u�����������)&�g��|/��.�Lr9L��I��Y������`����Y���8��\�:=r�E�~�x6b�������iU!���0�w#]��a(|��A
���@��t�ll���lp�}�y��=���hg�1��;�R3��/��n�8����s�MlS��
R�`D�|����:vN������������
�G�N�������������d&�Y�2}T����Y�X�e��q$�P��UE[�}�FPL*�\N�����?�������]
	�Q^R�Mz���'r��)?B����)�2����V��o���=d����>E�h@4	<N���+�~zM��,c�t��?���#���*V��oo"�,�pZ�<�����D�����9a��x.$�� �����Z��zaa�~�_��[�_��	�,�F��O� �Pq��P��
�I[�4������tD���FD	���nT{�E0t;�����z�l_����fPCns`��g�]F�`����8�
u���� ���������'��`��95�_���n������5m��V��oV��I��5��i����:J+9�&��%��P����bq�1u��*���~rWJp�E��0;#�.����k@B�M��:=4|���������������������1OM��C����2���0	��~�wd	9q�Y����������z��w�|y�-���<2
H�
#��a5�����rn�8UTi2���r���?����+��������&_e�����Nk��u ���0��.�P�$�a)KL#���[�;�CW��
 s"�����\0����yI�KB���pegAtB����������N
�XOs�W$� ��5}C#Nj����c���58^
�y����{�1��M�D�&-;�nG68?��.d�y,�+�~�F
��B*�=j�9.���d*?r����#�fBBzE������Z�W����:h�8JT�(v��_��>{�3lI~)��f��j@�����6GG��!%�8�������b�y�����>�'M�������
a�~�uM6�5������|��DF|5�Ig���@uxP�|A�Q"9��m��l7����\C�L7��S$��V�k<=��/��:"&���I��x_
>����(#II%��k!���|e��+�S�l��u��f�]L�UMw��A�J��k7�96�g2J �|��/�)�6���N��
PE�����`V|�z&���M����; �&�&��2�Y�dks�CT����M��85�)����
���$�r��5S_��O����B��l��AO]^��/^�8�����f�
������tx���fP��Y8`[pn���`�F������������]x��&���5�W��d�W�?p�V���5��7��h.iR:6_K���b�&��i��3� �v7~����$�\].^_�n�?
�7s
��~S��-x�E��|���_���
�W{8��%���
X%�������������h�uqG���j�����]��_R!ysz�����"�D����Q��-x���A�nG���7�����H�[���E���������
9D�+�;��+b5��.����d���������uk�~]�������6B9N�9�q����I2Q/��#e�//H�5�E���$����Y�|?�ZCb��/����fp����h��7���GJw�����$t���_��[�%t��_�?����3�5����[���s�Z��_�z�Ny|�3�\��6F��������M����0�l��:��������sz�d�9��Od�����i�}��N�%���hGAT|��v����n���O-i�^�RzEbh�����k����`..T�,NX��
��S�����9��SQs��L;lv
�^���������z0�^�?J'��f����O�(|E*qc����"}�<�c�sm�v�V���S :s
�I���p�,f�Ay0�����TC����M��D#�����,g�A0��l7zL������F�G&�_w`AcBJ0aa���� �A����X��@�w��
{���}/I���V�A��� �m����N�<�gGA����Ec���m��&mi%y���\"S�:�K�S����Fnf�����Qi��w�wT-���Z�����&Y�(��5�����q()X`
�����HL<V��L~|fM���!�x�U0��%E�������e]��xb�;�z�Z�����^����F�Qw���9�X��Q���9��9 y�
�L`/�_ELTn�������������Wg�������Oo��fq�V����������!�?���g~s��)�s!%R�6����d��/r[������+���#��y�k�N�,EB���98��X?�;����:X��!�'~�
z�������O�4�-���b��|���/&���l"s��fo�7Z�j����}
b�Vev���fd�`[X���g�AQ0�T���</Bt��@�����}�e8y���L�{�2��u��C������tI��*�G"�x��J��9u��`Z�����5��x�u*�
��q�QwZl%n�`r'����x=�_���\��H�/<_���K0@�\�[�I!/KS:Y�����B���t�K�)9_��r��[���b[Kj� ��X`
-��&��4%���-omr�q�}5��_��`�3 ��T�4�*�A��@|�J���xn���
��[������������������f�\-X�/\_�Y���r7���1#>+�m�I���P-�c��[-��<u�
�_]]���p=��<{}-��7W��<�g�d��R���!
�E��J��
�`a�P#��|�;��>�LV�Z|=<Y�}�'�A9��#t�����l��k�������n�G�P�������d�]���%��9�1+nw�[��t�Xub*��������]��o����[���)�s�����
'�(
R�~�Q�����Z�����W�O��w��+�����S��:�@h#KZ������.y�����e	�r��m"��{����8��d.("�].���.�����;������'oIl��7����D_����T�b��*W��h1|����`������r���bE��(d�mYT�F�
%Q(��$��>/������h��9�ML>dw�uJ���p�Z)KO(%?�}U�����D��p#�D���$.��1'�$�:`R�1��$�����y!f��x�Y3���2v�\�_%;�h^�g�yp�����vV���[�����/bGV�b�J�q2mX	���X<���,v�yMwbm��z��eS[,�"�Fd��\[��$����C�'W+��F�+s�}�h�9�S�;����������:r��|��e
-6����?*a }i_�($����&w��W�\��s����g&���NV��^�B�[F�4��8������H%���=~����Y�@w�%t����$TrG�I����$^�=���B*K����W�u:���#���)1��8��ZY?a�x�X�S�����r�og��L���M����v����6�mb��
�����e�����y�Ute�=X
F%JG���].����JZ*�F�MOq�h?���9�������C�r:^�k@��lL������t����T(��[_Y�,1*��M��������1��V�U0����3A�K[]��s�}��O�#}�uK�!0�x�4�o�y�8G��`�r��!
�B`�����i�,EJ9�5����v%����[c�%������I8_��`
����B����&�zF0nS@P��Zz�����yl9ITj���k������t������z�v���L�r_	�A� g�}�����bN"l��5������8�Y���!��L�d������zJ�[�������XW���S
@��Hh'V%�f��'b���V��E>b�uI��8x
0�o� ����_2
G���������jI�A|�'bg�X)#������
����Q�d�JK�'��m��-����i�I��9��Z6��RL���v����
g�c��8���O��ED�b]�q+x�\ ������\fSp�4�~�vt��-����
F$�	�M�G?=�����A�1�TJ2s��^<O���A+��`���&u������y����������,��X~
�����5�I�S���dZ��j���Qk�p����x0����H��'bb��X����i #9��3:Rkz��^�����5m�,Yx�����U,:)r�~5{S��-g=��h��b�}��Y%%JE�m�<��I�g����P�N<f�3.��)�ox~44k���^A���;�����<I�������q�]�Ye3��6Q6eC��r�����@���X�S�)xrj�+SHC�G���7p�����'�x�D���p�OKxk ��V�
!`�r����	F��2�Wwwb)rTC�4�pX]%�n���z��j)�=����m��e0�^�j\�[J�ZO�N�A�AG� ����J����Q a�P��i��X��;������c��;�SL%�vNo���*/�&��|'��E��a��������F1�stJ���
�`=(��-�U�����KNN���e22r��9���9�c�*��������#��+���E���6:T`�����~t�C���A�'������6&�H.CO�+)��Zm4���4�fZ�����CL[���<������7��o���2��K�
i�	6�Q?<-s��pc����X��]������h��7R��Q�d=?���a������Y%~'9�Y���}�a�*�0)��#6N��w�6�_�8R����Q�zH<��:B=����60��L����l�����v@������W��a��D��4`����Y���C�I�c6r����*e�(����A���1�Lo7:�S5�Z*�����~��� Gb�S�:^�U�"8*
A�~������8���cP����sGR���)3�\x*T7�2T�B�9U=N������(\�`P���&����'�8Bur>�������J��m��p>VF��+���	�~������'�4��(y�s��K!(�@����������E�3� ��'6����8���Ku�lv�-.����y`�q.�E�_�V����������5�����=p��^�%�\��M�a��\*g�t���\�w+8<���P�b�l:�'���7��O��"t��n0C�W�]��3E����TH���g+hYp����]6�
tpC%P�0UeP*����,K<:�C%�t�1�*���-'#G�o����{n�|(h�f�l�(��������V
���m��	�!e�h)�^K��w��t,����������Q�����3;3!UK��x����UY�g�XU��rn�����o�(���HdU�
K��5C�u=�d���K�cUbxze��r���h�y����q���L�d���T���>P��:�������og���"C��q�f`�G{��
|DU<7��(������
�����������c[ -�\I�mX5�#m��yN>��)�(;��*�^��[I������]�������"_S��%�|�+��`q����o���y6�13����
ZrE7��NyU���#�"�
�>�w�r���]�8������M�%��3����J&�9�l	8VR���yl��	�Hr��]H�>qT�f9�7���:�l�)jj��/ ����G�>�\C<�4��\j�'�c�����\n*"�����n��7�n�>�V�O��f�=-��"��OF�-��K�%��8��\2�W��,L��-������I"C1��T;�����Y�2��A=���$/��PZL�EDl��O��j4����Q��t�c�<�dq&p#D�d%�����,��X$9�� ���3�T�9�V+l����x	1d��@|�x"
�v$N�6d��������
������"�iJ+A-O�]�i���&���I����b{2�������#�N*++���'������9R����W�#6���S�G_,����`4�?]-cUH�N��/l����J��P�1�EL/�;��<�M��>+�0�4��%������ �����7g��
�d+����R|Hu�w&�=�T��>���;����%� ��K�ge��E�e�����B��R���E����']�����B�h���3Op/��o���n�@���1��n	S�}�!0�G��*�|3�q^�3�jM� �&��6Ra$v��+$;�3xA�z����{�mb�a��R��Z���^�#����jr��T���*�L�`�����
b���m���B�L|O����u{�� �Qof@�|�aN�H/�6o}A���k����{UE�#���������.�G�5�[d���Z�<��Ag����N�8$Z��e���-'&���t�A���������=�Go���2<}=�{
�(�%<l����x������w�	�f�gH�Dj<���a����k��62I�|K}AK�:FK�m���;`:�8_��#h_�b:e��a
P��;#��b.���K4'&����W�,iaI��V�5�8�Z�W�p�J3oq/��]�Bh������ah�]z&�����$��L��f�p�D ���;����o��QT��p���1����������;-N8l5w����2�X�\�x�aRS��a�����*Vw��	�),��0K�������d��n��Ru��:�Dj�a0 
N:�T�V���$�������)��nhM9��Ei�z��#
���:������n^Ot�Q������a��A����$'��7G���}���sTJq����Q]����$D�{DEs���9�e~(�ee��
<-t86dt,%� �m(C�i�|Uc���)��x�����<9��
��0Z�������
�� eg"�)
�
���4��#��q$�4kI:F���X^
��k)b��������mY��9K')���������
ULM��lvZ��0�����O��j��uP��'Y�����MU�MD���JE�UX��+*9����������W3�#���Y�

o��-c�u��sw-�n?���
h���(�%4�Ln���T�f�?qt�x�8�%��g��j���]�-+���5os��v��c�2�!���h�XV��x:!{?^�!�������W���w1=]<T����<���m�T�	]	�jr'6�{����sW�f�Z^�/�i�Qn��v��������E 0��\��������
L���-�f	��8�#0�C0O|�3�w!R�j��`����M���K?��>
FC�`�K����*T,�X�G�:wq��DVB��ljV}Q��[Y���mi�Rv%=��T&������A.	@�?�x�����y��f�e�5�/`�@�
|������<��J�n����z��8�Wd��b���)�q]�GV��7�-�`�zblb�!z5���zX2���_[��������JWc�rI��&
��k[���$�u���9��@�C����T$���!�u$�����e_�� �����Y9)H��(� O�
!�t�>��/5]��.�8%��� ����/p�0�V�6q�Z������QA6��L�,��������`ty5�����z88O�����Mh9f�
�#�o�2\O{���������H�KWw28���tX�5��-}�:���!
E��ii�z��G��U�X�a
L�:#��%1
Rh��
�:l�� ����PG�n.��X�h�
v^��7z�����V��NgZ�v���9�.�_~�]�%Z��MrH�U|%4�D�8��B�s�> ��8���0Hx>	1;1�<Ub0�Q)_�B{�����8:����UN���@f>rq��GE� �'������������9�x�
?��$������=<��a�����PB�b�	��3
d�6����KN�b|(5x������������m�<q������U�� ���40G�I�	�C���9<6u)���D?��](Q6UT9:J���w*���\o��a�;:�/�Y��KSA���y�����f�^���2V��Ux���������S
7.�qWTb��D��?�':o��M�@E�os�$L.�l������q�����������;$sH�G���s@f�p��������e3���%�Q4O��x4���<�y�SE�"~r�~2(T��6����f����z���K�Q1kb���[�8E���ZA�47��������wF?0�;M�p�a�����^N����E�-H�*��/��y�0
�1HA�|�h3w�������<�@�By���:�3���9�M2�6����Sz�)���S$J�JQ�\n��d���pK���7Z��1�(��iZ��REI��[�q��R.q�V{J�E�:%w�u��T|A�
���/)�@*�>�����Wx$�J1TQ�|vj2�E�0
�`��[�� ���	Z��iH]�`'�v��J��;��Lv��5|=;�c�������V�9�$�U����2S�X��;U��
;��(���"��"^��4J�t����X�=��J�����Le����81s$h�T�G"���S���Vj��x��u.s�Y����R�,�Y0AL�9�,o�]
��~]�I�����l�!� �mV�{*���1h��q�O��9���V������W�N� ]�W�DSQ0}`�Y�������gXF�����1���[P!�x��`:_[��B��A,m`2A�d���c��rH����f%�@.�w����{�f���q�������B���d8�.�>���[�g-�G(_*�6�q'����%��"���V��|�WZHM���������S?�`r��*]��0�}�
1������;C#�����_��W�cD'�z�}��lp��N~��z2O�u�^_oh^$>�����1f ���y��y
�SaSaS�k�j�(_M�~�i�����O�1Q�x���:�ve
��evdp��U|�bJ���|/��-b%��C�#���nc�}gO�b��G��KM���tK�,����SGi�vS����%��uR���
��T���Y&B0���l�n�	3���@��f�������-��[�:	u��C���
����/|�|L�[�X�:�?��/���f��ty��}�\��$,�_��z��cXm�����A4�u�����4<��
��gj�Z
E�[/+9���J��[���L���%H�%l�_�I{���,�v)��4��J��bg���������>e���  E�&w@H?����5J>��>��:M���|},q�qeW&��8����F[�7�"�_�"��]F��:A������=[����o+���6��zQ�Bh�do��mR"���n����	��R{����!�����h<(�xz��6���w	L���`h�<fMA�A�J�o��`�ns���S�
u7ZH��?i4&����V;
��O:�����n���n���k��[b��������R�s0��K�7��`��>X��F�D�;_(��F�+��L'V�B�G�a���*�g�����d�8��U��."���s.y������� �6���o��Po�N�u�;���
P��$����4!	|y����)���Z:���N|�n�i�s�"'�:?�i7OynSS"�m���v(�2��$)zH�Q�=�k�b'�}o��_�K5�r���K���o�#�lx!�T��*E��E�$
�"
�kj43
� �$lt#]��������n��[�������[������F�
N�~�9��]�]�N&�^����^�
���`���w��#�xO��g�i3���kB>_}p�
[����*i�!���R&[�x���w�6����:aU�;B\Hw�z!#q~
��?>�\��4��"#:����)Y%�E:(��.�o�Q�%���5���xV�n.4Z��L����-�����W��.Pj�?��i��\j�L�'�����vw�w�n���T����v��~�Q��@���c6De��j?]�g���{��H�	��d�:�dy�Y/���B�����Y9�:3{Z���p.W�f��MV9��!��8X�x�O�i0y.�&D�J5.'�s���s
f�A�aE������u1T4�_��Op���`�!1K�@ua����d��P�G�1~����1i�����������78�
��DlFD�	aPZ���t��|�B����z�1?d���
_��T
����y�n�k����zH��^>p%$E�+:�������d��'%KJe�|��Z��iL@xl����������~M\�S�IN�R Nz����Un�Q�w�Jn3����;]q:
�Dm�����?-���m�g��@z*/(��r�1q���O�&��{�@��Y�!:_�7���#@��"dM���\K;����2��ar)��|xBpg1���f=���h�U�NS�����	Q�`_�-)��1]��c�3fB(��m=���g�b0�`
2.E�B���G�N��rMN�jY���$��2�T��H�fn�{�;�d
�J*�U��[��?�T�w��u	������'9�[��jf�������y���w�"&j�F���p����l�y"=�����Pte��"�������
�'�7�4����F�}\#Nlb7�#�z1��uf�8�9X��PInV�����D��������K�v9�.��(^,#q��x|��'�8����z���[B	E�F�����AqP��a�t1M9xC�\\$2/VE9_��C�$�������*�>;�z��(�t�j
�.w�����v�{t)ET�,	�m�1 ��k���.X
D>G��i�n��'�rq�Yk!y�@��I��}O�J�(�R����+TO� ����L��Y1�=B�_Kri9���(MZ�c���2��*_���f���6I+�m�V��K��#~��B�plD�5;�u����0N������k�b�	;
�)Iiy��I8����
9k�/����5�&��U0s|9�:��,U�%e*2	�N�� ��zX�A�C8��fYn}�@��������t��\%c����%�i���������������=is�W�_�z���5T��
�tz��h�4���V~����!so����
��g�n
�-��+����PC'�x��#��g�e�L��q'��C�K�������e,����t�����S�E0#��Zn�����
tS'������5%v�f}'��4��~n���M��mf9�m�~���|���7�&eL*6�!�����P�n���U���q����W�����A�����}-S���2�Y��@��QQ�^CG*,�D��	��iU@(kF4�t��jd�tT�rr� =%���}|
_��&	����WM
��j�'����}BjFG��cV���-�����p�F��,���}"�2�a�ibaf��"�x	I���4�_Akq
s?��c��3��k�9��/2 #bxu���/��u��4�K���+�e�q1n-�>�,}5�W�<@��A�O�������K�_�����~�S������`5i�SH�|��z�\��%����
���z�E(�t=4m7�4z��o�fy�@�f#����5�\��M���=��TdH$���^���E{�<�����-�����V�cU��J	E2:�����&�1��Ag��D�q��Z2��#T����[q$M�������u����i��n_\�F���6E�����������?g�NZ��(^Sv��)�%����fd��e���:An���}IT��5�]��v�\?�T-g;\�9i �W6-���#�da�F�k�u�
H�����`����$2�O3dP%��yc�nM�Lh���1�V���������<l|a��o<�Z(��ZJ��L5e)�O'�v���z�j��4[���&�������ts+�4��a���8�73vc?`%z��?�Q�moVsq�����r'����g�	>
���x������p>��Cx��ka��3�d3���*	�-_
w#v���p���
������|�W�*�:U���C�@�0�����(b���TW����>e�L|�0��<
��G��AA�b2���:�2����@��]�(��Gg�d5\et��$����tT���2����v2]!���[������������xm���7���+a��*t�y���u�E�&a��]�V���t�Sv������Z��0\���D�0<����r���A�C��<�����i�m�������y��vE�_(���v��b�A�?�����XaX��R��]J�>-�CT�1G�rG�uA����^��ohl�0�V���?�Wz��8v��!�G�4s�0j�[8���%}���$�,�"��D3
WRi"�9����;���y��Xn�sq��e�������6�����tw1��.{�+��f�R)j<$*v���qY��M�_�p�����&\�l^LA
�����
��K|�P�#����b;��N~��nH\w�*�w��Q�+a�V��m��uU>���T�GV&�>+=��Wn��9����e������d���d��o�/��1k|���r.��{��8�����K<���������G��y����n7�P����1��
�f����nx��������P���dG����>���+Y�����nF�7���s�4E*�o�qAF�@TZ��]�B#$��aE�(����&�q�MX�rT��p�o�9�@O;eHw�����~�JQ<�V3���gk��MT��R�F_j~S�e�M�|���~gCS�;����q�;�Vk���;�Is\���=���
RCJd��@������4�����qpT���;C���/�p,H��N��0Z�A�!�&�<?��J,�Y,	��x��7,Y�N�eN�hsuq�!���ocg���W��B�u���%Uh�N�����8��<�r8`�-�h���P��9��o����E�o�D�����aS>�J�9;�
[�9l��l������rx�7����7�u1(���\�/����~��5���l]��k�@"�*;��B9Z����F����<,��O��M5Jdh��1xL�������z��G�SA,�>~<��rm�;�$����F^��=[�bQn����dk�7��|/-�t"l���U�7�1��9{n�|m����[��I�������"E�i��d�>L�Kd����W�����N�
��o|��Q�l�Q���(��(O%�i��/���Y��[�o-�]t�_�Zw<�����V����7�n���b�V���(��2oh� 8C�(����d��F�R#�������:�Syz�*(6j7��M���*s���B�`�8�^������l�����=S�>=d ,�J���,���!o���Z&l��>!�8�0��y�����1�8��VAN���h�U����Z�5�/�����+!����M��@��gRk�z��>��;qG:�TW60���)�Q"�K2T$��g��
\�T�.�j�~��ExAg��/�}��8�
r��x}��gl���4K�������k�����d�lJS&�)%%^	��l��1��6�z�9����e��}���������c+�SP�����j��;�T^T���>��P��q@��Vw�	�F0 ��3��B�������8Fu��|/���:�U��T���xN;��T*<E8]�[$�18��S�O�7+!�n�4�c�d����F���������d"9���N���o���t�J����p�
!��,e�;3��!���XfH�,#��k	nSk�Jo�JF�����+i���4)��/��A�W��� xR�.)o�`��V����������t
Yzw+�t1nO^���J�l>[0M�;2����f�;�����	�^������?�V��fs�����[�L`wXx,����q�O��7�;�+�1o����#J;��Kw%���t4�W.=����|�����<�Kk�/��o0�����>cil���S��D#0��0�B�e�"���o\��Z���Wx����W
T�qR�9���~yU�fw��S�]�D���*����b���>���_���Iq�RL��������
7<&SZA�d��K��A��4��������a��\c/�|gP�(E�����R*�y2�0�SU"�����!���{��/+��F���i�M��v��j�W��{�zs\�����
wE�!���%Ms���2����R��)�$�
��?_��R�e�B�a��W�Z*�y�B}���eo73��]��Bj8�2<�r�d��������
�W�n�gE-�k�RAe���?�����I����V�n#
�c�����]���M�n�1n�'�R����p��(V�A��,�����;6���5���d�!�J)W�&��Qj��g���${1J�n�u��0�`�&Ja�2Uy7� WR���X��
Yc��i�}�m����o1kopc����,q�$2�B�|���R�>�2�����C�E�U5�	V_���a���	~���&���b�|/�f�	��;�j<�Yb��N�y��(
T��$�f	K���II�T.��.?`��8y�@�X�I�5�$;������u]��\�p0b��x�����������q���Gtp�� ��%E��Y���a��x��5�1���D#�*g�.�����9�8�{�HTFBF�V�>�����sfE�����i����6�����_�@�@3�A�R2nW&��Kle������E�AGz����6z?�n��)XtR�M���I4�^�o�z�^�����Z���;�4	��P��6���@�����Koe��K���AlTR5����O���R��c����
T�{H�C|�X>�`����c^��z��+#��){��^����o"p�s��X�7��������*��N�I1��([,�����S �3�Og�L��
	"^�'?
��%����)8f��v����,6!CJ-��xLH��)��<�6�����S�Z�w��F�]�6��d��W���P
(m��NT����<G!�1���������O��qt�a�G7���CE�;,�m��
`�U�������s�f��(�L��	��`�}��F@�C���M>`B;��l:����/�����������w�A��k�!������O�
L�
�_v�e�EL�S4y��zQ���,��;)3]g%^-*O�
���d��|�npy>�<���������X��No�DL�EK�L�Cb8c�B!���GF�x�V�� k�.����"����4��#��^&x�5Y�s'��)X�|��q�8�.�B���L�r=����{&@��I�E_!��_^N������@��e,��Kt�D=������!3
�h��1���l=��`���p{�@�3���>�p���h��W���2�X�W����Y�;��	��#[S��l$��_j�����zj�������@�'�30�"�d���"6�y�fcf��]��
<
V���<�������	����F��J������2�h�Ej(7�V�I��mt��7�Vk����OZ�V)TvU�z�FpC�6 ��rl����77��Pe"�7�Fm���"�}R�/f3.|S��!o5����0�s��
�T1G����><6���:��I��T������o�l���O)g��oj�bQ���*�L�*���viX_f�7K)�|-n�T�f�3�e3��8���G��f�0��������Z}<
��Ccw:��j�NFo�r�hG��TyS�RP&�����aqF������geo��NC#%^���0qc���w�$��'h���a�Tt?�P�!��!�2G){�����2��Q+��U\d�����$����I�\-t�$����W��<�O3v������S���1e���xz=8������k
 ��MXhg�0�����b���~������5�HqL��O���e�#0N���'O��df
��"���1�*'�%X��p�����������Eyo|�A{��A��
����c�=�ou��R�}��@�:�cf%��1'p����������|K���5������Oy.*�F|���s����`�[J��	IZ<V�Xh*7�HH���4�<�N�"N���-�S��h+n��H(��4f
�<wZ��iW^
S3���X��4h���s7��,k
p~��Y[b�2\C��=���m���pW���!p����pnIe#����6_���=�9��w&�����i�b���-��\�]�����E ��T{?�2&���^.e�|j����Z�����L����	�c��S�)�w.Bu��+��[��q�q
v�r�;[�
��e]N�/
���O�o.�?���k�0���h�I��������7��oAWF��z��zj�z����V�/
����}_����].�##5q���<>A����X5�P��������/� �S��:�K���n!�]����Q�^W\��o
���'I��B�����$�
�Q2F��w'w��3,|:����Ay�k�8�G���2�w���45=
�6����s�����d�vgi��1��Joi�p����N�t�������xH�q��KV�|�c�=�7��qAWI�k���E&�x����k
;l���6���Z�`�)SE�D����z�<�a��p�Q1��;�iY�����/��!��;20&���>���4,��Q�
�B/���Qa�w��`���=���Jv/I#cYhFq�/�AW��6���>(�D��C�4]w��\e�
w�,��������p.�[��v�7�a��o��n�[�[%-�v���k�-	-�o��z�:yc�d5r���$��7;�>dk��K��MR�����\�.�\��H��{T�V���.�M_�U"8��mnV��S���F��8M<���
�f��s��]��
g{�	/gaF���&�����R��������Q�y�������8��<
���M��rv*��w�eN���}*���\sBJ��<*�4��i�A�,�;�������Q��l��	�b8{�w��y&~��P@�� �l���[0������?�9����/
x�M�D���Q��2�6Q�=4���2bu� ������*�����+�/F=����������}H�.
Eu�����43��L#'%�`���s�+���9oJ�q*�c������j�}i���~�)L\��Z�N��:����'�ZG
�ZT����cJ#J7�Q����
tXd(�_�4K��F����������sGq�x�
�:�-H��B?st�Z���/��/��5���5�z��
��m�w �W2�e���Stf����>�������z�Zm��z�V�z^��Y�{*<�st����-������h8���62L�9	���P	�w:�7	Y��h�mpp�����LX�$�>����1�'�p��0��HX���\2dR
�\�dqs��]�%e[
-tarQ����%w.���?Q@(����5%>8�0���n���LQ�������>`�����OK��[��+����	@����xq���W�v������
������,wF�,*WN���I&^E�t��������'������uB�����F��*
�r%��B�����7Xb�KAA7������&�yLw��9b�g�Dy���<#��iB�����H&�R	2�%���cP:�O��L�N�@=����AX}t�43��p�"A�q����N�(F��;!�g�|�1S8!�����8j>��$��n�;
��]�pO_F��r�O��C�#�L���U0�����L.�){�B?��I8��SR���,]�A8ffC�^	���
��S�$�������% #p��<���T�^;���(3��`�8t����6p~�>9B|_Lt�*�������:�*t����T��U�]�>�5<�S�v�c���w�n�:FW�j����:U�Z<]x�I
�1��I|f�(����\ U�d����dtM�`$���g2ZI�p|��nD�/S #�t@
��e�@G���k�z����w�4�R��L�Ui �,�r]�~��������T|S���X��"��U�_=�y�X���v����kO�EM���z	5��o�rqy>W�4p�>}��0������|�1E�Qo��B*���"����������1�(����V��)	�?1F\��^�8�B�h��%;8����Y�U�@����c��
������9���4�H>����� b���U�^�+���A�����`?7;x�JY'x�Y����_<���-+X����������{�<�*T����,<)H1�[/>��m�b��*'������X��K��a���g�ef7�c�&oks������7�w�oO����B�=��J�����U�"�ja���:�o.�oc(I#�l	F^���Q��;Qx��2�$�1�=���}C{��m�wp�W��>��fZtD�~���$����9����t+�
�/lk����Fg�$be�W��O�?h}�0W D2_$�����VZ�K���_�7iL��v�?�V{�����z��h��2t�d��p����j������f5_U�G�Y,�=6����M�D�\!�e�oJ\�*z*�,+R����s��re�v1s4�t�\b��]��N��@��?�������yAty�����Km����$�FSV��j��"2c����i���P���?����
gV� -c������xO��)���aX2X�2�R�;���2�7�I�
��Z�v�n�����
G��
�7B{��P������i��@�<�O
�B����N�,_�4��x�&I��e��+��b��TK�E�R�m�m\Z�x	��{�M~X/��O��+j��8~������7dRwf��J�m�.uE�0W+���g��K���8�ff��]����O�:��[J�G����++���#���R���b&|��.8��E+����m���
&���Y"�<�����n�/���������QK5����6j^��Mk�ju�k�k�q��5�h`��"L�!�y�8�5j�lS��^����\�S0����d����#������o
�a�S�?g34.;�K���'�:
;�%�cY�<�Br<[Gp�|Z��X���+R�����Q��L	�����e������\���*~M�ep}}vu.���7�_��8�\�����������sD�y|[�fn�)!���G:s|f����o�U�=8E��;�d�d������X"U��M�!f���' 7�0��n��oZ�[�!��'#X%�@��I�6����5o��F����n��\S]	6����n`��� ��t6Y��F�;S5���XB������#���0Z�^���J6�ac���*�@@~���mH�2l����j����-�Kd0��a45w�t[���)	F�,|��S�] x��4c��Wi�������h8x��"�|�����E�PV���3`�JHyRPo������G�[4�)\�;	��nA����#6�3*V�#��c�C!$�I	�l��6$��&6QH����Ukb57��O���O�F����w���`���hx����_U�4��VX�*�	v�av�V�a6?��];?BU������� ���E|��$�/c@k�������2Du;f[c9����!�J�4���g��e�f�m$��V��zOx�4#{_���A����V�w��#J-�����;9]�"����g�>�B�_Ex�1o������	]J���Zg�8.R�U���Z+�����F5o4�jK��� ��.B����N#�?�8�z�C��t=<���X�3�H�-����b7�U��o�k�Zo��V�}���x��t\B1�](&�y�)���
��k�����S���o`����,����f�)�g�l�(��1������Q���3��s-���f���p������!����T@� �#d�;;�t�%��=���T�U�H���������e��gKf��P��LE�Qb�w8�T�#~i�
���V`�X�z��8\o[�>�����Bp�,`���	�_�%��S� Z=Q*�����g�}?��8TGX�����y�A�cP��7�a���$t�V+x�M���
a}����h���!��a�Qf'3D��m �	�����
��c�G�����1�(�g��Qv�t���}���X|e�5�-�]�B�d�;�H���\L
EU[b8E���r\gv|�|����Mm^����_���	nW�Rl�12���B�#H)��#m���o�����f)U��Ji �((�X"w�*r�K�LeJ�iN<B�w���>gxL1�wF��h?`<��F�>z��'�K�W��0�G�~���O7��@��d�H��}�\tkM�x�PwB��p�+��������^��V�peh�%V�8��V0�nl,����l���d����Z���0�������uq��$3�,����]���'���n�'\���<��P-IYD+l�������RH�&%4[�e�,C[�L�m���F/���k�������8��/9(���$�}A���NfbG��bA�������&���c'7����M�<{Ymx`�����L6(G�.����6;�g&p^�hC�8O�n�?�r$�m��y4��&���(n�������J���{�~�vDBG�	���fpa�L���e���EW[$RtQ��,�A��7���
���t\�������zX����cw�G�%��[�!
[K����J�r���Y��������m��M���Fu��o0=�&�(�U���u����|9���K�LB����������_)������o���d�V���t�2������S#�avp^��"��8��b/��['��R�e��k�T����V��O���B�}.p)a<(/��:�0S�1�>��O�@k4 ��t(�?�K���+���T�Y���D����#�����
����)=Uc%Ef��v��w����PK>|�R�@J�g��p���d��|]����}�d��b�;Q&����ijSMs�<������V��a�h�6��t@��4�o�.3Fwg��$��-<zK�LLj�/������
���U|���A�U(m@���<��B�R6�����tU��XY��\v"%�s����pp-�
�5e��6�H��������d��p��n�6�W�a��g�@��������E�,��{B��'�	��6I�������;�YEB��>P����j�������EY��� sc�C��dI�����z����V}�9�O�
��-�ItX�I4%��&
���!��\����IC�j<
~�G��@�r����:.�x�,Q�V���%E��bR4� \���wn���[���1�����,��0D*�2k&��E-���+��p�d�_�8/q?���=�	Qf�Q �?7�����[n{R����~o�7���^�������e#rj���k�q�g��4�PzvPU���lH�23��;?� D..�-"��:S�#����u�W���������P�>�S������ ���m�@�&����Rp.
i���$>�	�l��	"g�1�A���tlX��m�C���=gd���U�m��6��!��<B�P����e���R;��$4{yNJ����~���I�����8�I���z�P�S�R���a��V6�j��V��S��-�����:9���,8R�:���i�AHk�������j
`�}cSk�5��)����8����p9�p���.���0��T��7Grml��'Y��Q����(�H����ul�V2e����8���&���$�[����������/�6
'mhlx�,}DX>��W�����i�3�����U��5��y��O��[`B`������Yy�F������%����?'�x9
�t��e�GFh����F�owf@�*����e.��H

�c���=JwdOd��� M�xP6�����[ hO��5%w ����/���4�8.�o����KK7Z��/$�s�d�9gW��^}"C��0�����c��$�{6.�q�'��r;�02�:��r���
,�����b4�A,C��T��v:g�KV�x�h��ct��Z�9��%o�&*Uo���Z�zo�[�~��u��;����F�wK������nE��-��dUQX1	����H�����aX=�>
��#^B�|��#X��b�A����
Q���b�z�hq��U(W�y���DFBn^�FF���u���
�3/.o�CG`�G���'���H&�P����|��}�^y��"��:~1~XL*�\w(��^�"��#�r����r�n9��#�-?`ul^�X~�_f^�F�7����tZ�v<_����m�1[�����W�5)Hm\$��m�D����@��,��l�K�����r���B��/�0���V��,u��e��Q7�J����d�^�'�PG����-�n;�QW w`/������+��r���U���B���U���0GXH��IFIJ���MJy�b_�^�������k�K�U��C����T*�ov�Z!��	T��w#
��@�?�B���5�IH���N�L��,|_�TKI�{�����]b�����<3�`����l�!�A��)���?����"&2��pH�������4�5��F>HN�[b��'��7�i�
	{�XR�p���A�N�1�<����A�R��}�h���,!<!�^P��%zcr.a|�]�G�
i����:�������^�a$��2#�jH����R7���G[&z�=d��y7��3��y��EI�Lh�����5���)�~�%!�&���;�W�,q}�	RU�����Q"�H��j��B�����
�93������P�P��W�����`ED���I�R�q��`��o��H��W����.[��*/2��9Z[��D����<��}tgb�%��0`�.�0�r�X�	gQ&
���7�,�?a$���6r����od�W����t�d�r1��n!�B��__�SbFygqqPQ�H���(+,	Q�Q�6��7������44.J]S(��G?g�Z���Y���)d��7�v������Q��V���>U����6�b&|*a#"uhw�b��^@���OZ��0�P��JDL�\iY�I��_��C�����J�9LB+�:7�C�0���U��N4:���������hpy.���z0B|��������w�@�������
��#D	�iy:]�b���w�O�uu��`$%��T{����oA;\x�+�����qPG}�r�3O9��<�1�b�����p��CZ�%7�2���9C|0�Ds=cPc<c4#�����g$�4�����r�a6(ob*(oO�7�����0s_Q%�+�|��xo;���9�����c���m�X�mX-7wK��!���<��N���B�o��A�t��>�P�K��m���$
����A
6�@	#���,������������6G��S�q��M	Z���`�	�BU@��"G�Z2�^O���@�,M"G�"��N
O%k�g�2��-�Z���JsZ���)��D:��[�����UY�7YI������
����{�c�����PJ�:�P��1����Vi�����9=���C��
���tv�k�KNy��\�.C��1��K�Qk�Z�W)���y���C����Y"�(�l8����@��u�/���0��,��x�����~���������4���%+���4j�.�F���l��(p�"'p/��,e�D����� a���a�y���C�\]�X���F��8cI��)�no���^\�N�1mu�}��Z�U�����Bq8uU*�����h��������P�6�i��?"<��bU/ !�8�y�8#��M�~�\v�&��BE���I�h�S��C?���l�Kq�[�F�(��-B�K4�Y��x���n�^����v�1���I�YMvX0����L�PM	
%v�g���#Jj��7���Q�������	c���{Jq��*��Kq�����;�VCj���'o7������,���B�t7�0��w$�^��Kq,�����V�5N�� D8���	���~4�'��������G��������2%zc�t~;c��Q�}����(adCA���W����_�t=���8�e��~\���_�sJ�@���)t��O�oC�'%Q�0�h����w��U+�7v���|����+�~`p���8B�!��{��T�|�|A�&o�VT'���rC���MB<l�v ��#��L���4�G��v��9�I����jJh���"�z+����b
�
\>����V2�N��c�����48�	��-�w�G�
A������FQ���W8��7��Q�pmO�}����@�wXW���{���
T��e&�p��)�|
��>�. �4��Q��(���x��R3�3kJ��_���!��%O:�:�gV]4���V`����������������������qb�(T��R����a�����B�`�#U���h	\
C<���E�r*.�T��)Oqtd�������Cn&�V�����������X��a��*�t(M���������������6���Ha+�^�^��<�.���o4H�BQ��)��D�]:����r��f�^c�n�Y�����-O^n9��|�q�}��h���Qo2��{�_�j�4<D���SE���9[��-���j)�I�e��3�n�&�N��t�f�����f�s�����������7F3�$Z[-mjUmR�VYm5�������������(<��[�DJ���4\��������n{�)����9��������e���	%G��|���mD�V�0H����$���(K��;�9n�F�@zzY/M������������e��������`��aW�Rp?QaX�����K�b4P�T#�tn�T�d�<���2�|�U����]���S������2�
~��&�|����&�	YJ���*��������d�e���y��SOPE���Xw���������e���w�l�X���L
a��l����FUY�.�BjX�T�����>�-�����������*2�eV;������Cuj
$�����0��F��]|e
^
	B6�����/3�w���G���r�		������n>�L~�K���#_�$N����]�WZSJ�+1�
���=��������.�+�Z%h�������@(@K�%���l�XU8�"�a�������w�����������N���T�&���KJ��i!��6�4�PY�;�����
��&	U������]/����S	br'��>�&���=�oZ�&��jQ��U��(]��:�I�^��?������E���N|:�:Qad�9�Z<�.��Xq`�0�>V����X#����hc� a]����B^R�I|���E_I�<��7����f�a�;��$
Q��),[�����2�cW.�L�T|�E��������J/�@0
G!lR�UE����������"��&r�X���G��OlB��??��j�#.�$�G��%�?��d-��1�����b5�}KK�]98����7)��#�N;�&�F~;��w[
���D�'N���*)�{��p�fa��������r9{P��5�z��Ce���x�x
w�i�?b�ze�a!W)/d@h�w��~����+���f�J��u�n�l�>����O�l`S��X@d!���J�xg*�;/������vC���D�l���i��nM��V�9�����S!�����c7$
N�q���_Q30�����6�N2T�����{������l8��no�������WW�����{�����w�B��T��Yk��_:�IE�������x���wq� ��gd�E!� ��f�~R~���V�p��������m�D^dJ������A/�3g���S��*')Z-��ne������B�E��-+X6=��q�����+c�l���68����.{�����6�8���A� iYV����I��
N���h;��+���*_���A�Y�t��/�%|W�sI��a;��'���g�;�fA]��<K*)/�-|������O�����8BD�:����td>I��Hii���=��h�sWa�f'���4+���
�e[:e���*9�G������C�-�_1��|�ZfV�Vi����'\�%�$#-��6zQ�/��{����U2�+�C���(=f���W�A��+�Ex���n98
R`�O0$����[u�����%qq���!�
�8*�a����
����3������!.���|0:������p0�z��gC&�BAXs���NgB�R^���J��B�X�����~
���?#0(�H��D�	�m�L��w��X=���^c��Z-W�����N�L��hd~�	s��4P�4��<'��d|�W��T��;Q7�h�9��I �&�$za���h�����.�z���Z�<�{���9&����/���uQ�WR���x�~|t��?��Q��f���cN��-/{��gn?��o�q������ND\_�������)�D�2����|z�ftq������4_w�&��?A+p?U����S���������
��ST��t���4������6���W)�M�$�(R�
�����d��f��%����j59�i�	���
�t���3Nj�^�^��o�����u�N�C�e���[�}Q>�.)3�[=B�k����}��W&�/���4���o��J��B�amI�t��
a��V���������p�3-�)3���O����8�I�7�1����2't���������T�z���
.��g]^	�}�f'�g	��o�Ee��z����
�V%��y�^�_�O�Uo��;���u�e�
���������������M�iJ|q%��Q�^W���	h=1R�����DC�[G� �3�w���������,����DE�qI���!�5,�;P�1^�h����[@T�P��Y�1�i��we�d~SST\`y3��ta*�������h��,#�1��0��g����UB3���������������@��fr��|���lV(�
Fe��x�W�%�an�TA��\�
�an���P��:`ru�z����7��p�-lM���f��
�w�F��=+�����Ii+������@��z	c���6f�=���Uv������`��f�HI�=I�$����(T���I��������9��*3����02�C���5��I&�+��~K����8C���$�,���(U��<��=p�!{�coA�v��\�=&A��c�YF��U�p�1����{��Bq[����[��~������������
�0���(����e��b/(�E�<d�r�hS����!MW�w�[L-ST���b��Y���z����gp}��8���#>s�UEL�E���2+�<��x(qk��6�%=1a���T�U���!�j����u�Q �5{��J���w����]������(c<���c��R2_�W0o�������{b5����%f�D9����8?�n�����k��)_�p~�R@��e�/�o�����a�.b���$�N��[~�Q;P�M#w����v��.{?�6h8���Fex�j��w�7�����%
�)$[����Q�_��ZbU���v�������l��4s�%�9'��bW�3q�( ������X��
���[%�&l����}����_��n{����nc\�$ivV`�4�a�5
F�$^��?
>!���X�m���;�P�����`�&��Ms�,�V
|.&�(��F��I�gQ����2(_d$��2�de�rZ�@��������w���B���TR����sHz������&�BA�}�2�9+Y%%O��(h��
N�����z4WS��OW�(�W~,~��;v����K6����K.1�|$~f�C��U�����H���2Jg��/�h���ZO���1vX���/�*��������+r��\������p
�W����$�7���+��B��hr��$������Ip�}���9w8������cx#HP�]���J���=��b1~�(Wc�K�E1M*Fw�IE���
$���R�W����x1��+��9��B-��%��*M��g0���}��+�p�]Huy��8'\G����:������k������`�!��H0��t�h�IcT�i�q����qaK�����n�)�R�R:�G:�����������2^���F|�c��`x3�~6d������� Fr%�T�9? �}�����l3~��t_yN��[;���J�?Jh��W�|���@=N)}����9�n o[����j�f+���m���:����������f���Tu,�&��f*d���cYB��sC�����������}���w��V�-Z'��,�?��Z8�9�YW���a�������iX���.0��f0A���)���9��
��O:qT_Uo�R�A'Z�c�0�1H�F�����
��%0������
�_��c��
'�vI�Pa�a5*Ib�V�$~PG�LLMSa�S7�zw�;�2>���������j��M*���������e�^�Q����0�a�A�'p���-�`�F�v���f=_d�q���
��OlT���a��}��{�o�WN���	c��yt_��1u�����TG:��]:J��HFA�H<z��*����G�c6{��@�C��+4BP��>i
����8����R�c��c�H��������#���w6���w����P:R�����.T�}&x{���+X6r��B��i��@���`c��E,�H)���"#4�?8�c;��W|�P���b����1j*�2�)>����5�c��~����O�?�����
<?r�3��z�� ��G�Ps�G0������A]Y�n����|�>K�
�X�����#-5��q:���X�O�?�h��_��R�����	�7G��c:��G����x-��|=8'�#�����&S��w���.�{�=tpi$�ubbD�e�8w�w�w���o�2�1�r����b��n!M_��s{���7��i�s���_'���/���������I���
Z��+^hM�/�f�gf�s�E^��@��p�v��Ax!�G���!����_�~��C��7��_$A����O6v_nc�;v#�H��6�{�_T�#3��x�j���G�cB�!�2���#���
�
��F5X�'����?�**��-"n��a��Y�U���u��7k�j�mu�~k�l�);��*�`��/(�d����z��`���]���!NJb��HN� )4`}���:��,����x��a�����X��0]���jSW�@�u��JS�6�'�R�J�����	q:��e�H;����t��
�3�Q
�5:>�Z��LkH$��Od{��e�������K5��i�65��5��(���H�LBz�����|�����x��q�wL�����n��(�(����^��On$'!�<��@C5�G���r��/��31X�W��U�RD���������cVkcd6�@@�x�nZ��jmY?
�d��g[,(�J0����������/�����
'�H,v`����CU9��<�z���ln6����M�|�!h�b������ga�r���jp�7�s.~�Hg���-�F5�?������l��qT����l$F��X9�!�b���N��B<�`7h<��Y ���{=2;t��(��{�������BJ1�nj�b�&��n�ER/I�j���{-�{�Q��1
��'v��#&:��!@ 8#!2��`���691���iS�n����E��,�c������?���VM�7����.���E�X|IkJf��L���fY-tx������zM�����V'8{�2���-�t�dAk�?_�?@���_�k�p�^�Eq����q�"X��;U�)���z��P6�h��:��/��0�j$��b~����QF�����W?�8Q�������l�&G��jN�jg�3�����!?�8Y�4ox�=�
���*����Gz{�"��^_�c��=�9���0�H��g�`7h(o�y; Gy�RI���-��/@��$�%�1!��>���Ng�:8t�n� ����6u��V|d�������n�o�;�j���M��I��)sj��+8��
�x��Em+3�j��#%��/R8��rj�H��j���l�4^"� ��M��f�'�&\�~s�������u(�lPaJ'=\���������4��G#p1~A�4p��7A��L�����U���#M����W�B��|�����R������[���6�Z����\�4�J2�GY�I��������h���vC�/_3��UM2�^m�<�,Auw��B�Z["�����H>j{���L��s'w�����X[�����+?�!��Jw�M"��U���[2��[��|���#ys�ns�T#5&�luub��(�s6�,U�EIW�V,�E�,��C������)���A�����z�������g����,��n�'������!�����{3�G�a��
�E�����w�J
�{��g������i�����9�M&g�<9����l�n�oz:�Z@�"��O����pGtq8����%�V�8�F�����0KXur�����WA!��o�v��B <�.y�d�A�����$�� �:�	�i�'wv��/�e��!9��	���=$���0}
-a.R�n�F\���omC����Jy������c���H�f��L�c��V��~�o���Z�u��Bk��2��$wjhl
~�����!���/��j:jy�����S���Q���S�]dy������
��dM�OnY���e+�_�4�?�%���&���	J�HB�,	T��<?�q�;q��yf)@s(b���`�B���l7����>q��
g��#f���E�[G������ �Z�����WX��>4���$��������,8��,�<��L�;�^�����_��j�����8�w���R�T &U�wS�y�����K���taY��!I�l�x��w����,����(�D���Je����������?`[H��+g�e-�w���$gE2f/�2��K8�:-YC�a����sk�v�&���w}��g2p��3Y9+��G�����~D�K��4;�|N%���J�3h�D�����	P��lIu1=/��6f�3�	QSU�;!��)M�IF�f�[v��[F�<:C��)j����=�:41OZ�$���$��
�82��y������N���~p>��|3��!�!���oc�_��'nV*����
U��^IM�����8�$�Oq{[3��>�n��(���
���X��tq�B�N�`DcP7A���8�m�D�������G���JJ��xln��De
z������\x����Tr�t�p������?l7���^/��$�q�H�^��#,�<���W`�����hT.��~<�������<���:�.�8�!;�	�F��z��V���WH��}�a��(ss���Q��h�a��1 ���	7a������(L��M�9��*A�B�*5?��XO���z�]1V���{��s
�]���e�z��C=4�1~�zj0��<�����h#����%�=��yD��YB`�8�MD�$\LE/+�df?<�z�k�i�w<���d�dY.$!+6���O~z��YY�5C���Y0�a�oq;
?��<n)�������=e�����T�S��K�4;�g*��K���������
���R��py����������:�s
A��'h"9v�r���"�<�k�(��!�������nLp���.�����Q���A\����P��V9���r�n�m{�����j����]�Ss�e�r��"��n�&��i��B"�XhfK�k����W�g��X{������w������dF�M2Td�I�� ����|B��4���V�@�Z��iV(����#��
�E�.��c��������:��E|
�#9����\�kA��`�*�����;�$#�[i�[S�Br&�8Z�+ny��S�����R��=0��|�z��!�$:T��|�8V������o'�F��}|)!��� ��	��~,9��'w����&Wr��-I3\����VT���\�2;�T�(�P�g��u�����N���k�I�[���2�a���=1�8+���4�m%�M*>Uu������Wg�������Oo�2}�����s��<V�{C����vN��q�~�o���q^��������7K��b)`�|C��G{�x�0�Z��Y�+T
]Xn�Q2T?��m�����uv0
S�jR:~����:��D%�SSX9��]����f����f���O�0�$�+���Fy���L�w�M
��m��Cg������`��($�
s����>��������O��`��`:�T���.�����c�eW�C2KU���^t�����]��3k=V�B2c�]�u��o=�9����5����N	�9�[	{
Y>gp��;�2ju�9/)^H�gn�3���w�WD�~��sz�i����V���>Mk?oZ�(�f�M�m�
�>��R��
�����,�wj9�������~�r?6�3!;:���������_FB3�P([��
od����G+��
�����|�x��C�����Z����M�4���`6�
�5"M�}�����9?!4;o��y-tz����P\�bM��
���N[
�
��y���t vg�Q������W��������BV�nj��v��(=��M�jei�zD����[Xs����2���{l;J(�DTE�0 ��MA������M�T�M$��
<lrL��&w�+@-��F���?SE��j���*�UIe��HyA]��3���U��Ke
��*`�@��'-"�R�uB��
L{���
W��<ir�egr}�I/���%�n���l#����n�S���^���L�-�Yo��T��z+0�X��"@���Rt���2Dwe�!�C�1 ���@h�0gFF����F�C7�N�&����j�|�k�W��������
3,�7$���b���
v;��P�S*�)�g/�w�����SN"IM{�>�t���C���DC$v�n��V���a_}�*�M*����f"�-����`_�U�!#��D��������s�:3�#��{���Ey)��p�������z�?��cV�����o��I}�����j�������N}i8��_s�������sOf����<63|"
+
?������oC����h���)�H�I�w������_�d��`7�cql�Qq����w��Yjgl7O��Y��0v�Y����?1��p����%��#b�Axv���W����+f3��XP3�6���X���\e%�����L����p=b�3���k�k�yy1����*-���)��}f�*�@�9��I~m�B�W&�|C{�����+��.Y�e���<�e��m'�:�DkQ
��Q��33�v�T��ZtHi5l$dg-<Y��M�px��������jX(;-2�����f#u'��O������Q�;�xku)����hPv����:� TX�X�w.�\��`$J�oi������D�b�C4�+s��e
	E�k�B�B��-��kz=�G�m�[��+UR����|�Z�VI�
��y|��*� ��9<�9��'�p0��L��P�#� T�=L��s�+1��6�&mH�t�����B,�{�!�<f�K�}���t�!�_�!l�������b�H~I���	����a��V{��i�S(�A4����g�
no�+yg������m<�$����V_*���5Z�=�UT���m
�Gs^�Z���L/|�@e�dt#����?�����B
�"�_T,�f�����\���%���|{�|��5�-]��m��H�$���9(%�iNK��)`�]�5y�P��n;��_����U�3h��8�A���nIR�X��q�����K���/��
�M�em������O��i�
�]w�h<FgE*������,���,
X�P	a"+�����,��B�8O�:���������N�>�
qH����N���1ZOV#7��jt������SB����|;���<� �:��>�6����J��`�

>����JF����!hj��b�P���K"��-�M�g��O+�#�O���!�'A�d�4\�"��$��w��/p��`V�`�9�p
�R_P$b`]CW��������u4�3w�+<S��U�~��S�(���d�Bo��`d����tUa\���2S�e�d�I��X���rs*^�%���W��&^����U�S�z������t�E"*��|�����Z��h\Ie&?a�u���t�����!�9y�������{sVF"������/o��/�����A���V������N���7�o��k�|�Z�:��W���#Pf�u���%�������P��4&{��r9{x��������<]�a}�
������@:�I��7�>l�"�]��(s���(���������CU\��
y1/�-��",�X���nO�t���9ae���:�0j��GS�6��T��9������	��X�_lXj�3,��$y����I�������'f��������@�X�������\�'^q)��O55�R�Z�B�]yZ�f~T1��)��N�t�NP���{��N�=����S�w�>{����c,Y���,\���}u��q�61�����j�4��/.�^�(�U�
&����Vi��h�:y�����_�N�����m6S��5���^��6�<��z��5����Q2q�
��[\Q*�^�c_w'������9��� g4���n��t�=���V��q�����~���Y���lF�	�B�E9$(�����#��ii���������Q�����a�
�s?
5bA�����w�*J���\����0y���H����_g���������;�$v�r:�qh%��|�U�ByN��'������<��e"2����O�#a
���� �<���
�&������S�K,��.z�j����<ON����6_�Kt`�E�$���<l�8Dx1+k�+�������3�q)�~���C��g��8�,'C��R��c&���IqBC�i�������2�z�
f���U�1mH-�#+W�Z��t9	�PJ��H�[�%��Twt�E2��^�+�,�#R�H(���<�0�������P�S�
O@|��w�"��U����S_�>�9�f����~eK�[��	��e�|��t^�Z���]c5�v*I�Y�������w�n�g/:��r�vm��������O�d����8��(���_��U��7�
������
��.�y�kA3�O�b��`�-�s�[���B8��������j���3�~yv:��������M�x���g�����x�e��u�����%�k�A��s�S�2gr#�v��	����%�����_e�f�8iI5�4ux�i�eY�����j���z4�}�1&����6���YN��9�dv�k����i�c2�2@�f��lTF�]�u��O����J���?-
�Q���Q0����F���������v0#8\�r(�(}~�`����O���O�v�������S>��{&��%QF~��o�-��o�1bR��G~�Hb@u�������<8�����'b��m9-���'��ju��#�*^���X��
c�c
�w��������l0z�������N����
FBPc�����OI�crlF�H)jj��v	��'�Y��yS�*�z�G���jc169 �6����Xk(�"K��V�Z��]���R'b/���-$�-���d{����u�<S���J,Op��N85wu���}mK=cAt�{8��7�&�������s_��q�1������O�
�����?
#:Y��%gV�W��c��X�*��d���hL=_!�N�t��2jI���8���O-�L$���BCqR
����� 2pc����s�>2���\��	�A�"���Kc"#�&����D�1h7Ui��	����*����%o�0|�ZJ��:f���Q������M��g�u���~�]�'��!���������$�~t���O���g�����bnsl���u�BL\��p� =�'O��q�8��G�T�����b������:�9Jv�}H�_��f|5��!:%k�*6����38~�[�j��=��n(ms~-����^�E��������������%��Wd�1��Yx����s��e�����G����;�cF��]4�\j����v���Ht��������z��Ij,����J�=�6�c�5a���lj�Q��*3�7U������ ��
��RAb��Z���T�AAiPV���4Z��n����D��-Cq��*��]�fj;�
]�����H0�K�DTd����IO������>X��
F��8���@�a���$()�|$
�k�����\��NetLN��~��L)�j��>E+�U���e�"IV�o��SA��|�$Q0T�����M��W����~��.Ai�����6S�m��f��,-�|�j���|�r�:>>>R�-�vm�f��$`�F��fO��uR����83'��>��n�n����0&�d;jlf��Xs'�)4���eo������^B+�D���$�]%$�/�g���}�\�\������@����)����wb�h�H�>S".�%<m�����j����d�9��JZT�"$���ef��[�!�a���3�}_����l�����@�b[�`��#��,�~5�`��#�n������I�49�A	�x��0p<�O1S����h������^����E��t}�Y�4�5��}g|����'�=r�>yV:Is�����J�H���8�*�:�$���F���8�.��i�p'��;�=��f�V���j���1�+����R�cH����7����6
����&�9-B`�,)/1��|�{��'�
����B���C�]�o��6v��H�,�de�a��\.hcB�C'j��G�}FF����3��2����t��{��:#��F�����W(ez�!�S-���d.s��~������:��>��G��=��b1
y���B�R�r&��Mn�l+�q�
�I^{����+-��D��v�������:9%��N�:M�*U��o�O�QH�a~�,�+^���\5B0��BbX�3�{4�(��d�5&����P56������7��/F�h0�F#k��
�C_�uF��0�l���
���"�078��#��"
�F��{��}�dzz�8�O���h���a_�.���K�S����;H�\G7�x7���w	z����1��8�C��/������6WHl�%�tG$|�j�2G�b�U�/Z�b�" �8�Q`@����
����66�e4��P��Z�N�gT��B��G��;l�B�����*�+�.m�_'V�9>�<�e�����S���r�X�������
]i��]�U�������G����<����r���/��'T�'Y��?�4���$,��7�k�~If�3#��7�w%$>
t�p��&c�`��8d4�	@ �.2��Da���EB�^�W�U LO=�,����JB���]j%k�*������������78��H�26e0� �t=O��k���Q��O���]M����w�3+CA�BE�����o
�TtA��8��8��������P7_�\Z��C]I~8�t�����bR���,���������(�����:�vCW������M�?��2t�6&�r��'�i6������-�w�����R��P��(����j�!X���
cR�FE:Fsk0�<�o�X����2
�((�7i����	�$Rf���i����a�|��
���P��EM�����-Y�LU#;��>�������U�o(�TL�����
�-O���7D�{�'NV}��9�r)����L�V�(�jr+���h���{��P�s����i��Xi���G���{�8�p>���9����p
���� �\4�I�mv�����@;U��C����B}�H����/�[*L�h�1R�����m/����=�b���aD������+�b	���������"O��IU��zP����VY���%���B.����)3ZH}�N�_�7"�e.#�U��'��h������lV��`i����g����b������%Yn;
u�b�m4��`a+n\�����1���C']Jh�FZ�� V�
e�!��L?c�d9��E?d��u�Y+L��:�e�����q(;:b��xR� ��{��\�sijk��<��OF�������7�#�p�������P�G;�lg�/�h��Xb/���S ���Na�8�!��JG�f�LV6Q�4X
��>U:��A)�TP<�ij�Nv��'Om����.��� ��S��
�**	y-�TZ���"K�pm&\{O�������eEVj���XrI��D� �H�7�������
%S�a��a^�
�?��iP�=��>
��F��������h1��� �kr��;�M�3))��������p���1'����:�|}��d;���W���qc��-|��m���wEJS%����K�x���_�w��6�<�G��:o���Tg:h��$G�����-������X���`�x%����k!mp-\
���4#T����6#_�F
b��-��Y��������0�{
�}����-*S�WS4��%h,^���5��KQ���r%���f%0~U�$ /��x"#�;-B���#������������&i�(\�����- �`���X��F�^�W��{���xa7�r�}=����m{�lwi{���H�$����V����^va������l������zS{A
��1M
��������JX�D�i�*���P���m]e�1��Kh�|�T�lM�cu2F��1O?\�l�:%�A�������X&�;���<D�������7�r��a�Uu���&�}mrG*+�I'
x�H��S���%�Y�{5o�&�[?e��k�$����c��:a{o�v��-��;84K��iZ� �{�>���@�/:�����]��}�bHG�K����N�n�
9�iN_�)#��_�C{���:�����Kv"�@�6#W���$���F	��=��>��V����
��$RfF�n�r�
���X&�����Z�e�2 ��p�����$���C�Ko�R���[�e0���qJE��E�r�[������YH^4=
��Ne�GhK�PW���
V�
���9GG��t:�*?<�����5"����	��i�X|�_f�z�������8���Rq
6�o�*L�N�T<�8���������o��.�!)�C'�=�A���A�?�x�:$!�H�
f�jId����#��,qO������cp�SB�t?�u�+�c�S�Z=%��R?����Ym2�����n�A2)�b��8<�G�	�i��,[I���3YKP�����De���V�^S���^�P�9��p���aV�J�X�V#����'���)�ZC��Q���������-A������C9����c�dU:@�����o?�6")���}Hj%�%~-�u�Pl�SC������������i�/J��Vf��{��0�(���fi��Y=dF�m��b�}?�;w*�0��*�%}L�d#�>�e����R
���~��n���D��\�]D�NY1z�A�8�_�\��<$�&����U���Z������TH��$X�&���v�{��V#���6B�	�Cy6����^���L-���:�d���
 ��t���'?�-�
���D2v��-,��^�����A��5J�'�V����=TiI(��5���;�oYZZn��CB�*�����8��u�����$�����1���G��4�[Lr�����z������T��c�`'��L���8�{b{�3"��0A=�C�|"~}��F-��x����{�#����xQ�"Uj��!$�Tu�`��>�B`�����Du��X �3����1���V�����G0��\��P�&4��6If��|���4.w/�x����-���S��V���#b�;D�vg�<H!�LJ^�rZr���C.s��oh�$s������d�c���Q���C3�*&�(���R5��I�Ar��	WY	UA������O��jL?1�r�%�����"��Ot�9C��SNn8�oQ$5�G~8$�{����J��)`K��E�q�G���,������;��w"����*�C1c!����W��.qI�S�����H�L:E90K�|�,�~
���?������FO�`jA��fb?����-�Y'�
�:q���J��FZ�R�C�4�pX����z�����pBI�8nx�P�d��m��;i�4X���n�/�K!�^0�2ug&A�&��0�I���]	���� ��t���cHL�"L���W���������+6ox��U
����C��-���"�N9b"��pH)d����WW�������W����-�_o�����}�iA��oAL�]�����Q��A7��G����������_��%7o���)���M��
�?
ig����&�u/#�c�����S���Q�P9�m0''t[���#?�����r��8*-+���Fv�AI��7I�M�$��a�w|`��b	CET���N-?�I�'i�M��F~[2�l�N����!y�2@��M�D��+"\;&I.���T��I�,��M�o
���-��|��P>�	�k~/1�A��	T�Y��@�$�
RB�H�h���Z����E�"�m��Y'�\������/������/�IdWe����+P�%�������@
a��a
�+�v��(���r�9��3Da��Ds_�$ny��F[BD44��}Zy��5��0^���B;	#��vP�
m��^��8�ypi�Z�+g���I���p?%%;0�)/��?�F�?��8�����#���	�7A����'��MS�V�8�H�0�L1>�-n
�>a�
7�:�����V�_��uL2s)�l��������._��g�;����zp%�Bd!i�@�r9��*�E����\�YX�nc���=/��^�c�;��7h�A�.E�K�%�+n�V�>�01�}�
f�x�7�Ue�B"�5���5���z��
���~� �"�P3q�wx�u2�j��0:s������k�=l��#�����the���`ES"��t�l	��iP\�P~P�:���J������/D_W\���	�1���b�3+�*iER\%C�HL�It�U���*I)����3��3T�ZG��Xz��@�����z�>M}x�i�
��~T�����i����-�ms����Uy��kt��
���4����i�I���dg�4�y��6���
r���Y�<PmKP����'�,U�bg�j���T��>�W��Q~����/kwv#N+�����N�W#�����e��><����������J�,lm��������$�?Z�#�:�C	sa'�8��/N�����
� H= ~/n
��]��>�a(�T��p���3;}������;y<q�O�d5{8��0������5�m��LS����e����)��n{8#9��#�����\�q�>�M�?|/�7���3w��k���{����{�9%|�E���,2�fh\<%E��������^�Peq�ph�k_��t�f+J7����d1n��4��_�eX��d�����hVc��I���~���n�����t`�2�s���������b�)����-	]o�F�L2����W�?M���
[���ks+1KYoV��rK(O�7;���~K|�j��P���z�����M��}'!},�9�IZ�b���Eo���n5z4h��=��0� 5����&n�m-���R{�n��"<&���
��J19�V��[A����f��C�8jx~�O%<��M����#6JM$�`�1�I���b�,���Q?��u���c�6X�#���]?��j� p�"�o'���i��1�0�w#T�st����(K*�S�@����� �����}J���*�f��<�o-���N��u�<�n7Y#��<�z����

��?��Y"(���;u���������V���A�KGZ0q0f�_gt�����n}u��+�\�k����yG(����#�`'X4����l�����Vjt��Mw�[���%���80H8k
P��=���{7�0PA��OQO*��N
w�)�����@S�X�6L��M!WU��H�������m~>_V���4A��pO��P���M ;�h�j6���N���=����y)�/fx��ct���k��F��)�h1��e�+����o���:1j�^�dM���e�	y	��6a&��b*���V��.���9��^�7Y�Kp��f��>�����������!����@@�#H	��k�`NC�T,c-q�}�i��E~_&���b���6t��8%�;�5�Gf�3�j�Qr���s�����$+.k0�8���\h<Q�������q��4�uJc�JX�9T�x^�2�'�:��^7�`����(�����L?��D�6���~v����0����1B�e@	q��h'��*��h&!������8_�f��p��z��!��d��$X��n�������.���Hq��
�mT1��1����euaBM�Y��2�B��f��Ke/A������8_�B���[��Y��f
1[;������?��#�*���Ki0i�1Ef9-���p���WM�6��%�������#[�c�o�X{��Yl���+1E��7�������{r�:��8 �N���S;�t����W���=�-������"5���LD4Q#P�bn�e^u��GR��IR�@*U��X��1���3o0~ �P|U��X����9j+f�Tu)mZ��a���
�?x�Q.����W��|��D�g���b��d�����s��|^��&.�V^�����]^��I+��-��9Ob��3~c�w8�o��dH3
"z5b?���d�t!k>|�v�7Z}I���H��y�V=�M����i��ff�����,���E~6�E�3|������Qw����I��r����>����	�F3O�����3O��<
Dd��||�^��[|
���������$�\h���ArZt9�NR�]��i��z)�DK���R��|):�`� ������0L�;���N�u�N���3A��J�\-*Oq�B`�8O����|�npy>�<��������}BH�m��	��/a��b7ogF/;x=)(uW�g��Sw������(g��7���S!v|� �'�[sB"\z�������}��T35�t�G�vzY}��BJ��+���f��:�@���'e�s
�3�~��8�P���K�T(7c�������b������K��J�b��`����X�/#�D�����tEj��Q���h�7b��#�B���g�����R�A��/��n��m�s�5�����
a|o?Z��4��O\�q����%u�����}������.O������AQp���$W[��OTIA��\���G�q*�����t���<��]d#�s=X
�����x� -)b���]C��]�]��y��.Z,�{k%QK�P!�)�����Qb����{�,�	�Ti1<�
�C��&�]l;R2��cG)}8��H3�l�o:4L��7MH�~����kV
�t��@
Br��2��(�������2�QC�����*]�8v^�7���gC���4�c���Q���|�����_5�����u�� �D����J�;������R��-��o���@������v'����v�R��r
 d/y����)�E������J�uA��|��$�Ov�d�f�F+�?(2��sZM�s�@w�?��Y�s��B���@[����]`Jr|����'������%/��Y�
�+�]Q��4�u2o���;��R��;?�������\�o��[���>�BrFD��#FO���b�7`�FE���#
�N�X���S��A/���g���)����m�b�7�#�V
Z8�R����JW����!v�P�MW�Mw��)�dH5�}�;`cs#t�5P�w2���CzTz
�n1��k|g���3�2^��,�,w�~������!M�S�J����	�)q�P3	�=���y�z/��=  �8�]�>��$`��/�\��ppLBB�U4�'�f���Y��:K���zt��_)4����A��j���?��������A�������wK�o5{�����_�V����%0#��r+��T�$��F�F�
5.�vB���9����z[�����`���������A���Hc:��.���W&�*"�d��l%�%�?��%��H�XiL����Q$�D"X������8�z��r���'+�@�'�����b�%QR*���	���.��}2�)�@������Rm���'��E�xa,�B��<.7o���7�k*P����`�����z�~�B��V�m��qAP�X�T��''���I��;	 X0Xf��|�!l����J��1�'Io�6�p��M2�25�}���:��c���7�&>plM��g�O87���y����c�`�T��V�6<	�U����y���$�&���V�����������S����Y���
���!����?������!�%*����j�j�xs3����i*B�����9)�L�cI����=�n�|��@`�(\������#n!/a��N�p�=R����u��[�"o�NZ0�8����U�M�l#�)-�U�t�)�I'yRQ���uQ�^�n����jQ�\��1D�3W��.C�:�r�)'���8S[�=U�����-G��0-���7b�|�R�.E�����S���D9PbS!Tt�'��-��0��U��F�V8�#.�SF���S5,�� sw������Y��V�X�*����OR������1 5���Z����'���mqn�o�2z��k�\,1�c���	� U���,QN��h�����,tl��U�KH��$��z1��%�d�G�r/&bB5����(�������|�O�QB�%�]�Rp��G��5�� Vk���'`D�3��Ka��}Jld�cw"n����md��p�
`����+�U`��"2[��u����i���m�����Z6�����v�v�I��!6�u�������J�������O����d���(;��
�^9q4�.G7��CdF8Y7������Q�r4A�c���v�'��}���"�� C)_GQ��&��I>��-�\����������(=6��e�c��x���J���n����S�����������;�P�-��00.���Y��f��6D�>�R�����&	#d���� o�D������?d�y��Cz�>�g��M&���)�n�=�F�������e���B
a��t����Y+�Ul����7�6���;���;�
5���w�����#7��(�
��1�F�10�!�`�.���Lk���b����
DX��G�����H���>��o1n~K�Q)���p�A|��Dfx�L�l�w/^_P�X��i�����l{�����G���Ata��:'m$	~8I�{y
P@��q�@[�������S���[�{�����������*e�G
�X�8��m����ou�����v�����z�iw�O&���;���2)��'�}�]���D5��tQ�c\m��QVZF��fKb%�Apo��������>������Z4�#��C�B��=�! :�Kl8�8$m��e7�������o�p�X�f��������������M��j��;�y	
WAj|%}.�������u{i�����l��VM�T���A���+���������}sq����������3c������r�F�:��_�,���t����(^N��DTi�5�.�Q�������%8��D�_|����Q�"Db�V�$hy
]]0,�����Q����,�ED�l�P�m$]�#����Z�
M���m)�|+e�zp����,��������`ty5�����z88?��N���L����7�f6
gY2�/�n�i�1 D6�m�)��]q�������\��+{D�xy�Q�l'1�2UI�L��#��Ed,r����J�kd��G�kmYL��/��@g�B���SA�U]X5[�zK�1�}������! ���m{;a�{N�uG��c����
e&����������l�@�n����@��g�V#g����	JWbzgq�t��d�;����
C��TH�m��R��eo���Zu:1�� S#FCD������)�x{����p���C��?$^4�R�,g��$�F4&AG�N�C������K�����PG���TF�rd������b,���e����.8��|
ox�t������V[�Z���6�~�S��������'}A��s!�����>c�#�����F�����&tbe]����
�������RlK���;�d���M��W(�O�>V``�i�|��s���46��
�X�m�H��a��t��_h\HUw�S�����.�O����<�:djUC�,;H:
���_����r�0���C���2��4�y"dD����Rg�b��H�7�h�����R���W�&�n���9}(���]��d�6v�.�
��D����	
�
m
h�
�����b��v
^�wn�A�e�&���������`uG�r�Y�-��MF,���B��o���.�S�4�_��N��	)R��o�����Q1t�	��H��g����~�����A&�-��)Vw#q����cm��2��j���0�.|�]�����P����~sA}���-xg�9�V"�+oD�S!�@��,9^C��x4�J�dfD&Gi�2�:J{QmM����L �W����V�"�4����0Qg��Z�\B������p*Th�Z���#N�����H(�)��E����v&�r1��a����e������d�$�����P�6
���G����YU
��Gq^U��A�1�f�	v���1�/�3��0�PA:�Ihm�G������
J����EI����[��`4�"��4b��aI�qF��{���
�b��9G��zFt����$P��������ymE��`q�������b���+:�zT��_u�B��
_N�I�p8��W!��*�89rCV��8d�V��e�'$= ��C�� ��(��Cza{���U���
z��$��P��y��������M90��^e���3U9�8g]�JdE^���6+$�0J�U���t��FCn�E�$�"D	q+y����,Nd$B�c3:�	��[�0O�lPg���;
�1����u����&�v���y�Ph "LT�����KH���tBlw����/%�_qf�x2
���(�m	r�����M6��fj��v���(G��//^!�W*���j8�*(�}��
F�>4�f�;��R_��Gr-��{�����QL�&'4	�K��3�?�����(�`����W���Y0��}]C��(�"j�������2��zEq���xD�2�re� #�I�J�nE)�W��'�^��j'"�g�����]���= ���_����qY��c1��bzg�1��r���LB5��3�
7��y2��3�Jz����i ��8c���?���?���&�/��GH#$�GG��u�c���<��J���DAOd;x��x��,�S�_Q��!�S�4m[ue�����U��������hR��?m�u2���=5�����L�l��Hl�nG����l��b���H��QG6E*���a�%������n��
�W���B��{��nV�mTl����4,am ���Q4��������3�p�^[��������5�u�*D�t��C0i;����
N��M
>�&Bd�[�
�����hcR�����Q����2���rFner2��%8]0(�r�T�c'����P��~��B*�� �	wi4U��t�hD������Y��u��fU���r�5���z|�m2�(���	,�%�5}�Uz������5��x������ ����=F��d��.x�����n�;mt[�I�����V�����e��VwE�x�!��dM��1���x���b��W�t,Q<�XU_�%%������Wg�������Oo��P1���y[���)�.��:1������]w�2@�o��D����7�h7p�u���Ww��K{!��h�Q�������i���,���(a�	�T�-j���k��!��[�U��%����8[�Dm6����[+� �uJt~�'L��
D��>����������1�����:tpz}3��{�1��	27��<�<�O��1�Em�B��0���3�q��wp�G�����e�A�)`1�����"��v#O���qf[�`��/i��Q|�����Ew`�J��r�a�!F`�N	"�P kK���@����S�;�Z,�v���u���Pk����������l������a�����������LK+C�/%
����s��=l2h���M�"�V�W0Z��
��Y!�d��n9�_x�;M�t��l�5��~K�B96�v�w��u��!�� ��(�Q�f�j%���+4��?���|��vWu��]%�����j/���w��]�5
&�x��n�/�}Ga�@����d���4/�G�����
Z0O�0gz�����NK���C�����a�������woN��l��CU����7]J��+������3��)��Z��K�S��]1�K
���g�p��H��?���8�X���W���.%�:�:X���u��>�N��i�B����^�K���lR$�bl�V>�����8���z2�E��R#��?��������� ���~�����b1 ��G�i�1_'2@�}��A���9����4�$2}�9Z�
y�~DA�	���.��<�-����}
��O�-"Q��_�?��3�UAw6��m��{w[�y�����������Y���P��H�Jm�=C��������
p�$��r��9+vgQ�n�Yl��.�\����l��Y��l�,�����5L��q����'��\Y_&���d���#�e�Q���������`������k��)�L�����u���\���gDA'�P����@G�<H���p�X��5\��h�"�
."���C�'�����X�q��@����<,�
��B	M�fm\k���j��v;�^�^�������'����h���^������^��QE���!e�������Lxd���%���w)g�[�R_���Ab.�u�z���*���;�"�A�c�#gC&w2,��b��
�S������`*s<�p�����f�q�B(��Iv������"U/}�-e��u���}^u���f�����	*���!��y�(���=L����$��@W��#��b�J����v���C!��%W��+e��/X5�rK��$Pd��H���(1R�z��*����G���2�z�R����x����e��\�f65��~yt�������)���;]�"6�'+�`�G�Qb0��9��5A�!&�<,E�nQc����UA��9/�Tpa�)XE{6Z5�
]w�����E��B���f�.��pU����Dh
B��1
���p� �!iLGSc�*Wx3����2(6R-t�/.��
�v���eI���y�y,;���6Ob;=����C����a����3���m���0�;��?n�����f8Aj�����K��oRiT\<U��*M�
\���������?�b���#m3��P��qieg%��m�y�}�'�6�'x7��F�����q��f�e~C����A�h�����`��R�*wm����M
1�<�J)�3�|��t��^���G��;�����v���j��������A��L�(�����m�@[�!y�z�9��ya���8{�z���~�}�D��~�=N��5��x�z 2��3�����v�����}���7���]��+6�ja|���I��8�L��'��g�?��W
����aV��dA����4TY�)j�!�lj��*Y�WaD�>�8�Xr�g�+�����Jz\
=�\������@�C>���x�*�p��Rz=�,�������J��W����I�����.��f�P�~=�j���X-��V��f������
� �����H��F�[�o�|�������X�n��V
�|�_J�n�e�i[f���OK���
����Bc���o�Nf��0
�Z�5������F��-���
�a
��
y(���s#�$I�����@���N�r��7��;���(�K�2E��|l6	8���"�N�����U����h�C�]�t@����<@x�
�N��#�a��	-�_����l����#���c����{�+��G�R�V=�
��C2�P�l�Iz�5E
	�VD0�J��07��_	�v[��RH�^g���f8;��zb����b�6�V���
�/m���LQ�#k#q��}��?�L^��	���m���J�,m0��+u�
���v&�?��5e1���u�����q��gbtP�����:�qq���1c7~�*X��^�qV�����~��>E*�q{8	� 7��D�p��`���^�oW���:{-�<�����z��27�x��.r����f��5k�&]��{5�Zm�&�����Z��f�OA�� ����	�y
�bB0���gK<��?�p���ALhX�Z��N�s:�����b$����Z�^s���$t^%�{%%���������+�T���OD��~<�*�#G����E����*��d�W����R��g��%S/�t��"Mn;�J�*��wN+���xC�~N��<����T������Jqb= 3��}n�������?����������5}�R~���`������G~H��
�2�����0�4<v���B���<����d�8����������7I���U8�A|����ku��jP~^7���HJg���6W�V}�"�4�j���,��aIv�� ����X��B�(:�L���h���$�*s��v���Y��^9}?�����@l~����'LU������nm/�H8�H� L��5��'t_����
��>�+����Q��v	���#�^�[�lB�Vg���H7��������}'�'P����}�Ls��3�i������-a�EJ#�+���>
�C�Pu2A�?r��#`.�����\W:��9�:�WK��z\�'�=^\���Z@Z�Y���G��"rA�,�E\4!g��*u��qf�*?Eo���^
]�6G�0p
�8�g~)���#'�j���-�&�������������l��PY/�b��l[��"�+�����.�t���6�;�+�������d���[O��l?��������z�j�w}��O��i���D�T`AQm0���qt�����F;T |U"��k*�M`���20�6U��d���>�����['#�s��hBe.*���S;�z�*�KN���!� �����J0?rSOACC�//������I<4�b��
b��+w��G|b��Do�xV��e����umo7[5��������D�=b/��C*6l��(C��,�4�wp���wm�J����`U��%%�l��B_	*X`�,��A�T��77t�T�s��4�
��������i����d�iRl�5����Q"f0�
�`��s�o��q�*�)��E�����QL���?[:���fVA�toY�`���d��WSi��YM���C�DZrdn6��X���6B?�O�E����,��_�D����>��6'{�`�qx+�N���`��N��_x/or��f����Nc��v=[sa%JC�8��
���~+0�LQ�Y�h��R����n��V����-c!������$�����O_����7�>����r���0M�	�i^�%���m+�;�LA7���)��=V�]��GzsH�.������5�P���q��:��V����h��rx���P�bwB��P��
��U�C,�q���^	
���}Tc�<�l\9�gqD'��[0��!�dH'T�����'d�I����%e��7�Pz��JT��&������Q�r�
�{4��5Q������4�}��jX� ^O�>���G���P.��E�Y��8c���r����|���3�;�i��s'-�����jV_�AV+��X$�*DIa���!�Q�Oe�N=��zW�6+�G_(����������pX"�k�X\�GCg5T��h��VbN�p�(��Q
<�{�)������w�����(��<����&&�`�%��O�X�=�e6&T�����dA�+����/eEA�I��3��
o����b>�!
F�����sS��ttE����WT���}xR%w�]���������X�������9�a'�>t������C�P���?��n���?��Y�9�
��7�a����*Z�a�(�b�>`Z���w��I��0��H�5n���n�Zm����Vow�e%����a6�3BZ�@��
P���*o��>b���W�q�* )`��``��Sn@'Q�A��������P�z
ee�~��f�/�%%��KWht�H����O6���M�R�~#�mE
GfC�a��\���@^���u�	��Q��{��y9��2�(��������C���3o�	��Yuzo��fr7+t����|�I&���.���6:^c=)y���Q��c\�����b-���[)�"n��L4�����QM;���&��zk�X����I��u E\j~��������?
��JoK+�z��?��#�-�,�Y<�N
���7b83G�-������nu���i�������P�bP�IV����^YN��_�4�[V��Vg�v�Z���V���[�&=�=����
_6C�i���`|�
�5Tx����H������%>��M<�-tYy,��:a|�g$	U�9��$t����
\����u��B%4��	�-��X�-N���j����k�C���*�S����  c8�[�S��N�@*��"1�A�I�5b�8��2+g5Cf ��N��~${�\�F�*�@5)E$LZ[����-�k���������t�������!u^r���_>����d_��1�� cR�nWF�����fxD	U�R�M���c��X�N�.|q~\�U($�����%D�$LD��9���`�q��H����d��E���d��+(�<w��p��h�
<"��������?�����f��5���F�����j��iOk����2�����m���\����|��#*�5�����(���@a���_��W��
$�W�l� � #���b,����r�5&��,����+�[���L�XH���%��|���i�h�����i�m����;%~��b���n����?��g3&���3kpB�/���(b�DCf���o��n��[�k�������6�e!�&�6���>���W,#:kBK<oc"�!*�R��F#
+,*������&�����j�:����cReD�+��]��H����D�e3��H�1�[-n��� ����=�{�����f�fp6<�P�M�knORVBol�s��$���
r�H���eW�P�gBC����L��Bd�Z�I��
�n����=��
HtX����dgb3[��OK�\n�{�`�K���C*�x6 <�(����8�U4_n�����r�%�+����
��F���\���f���:$�R"��5#�pz��-����B��n �?���i7��MU*��	�^e�@B��#�j���x����}�KgrM���g������]���}�m�d����J�0�����y����hx��5���6�hoLB�
$VI8%�4���Y�sCV`>(�+s>E����F7������T���N9��i�6��U(�f����H%����O*L�46���1x����2�~{��/�Vyt��)�*	,�'��H�W�ax��&}p��jl�m���F�����k���xq"v��!)��p>"J�u,�QFX@�.wPBM7��'f�*�
#(j���B�Z���:tB�P	���B����O~�f����S���d�4��2WH�Id�2��u����g	�
/w�b���b�vj����iv���;n�k����/���v�Q��M9�#�,�)$*�u����H�
"��!$M%�Q,�#��`�+-�!��G]�Q���m�~Y���
a���]�g�-���U��z!N*��!�!�C��E#jxkH�
wr�Q���?Hqq)�����7�����w\,�E!pTd�+�v(��������C�$�<�'�g<������rqy>zwz=�bl�������
n���b�g��HoE�5���v���u(�N���,�G��l}���0
��X���b9CB���!s���iP
n��J���Fn4v&��g������j��e8~t��x�dc���T!�f+�1>U>��a}"(Y��L.(�������A��S�� �&��s��*
�l\&7&K)�c���Q����X����
��[H��
�#��!��FF6!��_,{���:��x��)���,�I����J��4s���Kc �V�CD���(���s����������A����q��x���&��md&k�4�CRTA\��>�Vw�5�W�����~��*��H>Bw,$��<�*�s�����E::'{����l��^�����9��	:��tt~�S����n���&��)���s����s5aAtbw��$�?��L�!�������@?Inh�d�����R�s:�]Ns��DF���CL��(�Lxb� P@���Od^�$���
��:���8�(�|�.����]��fS�m�9����~�\Cj���Tm*Zm")��\p�"��_8����wd��;��1�q��~6�3]��%�J�br>0��l�����������kS<]�Wb����~�!bY,�O�'���C�D���Q��w8:C���m�fK����S����%K�r1�9���w�
xw_:��9�h��Q�yLH�X�~�0���O�
������vcR��z��jzn����-}�nG�:b��U|%C�<��<��?a��V��8�@����xA
��aw�;b�2@�Sx��g�Qr�n��(�R�H"�)�������Z8�t|'�Eo��I�H[��.���z���O��<�����?��[�G|��'
_N�����;�BF2�[.�F��8>���'�@�lI��E���l���J1X�u8G��=W�SIF��SnQ-Bo�����j�N����	f�N�^���������6,'nE�FjD�,I��JR��[�F����v��cC�����8K	�^�}�h%�+�C�J���W���f��Vk��x����iY�h��a.����7i'���jr
:����^��|Og�W�H�T|�ZF0�^P�"R���;�F*|��&�L�=14{�L� 9!�(�C~�K���Y��}����N}���?M����� 9��?��loz�/��
�m�F�{���`�`ec�N�06���'�%]?��\Ul"�/
�&�"��oc��4|�\`�=m��;>���	kS�]����<Y�
dljp&����3A:��e9c7�KQ���#(��X�x���*O�
'NR
>�A�	7D�q�Z	��=CW�aq����R�Fib��~$O���������=D'���X�w=O��
�	�&;�,q(�5%�����/���r�-���������C����s�q&�C��P�l��x�6?�������eg�G��\3����QN0_�$��$������_���D�*����G��e����m`���W��B�D�@���1�^��1�
��9;�P�#��'��0���9�G��o}��8�y��@z*���	*a�'��1��#�xP�FxQ,_AD]A~��9tbZ�qPB���5��j��
�*�w&(&f!���K��m����]�$���1gWp�j���	�J�������D'���,Q���z�`��
�gh+ZPd,��1��������W��$%�7_I�`I.EYU(��$����?���w#�� +Rl�~�T6�48�#( ���'�����Z�(P�C
V���G�����.���
����$)�X���x����!9��4���N2����1�d��@���������'>X,���+b&m]����s��5�=�	�np}sq3\�
0LH�h���tO���'s�������i��i{=��p�Z���O�^����n��@7$����
i��3=�����&������B(�����r�#?�N�D;�Md�������������(�4p@AGzOQi�X��7��5g@RW�]�Lz��x��%���}b���c
,C��"�(_M��fd� 3<q��C@bJ'�)Y�\r��G�6,[/Vj���k���.��:�==qV c�!���A�5�0q�P����2�L�������/�����4%l��������%E�}4)=����L�a���~���\���r����T������%�j��X�b�/�x��P�l�C�k���q;s����#^}I��6�/�d�0�'$l��$g��������y+N�(��9l$.�("N�`OR�������{V
�2���W�2�kB�������s,|��)�
�Xp|��>�{��)�p�:3��EF?m�w��\L�C\�z�7P��U�|d,+#��������y� �^�����/���7#2t
_��I����W�QR��xk�cK4�]�����N��oN�n�mW��F}�7n�W#��L�2�-i�u�%�+���Py����o�n�H��[������K���7��e:�F��y��98 �<&	J������G7oP��������hTWWWWW�ja�V����{��V�^�����������A��v
�����%b��R)�Ak�Bh�$ke@�<��t
�!S\�������$6H"�O��z
�v�����L�GM�|���5$�4��������lg�������:���{2��N�}�K�q19H��
�I�c\�\�������2�
r�3;�����O���M���b�T�S����I���n��������d%������SJ�<j=�U@O�
�'����6�C��X�lH_���(@n.(��C�Y��awn[���������)Y
��Y
J��L��f4/C	�i����z�D�E�6p�R)�T	���X9:?��Q���p�I$B��Au�h�e�����.�6��~�`.�[/�|0�U(c�c{U��		]h��c}/8C�.D��C)���-����oT�!��Bh��';�Q!
���$�y�^;HDW�.Ow���Oo�OwN1$��4qO���y������7��5�,��Bc`83��+��	����a��x���$�|�e������:
��V���pS�����J���7���[��Q�6�XH�'���#"eRy@{�C�Z��8�L������=����h�������q�e7��R��J��=f�����\ �"���f�����Z�%��F��
f��DJk�>��>X������������������v���
�����--/f5�{����~��������(^�E4�0�\BHK}�HN��wY5��:6?n���&H�A~�sv>$�$���P�m�jI�!���{�je�6b�f�w�KW�y���Nw.t�~>6�}O���yU�lv�UT �jr����6��
1/|m]f���`}�~�_]�������j�
~���AZ.+*{4����k������C������z�@G�R��pP�
0SC&����H;
0�w��B����w�&���Dg�����y��F 8��z4�� BD>�W��G�����X�Q$�/9St���[�R
�w�?(�e�0�w�r�<��@�H�\d�ed��}.�"���w���
z��h;u%8^X|����Co�gR�R���F��<���B�RD��D�
���w���uCb'Bvt�_��k1��/�WRw}�B�Xs�M�e]	m�a�d�������SzQ�$'��}=��`	0������A(�`68�h���|���o?��*��y2Fn�j	���D;([����V�t����8���bQk��`�*���\��\L��`Od�s�'�GpLo�G�;�8�:�����$��+M����Wo�crvk]^�Z�K��fr3����l
�]���*9`��{bh���F�m
����(Qh�����Y<���[J����,r'B���\�W���cX���������w[\�:��X$����F���C+�~t��G��1��7���t������a��4�Q)I+��%���x�����7�sb4�fr����'Q�@�M����{�6B�3�x�A�g!3:���!��h���Jp!fyM�OF.�tK�<%�G�g-�U�zy"�L��SKpj����m�M��b������������*��z�S���HC����D!	�-���'7�sA�a�Bp���!L����K���8t�)��yJ��E/��'n����*t���U��N8�B;�Z�E<g��}�EF(P�L���(����6��F�>bNJi[�-f�zp&^�CB� �����1&��Xl�0@�2�^d/W��`�� �;���6|	�Jx�F�<�1�Gb�8�(N�E�4/�{6Xq��w�E�"�9m��K��i)?���d��O����G�T�-%�|�~��<�;�=����|���^���/�#N��=�R)x^$���V.��g���*-8mBT��
��K���i��ut|�k�EYfSm$�:��:��=Y&��&b�CB%>����C.��I��:�2�}x�r��>�2@2�.�;�{��G�P���Q8���1����L.�S�F"�:5��N(��N���eMNW��~J���2xx.A
s����e��Y���Y�i������7�p��BtI�G�U�b+t�@���vU���t�L��B��M�(��mf����d���8��E����O����pk�r� F�D��L�����D���$q���D�y�T���&�>�|;�������$���\���,��3��I
~t��.�<J*������I���~FVU$��drC��M�rLN�DV��MC��kX*���8�H$�x���y����,����Xt3/j��=��J�b��8��e�n�2���`����wWI����d��d
�[���
$�b[�w�H�6 N]�2^��6w�x����G������������^�^L47'#���A8kN����,'=��d����A
FO�~z=]��������p_�fIM1&L����-��t��0.�#0�����&D�l*��{�;Y^�I�����<����v,=mo�X�H��s�����d��=�6-�pY�B�Z�T�Y�~ax�^WS3���4W���BN���
&�G��7U�cN�Q��
�������z����+>�w1^Ub��M1<����\��I1�424���y�
�������}5V�'������zf�3����9�`�v%�u�
V������ ���B�BE3�=C����b�J����H�}4��G��3�\-*4i|�H��25&-F���d-�CCM��M��b��fk��a�%�r����+�/dbX���Mz�
9�J�����^Jt6�����|��w��0���8���b!�j���$�`b[#�$c�'
�������r�������\9J�E�E�_�%D,��+e�x�3��!V���>	���L������D�OK�1��f[�yu�{�9;��Z�o��9�,=L������0�m��l���u#����
3S���k%g����]������^����>j�KV1c8��xH�pt}$������v����3SNU:y�=S�a��q�(z�k��`�y��g"���i�=�|�����s>��$'���0�9����=�0m��U������hH�
�>����i��A��4#�M�Iru���[u��������ztp�!�*_;<����s��9�9����.e��+���[�b������Jd���o��O�SN���*���U7���0P2��R�u��������K�@����1�sx?9��x3A������+����
�����VL���qui�]]�?�����	�
8����0�q�3?^�;�����2���a��%���h�j�V�o�5�Vh������{��kwF�V������u����"�����UIt��3��Pr<�6o�S���w����E�&[����%oj���
u��'�(c������)h�����<�6���	i�g}G^-Bd	���z���K'���Z�
i
g�?Nng�7�n�������wO��5����p�P��������$Ix ��PS��\�(���O�HG����b�&�:5&�0�ytB�01���f�������zkO�C�Od7���o]�COl��a+E���0y�z�'��������*&��5{����������q�v�%x��
VJ��(�P.�8����hJ%��gU��`�P*<.S��XG��<z#�e�I@f)9���h���;x���3���p���l��!����c����)�s����az�V�Q�X�B'}II�ow/�����������<�&�� ��
b��I��3W=���.�|z��5����]��Vk���{m��vK���[+�v�r�AX��N�
������W�^���S�
���)#3�@`Hl
�*&+��i�h|suaD��a�S1?��#��U��R3��u�S���b����5M��?���{J����d�Lz���^KL�KF���y<#���<��x�^C��������=M��S�9��0����Dn��������Q))���o�c�o���j
f��u{�hX<������������
�lZ�/&_���~�I��;�����8�9�����_��&��������b�8�����r�/�r!4�`��T3L�q�7��t8���Z��K��}�s"'[����7
(M6���#�a�(�RB�:
�����0 �Zg��5VN1B�C�����~�a��~�,������y�����e�x�z�������}{�7%�o�q�V\����"��D�w��`)���X�j;�G�������]�����<E�m�u�yohw!�w�3����S�\V4�7KK+�R�V�������� )�����)����m�l7�������c��q��8h���]mR�C�Is����&�YY�
�?��$������/������K��+��;�8��6,� 9��)^��d����LO�?L�%��E�Q����
�q����x����!<�8$���vz�����z��o~��R,��T���oo'p�2�!���k�4�[B����W���m�K�����E�v!�
h��3$��z�L�W���B��!Xi��!��_����e������g�%rHR�7WF��M��FB*���o��v�W�&(����
��hn���V��kw����v�i�����A'����t��p Jo��w����@�
7\%�>�����}H��qSxy��U�����A5����0������At�c�������r��C����l��������e6�?���=��{��G*g�$��p,tqw5��I����yVVR�e��fmQ�e}������Z�}��^�{�!��`F���n��w�}�������]}���
��aU�I��3O�))&Z�E{�1�M�K�d����!%@��+L����~:/3�E4Tc�Y/�l�a�1/4c���C��x�V��v��h�u��B�
�-4\��N�9j9^x���`�h!H
F�_����/����:��q�UP�?��OQ�r~0Xv�y��hk��6��F
�{��*�X*��nz��di��.��VP�fr�����|R���$X���%,�(��"�b����3j����x������)���&Y-imr�h�s����'oo!�X��
SL*~�I#[�_�?M�j�>��L���1!�'�S.>K!��������v�9#��%�C���G���lUK���j
��:�f�AT|$�q�:�����t���;-�a���P��GtHi,v
n�	���)N���^�N`0��7�v
����k�����5gy��r1�l����~~&a��f
�3��q����#4x$v��Z�7f���bb���`���w�e#iq|��@#�� ��?����X�����n�
�*����[/��h??�`��6�9���Pht�a�<�M����Ep&y�wg�����������HkjO���@���4G�5��
m������&��$kj���!��lg�Q�HW��'YJRH:�I�`�
��!�����i�����:21�����L���H����Z,7��S!����������C�x5.���/sLET�C�x�T���{����.����}�uN���|^���o�j�2�V6���f���e`��R�E���x�X�]��P��uv^/���e�������Z
����^�����rW4$����)|,�����U�SD�)o]�.@[P������m����e+.J&��������������	��� M���;7���Ej)%HB�I�%�l��u!6k��9*������II���i������0{�Q{*f�3�o:�)��X&�K�_����g
�,e���m������d�m�_���w���6�C�����j0$�q(��N�q#���������c�$�"��K���3c}�gv(���5����g]N���/��;������zC
��k}:��p["���G�hZ�y��	��?�W��'�-���>�g{��n��_e����4�=��;�E�{�.�}��e��Z+5�j����Yz����~6����-���R:o����	?o����-���|����y�s5�����a��:����S�&�������x6��cs�)$��a)���������X���'j��`���-�0�)tv}� 	
r��������1ci�-��f�����qb�I�fJ/S�e)[K�������2�-Z �����:�u�������������\��n�3��x�p)�E���:�4�px��>a���������lLD�J�j&������
e'ofn�����9nsz{�\���m�!���?s�B�J�%������Y��s��'������l�����^��.0zF��i�1�C�z�?�t��X"5<���.��	��&\m��L�N�"�p�K{%.�A��}X����I��'����)�/�Y�y�T��|����������E�����'W�Q33	s' uWhN��s���D�}�}0=.���I+BW���r��e���q�O�7�)>x�_��?{hCb*4(��T���\MC-���i�\`t+r��j�^�w���v���7(���%��%��Z�+��(�U����$%j%�\���a%oc?�~q
{�2��{:�n�A�_��vG��/�~&���&�{�]�����5\��s��B��J�C~# L<�Ib���3�Y����
���/���'";(���"ylh��~e�A�������Dd��a��CXcC�l��S����vlh:o X��[��;����3,A2�m�l7�C��>�������;O���H�z���������I�I�������:x#��	;2 �I�&,�6F@�Ea�B�Ml<(,�����H���Hz�+�;�
Wq�
��)����9����-D����kK��	��u�Y����Q�%��;��y���<T���]�ogbN�(
%��� C���������2���	e�I�}�eK������RI���5Z�%3��@&s`�����X��x(�_��:���)��T��(�FW���x�1s�J�Al�nF���f���Y"��X1�!�����g�7)�Sp=��r�@��H���C��p�w�oMRC[R��aV��-�=g�:�W�NC~�|/�0�
�j�73���=��=?�����3H�X�)_{�=,�����������A^����Na
tV�D���3�`E�)	?T�O�
�	I^>
mz�6����g����96�+�w-�����
3zZ�W���Q�<f^���e���gv!u]��&�6f���1��m�*��*���}/�<x��r��u��Q���b�������rPp��v��PY���C=�*����?4�Xd��W%�>������G��{��RMp�pK����)[d���G�����7�7�"�o�b�`���;X	�n�Cm��C�`���b��h8�����v�0�v���m�Qf�p��������j�z���P���/��u���8��%���3��h(�Gj(,{�VI���!R5�����<�����


h���$(�b���z�?�e�3g`PsA.|��F�0�����g���2uJR�I9;�2��Z@"K0y7o�<Wm��t�z��nfXL�+X����n�&����8s�����i������0��8�U��M"s���Fq�~bh���b�D�o�?
V�t!��dv��9\���z�k:�a��KP`
�+Z;3�]�K��]Vu��a���R�x����
���-PcI�����M%��f<l����X��[^����6��7�8��Ca����
�+�;0�|tp�to���M�����������G�Q����O��������I���3�N�xY��&�i|���'�Z�'������ui�K��|E058�d�X�a�F�\W���
)z[?�<y�X��{9��F����*�
O�`j,
�J�j�����>'��$4��u��^���sE=�[���a��W?�?��(�Q�O�7����4>?�1�Ht��E�P"�<2�:`4[h�%� ����=v�g�0�Q
�ex�BB�������E�����o\�i(�VT>B�W�?�3p}�����8�����`Fr�?�M?��RDH=����@:o�.����'��5�j8{���4�yN�EZ��%�<H��&Q�@���M+0�v�0T���i+����(�r1�4��DE����;;���?3� -�|�|:Z8r��H�}�:k��-��� (L��}�u�@7S��[���'2���S�>�6�L���a��V�p-9���|���/�9�^�I4r���Z
]GsDTm�'�,`��R�1.�:�cw:����^x�V��;��{�z:��\���$�>��lx���;�� �6���@�l���Iz�&���7���,vB�w�����v1-8c+��;�U��nc�v�0�q�����)V8/����~�1_�*��wd?���������t����L�<BiC	fK0`r��x����}���|>@��A�y���{�����;7)����$�U������B�������A��bk��C�(��l-"���@����;���
�k�O�S�,#w�:���mk2���bW,����t��Q
��4�1h�v�d;��:����F1��K�r��(>�r��7L���� �.�6]N����+`����������ky<��H��hQ����H/.���`��`�q?j.;r�N5��%
��I���9T1�:]
�:PL��'�����������b
o�K����m���	Jz4�^(D:mo�(3X�P�dn-r��LA�d	cS`�i h����O������1��O
��*	�CNC�;u�'U"aB��u��G�t�p�@V���
�������o=3c�~�����F� ��P�/����b����C���v���8��F�mz��w���-�0`�E�x�������K�Q����������=em\����=e�=�6m;7
M�����M*���j-����D���`����a!��m_�w�}����WP�@'��`
B3�<���)��B�9�����A�[��T����t�����X���L��K�T-6��c��^�_B
-��>��D�O(L�5X��]P)��L��fx[\����3���n��90x ���K����!u����w���(�*#!mi���������{���
w������B��!8El�Ds�<Ba����}Q*���BwK0��������A�j?"���Z	Pb��L�<�Z�es@�%|�v�y��Ea��,1�V�
�/.�����K�2��R.r�~���&�vx�i,L�������\]u�{�w��A�������q��nF��]�q�rjW��!j�6l���G�4��of!R���*�m3+��o,]��Q� ���^|e�+���b*9;����N���;Y������o��R?FQU~L`"��25�4�-!o�]�X�@���{�~op(�x���f��*�).'7���b�A���6�[=V�,�~��rO�{p���w�=����t��`�MA��,�\,�Dx����fop �
����SZ����6�3�G�r#WF����4s����p�[G��i�B��*�*T�4�N9���KU=�KkT4�b1�R�M�����u��C��|=��y,��jp��ULY\��gJ��"���$��L�D��,�BU�;���������>er��a����U��X��$�xS$�\K] =���h	=(��@R��Kf����rp�&
N�|���ZZ�7�AYe�������
i]�iR�*��DQ�8���c:�V����3v=�$hi������B�6��h�t��uk	'{�����QB�9$8��+!Xy��v�\)�B�K�<�K�����qE(��W]u$!���!�bWx�	���$n������Q�������7`�5u:Yt'\���/���^u������?r�,�1\��s)���zJ��o��IWF���)SL����^Z�^Cq!�o=��p��y�o�Z=s���=�mW&��4W>���(R)�rO�T&�TJ�����
���n��y�@mH�1A��*v;;��^`�v��R�u����
��Ig��/�c���Q��)���k�V�x����S�N�!��Uz'T��D�=�*?�^���+*�`qACN���t��x���SsF��5f�*$W0s�5]�C����;�c�#��"�\���b�IQf_��Z����T�����qF�3/���G��&@G� �����1����s{#��b� ���B�S[���m
'�V!��!��?(�s|��r�x�����%�|��x�:F<2��

���$'�Qyv��c8)Qggi]����WPN?%���_���u�����=/E�wg�X�B��|�4-0�<�B.��%@�J"`�0�<���DP�-���D�RL������;T�4�l�P�������z�A0(�C8"��Q�z8��z����r��K��C
�L�X���=�,�K����>� ~s�=�Z�z[�/
����>$�^Fb:UF������[���i��BD���b8���M�V$����='�01<Fl��b"T��#|��"�SV������� ��;�`��)��Y��t}�7�v����}��v���z�+<�X��m�{|��H�
����h���Q��
�3<d�^�q�.p*�h<�1��l�*&�����m5:w�����V�k���Xm��������e3�O�Rt�K
a�8���[��t�	5�W1nu��GA��Z���
P(�B(@b��`���hiFOj�I���)��q�XR�t��;���
�cK���D�S�r�b��U�
�(�%�d(�Q���v��s���f�A�.p3K��)�4�<�f���WoOe�rH�4{��j0hI�������R�7o�x�F��w�����{~�L����/GG
�c1vbK�f��Sq{Z	K������h���9����#����&M�8�5��E�K�RC��~� 6����
��u��U&lR/��PZ<�����2��BD8os��
�X��eYO4}od����n�#��A��u����V�����68t7&�7^d�Tl��\&�Ota�@R<$�5;X�
_>VgY�)VeT:���q4����:1�`���Nv�bK�;�%�~(^�J^���N��������e�_��>�`��

��'E\v12-0023-tableam-Introduce-and-use-begin-endscan-and-do-i.patch�\ys�F������zi��i?{����:���y/�B��X�Hb����=
�r����F�E�����7����u�~o4��lk0�,�1��Xo[z{<�V{2����.}���%��X����g�v�spl��#�
�`�
�<���N�tO��������S=�o�m�����U���3a���N�M���q�}p��f���xstw�{�tY���wb�n�\��.�0�����a����3�kq�&������������h)��������A��8`�L��/�97Z�<p���a�y�d��_��������r}�A��nu�D"��0Z�<�=M�D�Q(�X��/4�G����:�D����kE�&D$�e��(���&�5sDH�f<����eDs]����z`���D\_�/}�Q��l���O#����6��< ~����'�����f�������K��d�;Cd�>�"J�jmx*�[��5QV�H4���RVDo)5�X����(CT.�eKgfL�n?�a��3����kd�\��#����FD���"�=�o���l�z���zt��C6��{�D��$R<����\i�h&�����3
B2�p���6�"�H.�C���H�A�����tW;�Dd3p�i�"���-����AN@�ko!�=4��m��M��i��B�o��2����
�*!"���,���������A��R7�e�����r��2'��u3�y��gnF����(x�N��%Ct��]5�i3Ed��|��X$�TDB��?vB�D�A�)���� �P�|�������e���L�E��]���;��zP���D��-�]
���cP����2�T�M�/� tP�` �0�( �~��(#��C�yw*�T�H"�M��I���i	��-W�<�}�e�'z���W���?N���Sn;�����qEK���r��6���%��9!�����'���j��������)��A�*T	U�]��<��N7�rd1��$��T��g��IZ0<�sAnO��d��
}�E��=x!�M����h��L�����3
���U8:��D�]KTkp���1��\�j� �m�h�����]ScW�9����ph�;�q�90}�i��a��a������������������{�>|8`V:g��|���g07�,����-TW��p�Y�@E��<Q��Y7����_}Cc��&0����M�cF��"4�Xi.|��)w)�0��:K�p�t��t+G��U�U1���{R��R�����_�_�j��g���vdQ����q��V�0f���4*�g���P�����J��H�6�^Z�A�%����Ac0�~�@�F�l���oN��L&��[�#5��qM�n2&�M&_Su�Z�fW~�Y8�CF� �����@D��HS�p��"��Z�1ZHx'�����d�i�0�� ��j������Gx�B�~XG���&mz�E����_�l�����%�	�����R��a�j���ewukdw���l����m����.�/e�������Q}�eT�l������)��|�zqz��A��*p�e��0��*���Q8w��3��9{w��������5`�
F2�n>j��W'w�W������}��V0$
�������a�������R�V
�J�f�������p�7v�:��a�A�F�IG]�)\��hq��"U�M?���H�0��p�T�5���_$�a��<���"]����]b+�����Gax�]B��`@��������� �A�*/u��*�����B�S�
��
��^��|�Q�����t��n%��]���#6�$�,���^�X%�uvD�z;��$A
�[����lK��@�`z��;;�����?�iG����i
�Wx@u�z6�^O����� ��'��g�������L����n�on��wg��:�V�>X�Y������9��h�|��M
�sW��p�z��wlz������vs4��@u��JiI�91Uv����������_�N�����9A���n}���H��e�
�QI?��e�$�:��PSbk����1�b!+(������+�	�����J�����y����T
t��+C�my���z���� �%�_Y�(,�14�Y�������}�����/�6sW� Y�Izc
��D��L�D$0Q	��>�l-dU�%���n
^�l�*,VVZ4T�v-]\��9����9LX�JI&6"x�q^E�:;��'=���p�k5L���IJa�2���AV�!�3���a
�Li��k1��m�@>,�	@�$3��8d!q�}p��0��f�	|������l�}�>���~w4=�>�"��AAb�C���D�����P|Y-?��u��j���n�u��R��g����sZ�b��U�
�IA�C���hb�c����g��s��~���^�.���\)���@�����*�*���������C�aOC%4d)�(q8x�trQc�'�N��Bwr����j�u���G`���;���N{OO�

������m��c����S�ss���m����Tj,.��r;=��gPi��S�}U���i	�/{i�n��~W7'�a�?����0�a�=��eh��[����H $��|���z�����BL_����)�N��AP�<���[�kDn.�����B�mb�/G*�\Cg��*���/�G��#�JNR=��4��B&h��l��O����G^�l�#]��dR���m�xE��R��^��
����	�UR�O�Z`b��T�
n�����3]�hA����[+��?��g�����q���w���Ug0
�u&�*���l�-��/<Gj"
��(���@%������g���5
�%�[r�dM:!-v\���T��/��L(<?$K��Su'��A%8�����&�7w����
X�;�1�	W�6�����m�(��^e���2�k�xr�%��y^T�>�+ ��\��������6�F�t(������
������`	�z9��"���@�|�?�������7W0���R�T�2X�����
}����T�pH���b�@E�<L�A09���`�d��<��B�OW��u�2}z|�]]O/�>�|������=�t^��e����$&b�c1�d1���gp6z�9<����*��1�Q8\*�1��p`�U���>F��Iww��=��bsl���5������[��b�PC�XF���d
N��-8^&+��	
�2N���Z� ��?�|���d�{���[����I�o;��j6���p�n�&F�����E�������0~FVX7� 
���4,�r���*w@`��
i�_��%�[���l��I�aQ-i
V
.PmPdd[��d3!���\������4��{����� l���s@���/���:9��{��x�����n�K�������R���T�,!���H�/Y.������/��F�[��mN������H#!���
�����I��(��������r��`���=��^}dV���+��c	����"�R���5��!�e�r�qs@�������XF�$%n�F;��uB����%8�?#�������I1
7�xJ��y���`(��PMx�sm�ri��#B$�,�.nq��>���[4L�� b��Z<����{w��y�/
�Y�:j�5�,8�r��H����F
��?��v�'5�Dw���$�����������U���7��i���F�ZS�x�p���o�Z�K8�"U�s'�B}�-��z����!��~�?�t��h��}��c�%Z����*7��'��#�
�S
���J�JG{"��:��~��~Kf���Kf���rp��/*o`���xh���z��Dy�I���s�z=mKW9H5c�0Qy��mJ�5����
����p0��f��l�c��y��������k)�)i/��Hb��Nl�T_�m��l{�m���rn�&�T�}����{m	iz�,�y����4@��iF=�
�~&�����4i2�c��6cwU,�����m�Mc���Ig��f��nn�H�nG����L)?�<���:�J[3��o��xq{wK�.��.���k��E����
��|�t��2-�W/ ���,���*E2�3dp�M����.�*;�&���_7a��2����cmk���Nj
��'q,�� �ok��z8��������
��/��{zv��[-���}�Zi��pi��6�]g�7
�� y	_����cI�/@�7��5X��&`$/Z�����d��z��\�Az��3��6C��=��M����)�����Rl���9���<�+��6�H-��X+��<��a��76��uJ�07��`�V��L���fs�1'm>4��xg�dX�6������
74lA�ao�����S�b�� w�d]���Q����
&|����������b��[�v��	cvr���c��0s�V�.����e2k������>�P��OP	�
M�B���M��8��K�%s��1�#���n�"e�7
���'=������MS�]+����$������C����!;v|/��w��~p@rz_pL�t�-�)2���!n���Q�3���_S��|�?
z���ON@�^y�<�=�g<L��"K�h�j���e�,,���gOk����P�*79��<
b��q���
'$�o�92��6�(���t��>�7I�`�E�1R�6�~���s����#����>�]j8N<s��G�aIm��j��D,Ks����:�"�Kf�VD!�2"�uW<�&��X/EN�����R�������d%3�m��ao������l�M�	��g���Hn�Lw
��7o�w-|�-'F�m���,�xR���.1��p2	|�������
���O�]"��@����
�e�R7z�|����&�Jf��vK�v�;C"��K���Mp�d�g��Q��������FtA'�t��^�����ux��%\�M��
�����4���d&w�`������ 5�.h-a���'��6T� �R���������i���3�� �<3�����]�����$v����J�%[�sbJ��!������Km��Am���I������u,>q�HBZ��Nmqs�`�x<rDCW2@E���n\r8�,YjYmL�s������5�v}�o3"P�����@��+F�Y80H�"|�Xi�G���BZ��S&q`(��5/>���of\�O�~��T��J#��W����>e�cf}�(��X_��42y$���Hg��V�oKy��ex������l��,�M��H|��e��O�����Ak���MRiYn�����N*�:��%H �������x�����4SQe������ ����:},@:��C.$���@k7�H�X����w��x?���!��/�:�O0=� �q^��������8z�B�Z6U�R����o�0G�t"j�X�%��~4����WMy��W���2|���c�S�4�	���p�u�� p��Wr�z*)���|��P�v����)���LJ*��G;DT�X���8���P��}��_�2��1"�$��5XZ_.�<ZU0�������/��j�;��_k��C�L��Sr���{��<b=��m��F%'�Bt��[#��#���B�L��V���J���V��BV2�<����^���r�B����W����7�n���?����q(s1�%�d�l+=�-��t2��_�%�I�
���3��o��6�����<O<��j�u�������=��-Y��3�x�Y����\����X�$�9���x	�P?��%�;{��HpBl�s�v���cH46�������@�������N�1����/��������*i�h��V!l����}���GY�I+
qZK�f�krfW8#1�)�K���c�=�O�(]V�����y�]')
�z{
�y_�t_p������g�1����k�v����l���:ZD�UF�A���<�7�k�B���#&�e��(��@�!��j�8����:s��?��{�7�����BN	*�?:�f��D�������[?	�0��
�+�:���	�0n�/v"%}s �yG$�H�qx"�}*s	<k��Q�a��5�O��A��*��1���H�d�N�e�f"���@,Y��~���o(��~�����7�Q�;��=shf7��J��g����Z���������#U"`-�R�kJj�����Dh41n���vM�}AO��=��W� U!��7 ��K:8��l�T��qYQpN7��4�d��*�zu[s�tT�1�_BSW>��������X;9@��h�tdt8�	:b#�=�����i���kGP��U�fB�<_*�O+	-0�~�����e�Aw��o�O�e�[���j2�t�����VG:V-����Q+��G���V6E
�9���QPT����e�����<�n`#��.���-7�|S�� ��M���nj�!�y���2�jOk�K�Y3��`�����Li��>d#���A�L�`D
>��5��q0a����x&������e4���Y
��!�����L�V�'��q�SVq@��7��6����pl�S��'*<��f��\6����C�y��.���
����m!ZV��yK��Y�������k�;Y2���
���(u \��6w��L��������
��r�R��
��&�Sa$^��p*�J��e���:$G�$}WeV4g���8��K)
�8&s�c�vjM��7�9t��Ib0E�e]�H]�x�;O�����T�<�R��woY:���.tz{Mv����m�sr(%�����eRS"�H4iG��5����x���_�y���Hc�C�����J���@�H�V�}��aA���>���R\����a��c
��\'XY	��^�P,%WJ�t�6f�����}�\��~�U�^IyM�`E�-��@P����] ��}gd���*PB���n�E����k,���@Z�w0�}���@ ��B�^��~GB���3��Z.��
�>�����������},(�'�HH�d������Tc>
8������Ig�p����}�h���������c��dGZ�����\�%�V
/�����(?��E���C��v�t�[m��bt�&\�������d������I�����2�����[?����Q�M��%��&�����Zu>&��M�;������
R���j(�)a�S�^����d�/Q�cal&s@�~?�92�^z�9�2�x)�������	�bz�\�>���e-0��ma��`�LGc�����e&���3d|c���f��f�06&��as�{\r�E
/�M���#�ET�A�f��IB���A�v���K9��*(j*���U�����]�>�L(
t/���!���E�b�������h����
6;D`0]/P1.��_�a�z+�-h��w^�	�`��0JT����$����b�ld� O��`2K�����S�������1Y�}��	���H����"CW����n��.�����4Z/�(��w��h��j�����q���Q��~���|I����
�nA��gJ rya��=t<�������C������p}F�4�D�z�B� YT���-��>g�G}��_��w���bg<��bg<�;;O�����g<B��8g���BT�s&m
���'��N�u~���O��L(_�d�9�/�.W���A�qjAr:��(�d�����(��������u"�v�"�� ���o�C=ro�H����+
�^��������o�J��}���D�?��L8,j�cZH-�=�0Z�����v��T�2�����s��f������U*������:�<����\Z�
�k���E|������S���A"
q�T8���|D����1�>N|��d��vH��1��c
K���N�������t�|}�;��	Q����A����LzpR��v#�c�
H<���#%"p��M��kA�Q�����n(��6�����~�v?ny��8�a�B�6r�Y��;�+�6K?Z� S
��
6M�/1���k�
�
�}n�M����S<y>�F��dI�� �K����:{.(p�]%!�?�}+�eo����{�<�M�dy0W���5v5�������������
x�^�a%�z@J�M���cpw4X������7�
4)�C
�������&�]UNf%�+n����v3
XL�
��cggbA���]�G�����8$�;�yjPv;80��c�X�T�Hyz�{��� T�s=1D����\H\�&���K�I���#�EI�����G�-����A@%:��k�or�XbEg��Q����/������X�n�	�k��k:����n�c�K�C�E9��D]�PF���a� �4�@�g�������/b��D5^!���K;��0�S�����f�C`�[��"��cO�`jn�Jb�7������w�B2alW�"x:2D�Z�"��`�_�
���k�!_��2��m��t��E��E��r���2i�2�b,�P��t �SJ�v�C�E�Z�qd�;�?�!�v�Y���87�
1^A��|cF?�`�=��Gk�1�����k�@K���:;�%jZ3u�p���.7sG����X�gfK����
%��^*�<���r��l7�V�[�7�m���K�n���.��9W\1����	:��L���|�f��m�B)$qBF���~�l��������5S*�y"�+
 ��Q�IV���,�^
�$�%��L�se��b@��EHL/+����^�����p.dP��0�w4��y���L�:0�F����1L���my/�� �Oe&�2T�W���P%��9�����@�o�2��WY�V�
G�L
���z/g�IrY�CG_����!U��
�oCI�9�y�����Y���T�'�I##u���c #��u%pJH������)R��!��
��P/�.������>���GI��{u��G��;S�8��k��!]
r����4�)�������E������L�37:�G�Y�����#�����V�H���	&SF��@d�������r�'���cjx����+��;�p����e��1%A�$z��pq���| 	��F�n����;��3]y
�����&C�>��3��	;5�4�������E�L\!������e��+�����)��NG�2Hf�����v���=I��,�Z��C
��F*uBEK��c1`
����c�Og���bF�
23�kq�`H��u�)}��o�
R��
'�
����E�`�n�J�`����+��T�8$�Ct�~��h6�����x�{�>}�p��V�Skh��<M��1��Yc�,�K�n��u����wu���8�FPp��Rw����eHC+�z	j��+�2q7PyP����7-j����T�<�����M�TK
i�a��	��+v<F�x�;4���8�����i�7y�����^y��S��o�5q��5+m�DTSY%M��"���qI�n���)��V�o� �'!����[�vRz8=T���S<(:"N���%k�Z�y!{zR���^"g���.%���[����452�D�o���C�n�,��-Pv�������i��&�M�VI+Y��m������25d����u�!��
D���~e�@R��_JF���;6����B��Q��)��f ���)p9I��k@���0�m$c
���O�*o�K�~��j>��E�P�����J
���dq�����
6"���	�$��~LS���hx�<3�
U�_�(�(����c�)��d}g��H��
H`0�M���z��;�����@����]y��X*Prk�kF��v��`���$�B�Eqv<Xb&!��c(^��,��(�P^�~����c���:UCcO��`Nl�2HG�i��b������(I�RR������W�>�
N+����i�5��/��/��h^Tz��0�.��w<}
p(�8�f�-]+�3��AXHf��9�����7�m~*���~��:�<�\O�,^Es������RE#�6�����!m�5�<��A�^��S��Mte������~e&���SK�m2o�����(��[�]�J1ap����N�����b��G)�8���>>��n�(	���%���i����b�&W�*��FT]��8�������^1yc���K��7 t2��M8`�c����r�1��:�L �D(V&�A%mQ&����*�N���5
(x�X�s����],\�}�����n|j���Y��������_b���j�s����bD��$#@IJf��v���*H���YYEkH�&�4I����Dr���K�%	�����vM��V>sH3����uJ� ^Hl^|���h��K�����8�]Rgh�P���cA����C����D�i�R��>��B��w7%�N����&xJ�"Z"����}K��FP��\H��,oN��X
�J�GW�)�
����w�������2�SO��Vl2�G�{�k�d������wf�,�����u��St-�G�61��qJ^���{���Bm��
�
�V���	[�1K��,j#���)\
�/�G���&�i�S�����ts�}%���Y�Qzo��
l��A�@�v�����h|�5��EC'���+2�b�
�V	���+��}�E�n������j��4v��V��} �*�������(��"��)��]�>EGT�������N�c����
�w�g�D�5�C�w$���m���0��:�T�D ��G�
�)Yms�
����
�������rJ��3�����l3��n��E�!�!S_�8F�Z�(��eJ���Q�GN[ P��G	����<�kj�]��YQ��}d|���*�
�#��{]8GTd��Hs��v
�;�������
n�h�qO��0Z�R���8��`��\��������\�@�-��O��������
����J5D���~�S�$CP�"�
Mls��R��~����9S�P�������$ZK����
���J�,u����;��
�W7���d��}��m���PM�a��S��������AK�.������2N��{����5��JD��f���s�E�al��S�	?��	T��
�V�e����uf�����\�>��>�mG�Nl�,Ps����h���1�����'s��K24
�x���5�Z���+
m�
�����l�
��`K��|t�t�4�dw�95�%&d3��z�b�f��N MB�>�E#��.�[�J
�D��g��3�
�@��+��K�3!&m
"$�r�#�n6w5�)m!18 �*��g�f5�%�Kpt�n��� f���vVO� T�I�������.e6�t!w�@��5�����w�t�����[��S����"*U��q�Z�R0���Z[N�\)����������;�(F����������S��+���0���o�������/K�����/M��\��Ll\��hA��o3(��� ���.	���D�QW� =y�|10:B������� u�o�,��n���
�4�V���3��v-8����"s h'"j��[�������!~S��O��=Y]��q�v|L��<�N/.�/8'F-L�9������_�N8=����t���jz�����W��e
O�^�������/��[�L���1��������'�_����O���9��JtA���"Z�k��?���jr� TX�u���SP��[:.���A���s�YPl��La�����z�)��(��.fY"4����z��@;���8H�G�=0��JI|(��0�k��&�����b�����z#^�i�_�E.<X����7�W���7o�+����w���_��bi�A��}}��Z��/��6p�����

C���U�_7����}���)Q����&���E�����9oc�N�/����wH_����r�V��b*��`���x
���W�3�FK����9��!t!Vr��nj��y�����u��I]�I6�D6��V�$|�Z��N��������+qc'��5�q��LHd��g��S�()�D��DoCYov-�3)Z"�p�+���������s�Q�7�@����D�H�\H�`�c��F��Ay����.�pJ ���tW,wg�rI��_��a;�v����}���~��6�������(���%euA'����YF�����I^�6��ay`+Cp��_�Rpln���X�J>�<�bUu������>�8pM����])�ea5�� sv)���;6��f"��C��

R~�i�=�x��X917������J�X�H����k�N����NT��9W�k�Jt�#��	d�4$nP����{����#�[�d���D�o*��\����4�pp�	��(�S���B���Fp�!$5M��7P
���`(H`.`7{�X�8y-6��&����Ny���7����=��7����G;	G���=�u��������?�^����O�{��O���!s�B�m�s.~���B�_��|����p��������V����:\�+xY|E���w,��>��)�A��������\`��:��+��e*^E���g+���%�������Y�B�
()���C�p�?Dt!
��%4iiPl���]b/����7����R�>�5
�H��G�mI.���R|��d$7��=T�
�#���9���3Et�3k���.`����<��l���b�c�o�v��Ng��,����=�w\���C�������\�����G��:'4H��s���y�d���h�g��a�5{a��)c�.�)��"9yH���\�pA\~�e��6p#��{�aj�d�!�m��s�qy������&\>v���,#�a��38�S��8r�<B?x0��rG���&�79F���t��1���'��� ���)�������Sb���F�/^�!�C3,���;5p��$��������Wp�G�����
�)<�>�y���l�B���\�9� �C�E�PG���c��b�����d�"��Sf����W$O��	�3��e�Q�m2e
o�jHZ�-#}�W�L��{��/��!����k��7l#��m;����������4je�l,�\P�m+N�(������J=��2c/8F�B�����g������M�
���\�{�/C��o���~j�;�b?\�Y��Y9��������!��3�c�9b���m6�jd)a���-���
�J�Z+N3��go.�`Fo����"	�#,2!5�Q�}PX���]{D�s	fK���B���|dc5����<9��U�/�l2"����F��TV��&-��r������~�;$���{^�����
�����!-�/!�01�Q,�
��p�P�tT)'���`#��R��D����h��^�&�8o��S�I��&S��"�����-���{:��gt�-"���I,����
�������C�l���qA ���OY���9�7�{8]�Y���]"�Yq��m��+���\�����e�F�k#��{����NT�����Q��^��f[Px��$�<��'D4�������n\$p����'�g��w�tp���(Q�XMX���A������j����,�����T�����n�f���6�^k\���\#S|U��Iy��C]���`Z��K�����-#��ri�5^R�*X���-w9
;�k��z��l���+������F�A��+���R����pjl#�����{��*�w�b�3yd1;zi�����f�,\g	]��8S7lPd�U����k����������M�;h��H����`d�j���%�
-m��1
��h?�O9+wh�v�9�1�����-J����[h5
��z�z��%sIz�2M.��61��������2[�0�D�>b}�z���[�Cx)��`�,N����.��9	���3!�Z���7�4b=q�'�HE|��8�!�f9�C�v��>������^0���4�P��gO�x>���GG�{�����?�SR[�/f�%P�}�vz�zq��vjk�Q�7���1l����)���Y�^��n7����{fd�R��)�7����)eK������mH0�3Lz	�6n��:d7�����.%t8�<^�
b�!�r_�3�*��.T��������Zf����DA*��"F0�s�S�.<�34|!�Z�s2>>75��4.�RmN���w�G���r��=�sb��A&�P�5%�K��}o@�Mpa�,������-r�{u��,Ew()�<H;	h�����(��{
y�����lOY�izG�b`��qRlR7�p���%����M����4�an���I%��{
�#A�h,�����6?I ����h���K*��"�8����I �)�,g:�]5��[��(��*&}�����K�>{.��% q���x���<�o���Fz_;`��0����?��'�-�y�!\!�L�$(bP{
��V�XX�B��jl�^XC���_�����$���Q�G%�
c��pI�a����$����>�$������&+G���������tai�QB/����`+�K�Wpc����(^���#TQR�0����
���Fo$.�a��)T��#��uI5��7:\7*������V�m��y�����rd7�75}%� �a��(�pQ��d�2�e4�JH��tF_�R�*��� Z'
"?�d/5�p$��r����r����<���L�f���
qJ�����T�$8EY���e�Q���������%���[
��S{zo=t����)���������X8`������M\X�
~H�����r���Wj�<��x���N��rxnK�V[�������%f^�p��������=�g�#
�JM5:*XIw�Ofq��FV
�b����E�)��r���v(�s���b��/�CI�9G�v�3�D���8c�]��Nz�����A�le�S�&-�?N�0\6��x�������r������B��D�I���]$ySg��hx����o(2����+�I�`�7(H�V�W��BCR��{
Q����0]�e�I���������9�t*��[�
�x�\���z����r8�{����S�Tr����qoT�e�rDH�Ks��U%���/$�
��8^�N7�A�
79���7&�%8����%tm?��w��O5b�_��,�vw8�-Z����i�;�A�������a��

7Fh����������?~�I��]fA4i�!�����{���@[Z��s�V��Wf�3��i�&#�� 
�6u'$$���Mv����Ul�qW!��pk�*�M���`�����1*Z<�W�����h��G��Rqt��y/���z���L�td���Rn�L�d>#(3������:c�/��n��9\�6BQ�lh���d�
�4����*�M���KjN9��!E��P�C��)����Q)�I����vHV�#�]�2h�fN�f����^�M���jX�Y�S��*z�kk�i���y~�5;Zp����4�����&��D�p��!�#|(�@���V�W���8����\H�hxe���:ME�Of�^�?B�;����x{u�n����W?]��oS|��������/Nk����"�����{�c`JE�"a������,�vJvjA��!�����M0�H�j
�n����&N��Y��F�����tN]�
T�!������[�pR"l�r�H�p8km��J����:���X�@'����UR$*8����M��������	���^����X���9�
��%q������6��1N���2�`I��#;��d-�JT%��O���;U��*6f�*���T���*sHf�5%�U3c�w�@��#w9��w-����O@���(Y,�y��#4���j��C�,-e�D&��Q�iX��m�\��g�5��F�)
���R�th�����%�J
��}�{y*s+{�"�D	a�!P?�#]�|���@�+p"V�@�~`j��'60�1F<�?������`����{b�S���c������aWF/r�i�c�d���M�t/�N������Z�����Q�����8��/��*)g��\���G�����=80T�_��lW�(����Y �&�?F
���U��vB)7�Y���o%�Q��A :#���(mP@��-��#�?Z%�����9@�T�� �������6.l�C��P�e��$���(y���1�~�����2������)�L���6�O��^�c�2��g��E�d[�����{u�kww������z�|pw�-x
?��Fh��J��l���w��g��
�����-%$��o�.���F��6����kP�"�<�y�b�_{�`;�H��bE6��I�$��1�
��B:>q
kl������"_a�%GqAI�!uC]%;���t��|���[m��+�����}������yJ��vY� z�?'2��J�C�S
pE���
�T>"8���`R���s�;�}�����$w�)�vc�
�\�B�-\�Q7U��,���C��R�)2��:L e�U0qMmFk��Ku�
u����mY�24��rxy�
�EJ���E�Jb��9n�R�<J�=�q2�V��{��7���5��Q�(yi��
�QD`�	��%�y���Mw��������o5�9���\��a�M�A��a��#��oSi��+������g�������NK�������-u ���>��w:��|\r�^�
����8���/c�C���%������B`��c@10�\y:�K����Q���B���wJ�&?��9Qb����xitH5�����E�O��`yC�� VC~�qc�������7L;n1�"��<����08[_���c��"��7�(j%{�vz�S�?��BS���E�2m4&TRb]6�ur��H����R�{���P[����S����ag��.�&LX=��t0��;'(X��v17|������C�Cx���!��,�����`FnE���A�		��t���5��
��0)1 �@M9)	)!��k2� ���B�-H������6�&a�lp�i����&�6
���H,5sJ�j���<�0Yf
�$=~���,��@#�0S��b�Kb�4�y���m�NV1�3k�]�M%�k8��*9\���Z�j/^(q����&��tYq(�Ka�����p��
�~�9�@��n�X�d
��]&��-���F�]��[	�-�
o����a��sG4{�}G��`Vi��g��>�R�����"�����6��W�$e��!�	����A��(�AB-���c���E�8���h&.�2���SH-��������{�Ip��I��w��m����RP��!q1�;,��rY��%��p]�����v3bY�<�
w�Z��k��Jxf2��]��TkX���	P%r���q����bz@�`�O����BG2�q����&s�k�([��L������s]ub!X%�9	����]}��[�[���-�,$l��?�nWg���
e��8}c�{�S����L�[���>�a��)7����:
���y�������./��,K���yQ����Ig��p�Z�v��M�������2�]�e�!y��3^�~��La�[�s��%���l���
�>�eST�2�;C��2����N<�g��[QJ_�����d���^�H���8�VX��u�����5����HL$H��{���`%�z���vr���^����Y��/z�����lx�����|�s�t���?�#��{Qx���b��p6�%���O��$��h��y�u1:������{7�����i>M���������3���H�qEi���n��|��i���]p��EB@jr������=b��b���9���!>6 �����/����aaL?��4`~�?��p>�,�I�Q�V2�`���CqD��Vk4�w���|4�B��}"�D��C�&eA|w:]�U�G�+���A��h���8��3cI���<B K!� ���/�0�.���Q�}��&�L�:6Z�Y��h����S�G�����h�I���8����d��y@Od)��c��U�SE�L ��.�����k�}V�zaT���A9�#Q8�b�A���/�8����������B[r�P�#/�^n�e�_AZ����\�Q*�&��$

q9BG��o,����`c�7���m�l������\B$C�>���P�Ywm���R��������+t�)��D��2���X
�1�J\�!��q������bu��a�e�����P�;�Pk#�X����p"��o��n������7o�����N_^]���I�5�in|��*
�c������W,B���:Eb�Z�����r_-�
��v
���7�i��7����C��f�)k~�O�������o\�wzu�	,Roq?���O%&�:C��^g�E0A.P@JR���|+�S���������>
���H�uJ��Scp��b��;W?rPi������MD0�(La�1j��kn��#�&���h~CU����,LO���7>u��XI'���5�=�hl���Yj���
a��i�|�<��>�?����'3� %y����������.<������L5A����:�8��\x����X)+vn*��0��!�O����O�
vv�_�qDk@�����uB�
}�:K��%����)��n.��-	G�!���+e�����Mkui� ����H���t8�����V�����dx)F�W�F��
�c/)��H����K
����n<��u'V���;���
���X���i(�$�y�M%��[���xv,�f�{�O����
���(K��T�VJ�j����f���7����v�T��Je�BK��I�-��xs-�{����L�>K������5����A�
x*5!�
oV*���3�;t�9�_�~9������\:�Rs����L�m������w"
%V��I���p��;��l!��3w��a��w�I��R,�7$����F���O����~w���x]Y^��R0��JUW����_)q�2NC�>8�����o���Ni`. ����'?���^��|s:=y����r�������/�x
�"���$^�KY ��
W�x����\���K��a��o�2����+���S:���j��nl��Q�Nk9k�q�6��|R/����l
�)�{���;T>a��(�gSE���j���~s��#YxM��6r$q-�Y5�7OO<o ��bW�a�����w�7�����+���Z���%89b�.
��LN�Q�E6<Y�����o��^"zY����
�$���O)%i"�����^HmJf���k�-����/���;wP�q���R������tq�R:F$S`�� -Oa�z��YS*�E5�|���Jr��1�)�)Rr;^������e��C(|YyHQ�W��v=���9��@�����OY=#4�cc%��h(�������h!>d�#)��|��C�E�(�^4gn48��}�B�'���n:>�d��*� �S��"�����^+���]�<�����M�!��K����V'FN8�P�X"��e��1�K��J�����
�J��(x�p����w;��
�`��;V_t�^#>���0 ��������[�n�dt�����Dv�-���>OU�w��g���9!���7�k����)��z�P��v�<
��f����y��\~���]������Mf)�+��;��{�����\Eg%1�0�<��]��F�1�}�+O�|�l���Y��I�=3�N,!�x��@�������v�w��GN�w(}B�p��Q;�U
B����*Z���E�&R����
��:���O
o��S�9
�7����g�f��\���{�-��^�&ZC�$��=5�Ym3T�`�B�����4�9����U4G��n�}��5� �/w������� �?15@n�(�Df3�� ���N�
��7�t����x
2��H��������
���h(�;��Id�	E}�B��Z%�Vd2�(��<T��H�:���q.�K��E�X�Ac��7w����J������&����n1���x<�\O��%2�'����s�5�0�cyB��kOi���|��A�-��,�����Boh)��[| `SO������|���(`����o�N�a�TB#�1D�:lO�Q�w8����Xz�s;�'p]:�8!)arGH�g�	T�-C�'�)���d�}��P���YCM��v��� !=�2�����,�C�
@�������^ !������������-�8�s�afEa�GK�&������8sSm^*�T��[����:F���=�Lj��������Bu�D�����TK��)������(=E�+����Y�����cR2'wF������C�$
q��00|�9)4�SY�����/��b�&"�"�-�����+�u��p���?�?s<��HM���cT]�`��e*u���I��t�!�">'����	p@���X�������#�y�B�����}oq�\?��� ���6�
)��2�B9u���@
��~�B������?T}�n��,���
�b"
���RM�
M?�Pi5D����/71u�Bcy�i%?����4V@@;��"���<����|6	F"AfB��O�ui�b[
S��%�2�{3��SG�Q�C�0o1��&�f����ap�z�p0a>�������0
��NFG\�6�.q���["C��1�L(��7/��R�6���v{<!}�{����[
�
u��55X��
v���E}Q�P�Nan������K�{2��{�����W���{��F�[�&��0��]��P��ypcv��cz�����lb�$�bw�Y&�� 9�Lv��0���,�I�\Q�����t�"��@��X-�\�&�X6?���1l�a��P��[�$^N��M\��{�[HL���8y���b8RP� ��_|wls1&���hy�n�*�G���|�����c��vl������7��H���u�����N���q?�/�E�r`����L��
�X������o��J������M���$�\��H^�G�9���#���;��kD�r����>b&��t��<���}��@x"����j�
���+��������;&�?L���==�n���KC�?��j��1+WZt���X��N���p��2%n�#���E��epO���8��)#����E�L ��G 3�u��%����7<�����E��ix�����GQ)��82��H���@��}e�r/������
vT��\K&�q�7�������
���d2�NvG,:��&��������16��MN�KV"�N] ��]���k�|�Ze�K��Z$d_�O�o�1�k��,]M����86K������M�h�7�07Ri>=Vn���
Q5-���z�A.�u��n�T��6�KW��n��mvN<�p����o��bq���Vp���$�6���~/!f^/A�i���NY�e��.�%�6��^����������	+#�����`�B�ep82�9��s����M����s@~����HB�_H�chy9�dF��E�
�U���N�c��������
���Fz�
G�Iw��C����'�a8
&��@1woE��nG��%Z�eAb������K
�-M�0��e��ab��J��k�16�`�`�a��`
�V�ic���
	t
� 7�L��6��`��3!�����;P[�Q{,K�!��8��y}ru����1���C����=�������3	B�l�"q�z
asT��������}��D��3!������D`;�����uT��\�
8���U���m�VsU
��G�[������E�������\���-���=y���U-�
/�pl�4�{�M�����!?|F�P>���j]�a*�7��Qv��4r�c�h
�p�139��B�S��}��`E
�M�2[��&��b��d�l�Wf����������z<��~��srT1�J��>}����
�k�yTg}��k�u%��q��8�=��
i;�����?���O�W�W?�����e4I
x�S/�Qr��HTh�du;���|(�t���������L&�V�?���"V�B)tT��
M~�L��,K�����f��O����u�����]��R���&P3=[_�o���GAZ;��@��
�m�{��E�
�:�DIS��!�#������ ��)>�sR}�����[��/�xD	q�}�J�����5h�*������������d.��#���e�mb�E�Af�&�����}�[�K9e����s�����)Q�x�{$�sbfKA� �u����Qp,���d�WB��������JP1���s\�i�x�i��o��w�tYk���/���b�e�`���g������k���{,�J�*��`��_�F,�YO:\c�@�W*\��Qv��=NOW�}�L�<+�rN��L&�����&��P��
���L�h�I_����!�j�
e���`�
�d~`�wz�b0[��p�����d���n��
n�I���.'@s��!���w6���	���s(}f��[����������Z�����p��cd?�� [ K6B�lT�
U|�j���r��?�R��V��N���J�n��f��UAi�	0[�������_�s�����h}
��A�MeZe��X�R��9K�Q �ugl���_Lk�sg��{E����E�.kc���e��6��B������2yq����:������������\v�8�)�u}X]�Bs_����Sa���n�����
����M����������:�%X�Et	��B*���c�~��z���\����%�9Z*/t��!�xUd{�$'�B.�`+����a� �R9�<��l(
'��i�
`��U���6����&�����Q�����@*
������D�y�V.>��L??��#��� B�	5�.#�����_&\o�pJS}i<�W�L[Hf#����8��S1]�D
f5i�;2s����Z`v0����k�
��\���/eZ���d��8y�>q*�����a�n���u��W�v�M���&����[��������@W�A�6��sfEFi|5J3"'^?�4�S�L2mc�/_O�f�� L�_W��v,�����f(XKv�uvu���p~iU�iy������`�)� Z�sK�v��.~�pR��
n�T�QL����&%.�nCv.�;sx�(uC5 1�+g|AGF!3yIsi3G����@��O�Og���X:��h������P���*��i�!�U�o��I�Q({�T�~��_���	�G��Lq�� �|D�	�
KYW���T%������k���i�>*�|����U
p�K���������W6������}����3(�At\
����FS�`�e�qh��<�p6�����o1�#��0
�@�2,���Z�����w�P�%9o�~�x�$��}�������O�%�%��l��b����	m��"�o#��_��a����9�C'��,M�(=�R�C��*���r�U��0�R��D���Y�N�c��/o�oaXJgu�q�OO�cv�������2['���!�`�U,�&k�E�k�T��j9G��#����#/^LP���D��Q����G���fR�AHr��GL��_�y�FF��"&U�Sk��g�=U{������[������f[F���,.'�����;��r@�7���i��
�����V����
���D����N�q�"�����?�KE�l��;�)%P����Y.�0�Rv
?���F3\B6�
t	D^�����d82��W���~�/�)�VTn�z��u2N�����Ua<1��2K���$���_���>�u���WH�|�WSz^o�K���O���C�g���9:����n��,~��r����$��} a���I9�xFe�m�ZoW��7�>9SOt������R�N!�Z�>P��,9����G�����g�Z��!V*Us���d�H����e�6Y����A�9�xC@jn���s�e
�Y�&W�<Oi8-n�K��.C�Z`
+���������
H�0|��WI���VHh�u~��}�3�N_J��$�L���z�o�^�Cd��6:�{AE�2`�uHp*
G�\R��ST��d��I7�$� ���:�r�^��Nux��}���_Y'bFs��CQ��m���cjE��E���hF�c�`��	�
;���h��oRZ�&����6�l�xb*���`���K������p�$��������+��!J]���fI�?�k��k0�U�������n��J���/��G�U����D��*���T��;�/z}�=?�����ro�f�K�"�tsK+.X�R��\+v��{�`<��;�n�5�G� ��U��e���a�[R
0���?���+��?K�!xB����.~E��R	p��|�V���,@+
���m;���Anw�������~g�m����"og��������y�F�,Wp����Nw�-3����^~w.9����
��k��%���R�|�:��o�(�m������=��?���T~'�43�RH���cJN/.�/)�"s�c�i��6����Fn�^*���\��yOZ��U���(��V������'��b��V����y7�����N+IW�9�`B����x�[o0K�krm��J�8V,�������b�C�/j��
�A�eo�o��I���P8`��U��E1��G_��w&�;��'}���W�Q�������������I�J?V�:�
�w9%R�d����s;9"��v��}(�f;[F����X�dY��b�
���
�����`�+���vXI=�����N �U@!������!"��^����N���6}������(Q��k��<�3�N��60�8�
�:0��<���L_�$�
d2���B�8}�a=����������	!�Ct�p|����
F}���A�v��&��X$�q�	4vDP�}�d
�'�f���IB������P=���x>��cS�c%����������I�������24��M.����[@A���R.1��2��*�8l~��A>������8h����v?#���
��T-2�B��V��d��Cb��o~+��0�s�j%��>�O�0)��Bu����P�=��
��n������bW��_l��E��n���?�����cl�#��b�QI3`��a�8r��U@5�xw<J�g������t������`�}F�I� ��L�FCY��w ��22�#�3�#��`$�*�L�%���}����M������zG����dv���A.4`���5���#*v�����w?�{�z���-�����T���t��M��7�9��1Z�P8��~K����*�<V99���<U��/

���m$c���`��:32sI��Jx���?SX#��Y��������V������e*8�Lu)���f�bN���}_�	�����xl��0���D���O�*f�#t���X#��?�N����?'r~�f���WW���4��8��V���c7]�o�kyO��\@��^��Rr�5��N��Fg�L���c��evO��fR� ����v%!f�-����~�G���o
���i��n����	9
{b��2g8�H�IX3����=YG��s-8��Vy<K�����W������v�)����q�n��@���V���v!a��
�Y�����������������]��2y�J��^��:�U�����
�������G���@�
�&����j��GS�$F��|�l���T@:���_��~�?m�?[�Yr���}akB� }I0����P 2 �x'��}V����s�R��':�m:��)����X��U�� E#?{���(���0��p��s��=�^L���z������\V���*S$�@������l�/���(��K��:U2����\��$��D�2[��Z!��y��<Fp#Z�a&���
�1��� �js�QWq-�*����B�t4b���K������_p���F&I�������q��������7��f���foUb������<�[��R����''�%��uAF1�fq�\�R��B�xsW��V�>&�~�;�/��n{����O%���#o���+b�� 4��,�F����X�8�������m���K���6H���B&	8�2�~Q�_H,a4�h  X88U���5$�7w� �B	rY�v��#���[h�\��L�����=j�@�>�?���H:���PO.���U
YN�o��`k�����rT��1�f�s����q�$k���K���,7�J�o���	G0�����
�@�y0�Lc�h?���l��T�Z9{� %V;
wD�2��Z��$�p�����G5�{�-F�Ta����mz7
f5,��u�n)���Q
\��{���@
����~���?}���T��7��V���=���F%F���)�X��x��A����	%�f+�}�K��P�9��p�#�r��\IjqM�ClW
�/�U�q�
Rx�dd�!��y�_(�h2��}.��bt�f�����O2���7���~yry:}uqzru���xv1�|����
���?�-^���GJ��6���J%3F�F�E3F�E�H2�%h��������l������q�=e��G2�{%�:?Y;��S��)��-�7m�f?����e~��R|
�a:n�3�����"�~��b��r�QEy"pi�?����tCF�!#�����!N#�C�o����&��Q�'�^{
q>�w�yw^������?4��� r�4&����[&��9�u{=������{>B�-���5�jt���;,������������Y�S�.��X�P�����k���B�P[Y�I����J0���w:�rOV�{Txp�$.�8=-Z��������PZ-	0�:�;�/����]l�l��������� �����e�5�]���G���?�|
$����K���9�����g���Vb�8p/Gk(K"��E����'�M�q*���h"���$u�v����^��~�i7;� �f3�<u1���N�.��w�v�D�A�)D����m�����)��Y��a�����lv�(�&�s)�P��(��'�}��FUN���f��Si����PP*�f9g�������#�a9����PF/R����}�4n����7eQ��+)�������`&M"F+��o���Z�C���04%��Q�S�����;��+4.!�N�Pm��3�ty������G��e�.)��#����9��ZUF�C"�0������������?�����"��4��i�Y�y������Z����K
���W	2a��G�p��?���C��:�4��1��+E�����h&�P"�	eLB����:�xb�Q�g\��;bw�t���P;�>�+�}�`,y�=�q��s��%��������FN��}8/.1a�������;�*.��;��BS�6~���D���C�J�W��5����C�����G���$O����_��H|������O����5\90������A�
�i�I�6��5�$��z������D�e\�Ga�������vy0�wy������<����
R�|���/����c�����}�ytq6�A���Q���t1� ��=/�gDi�;�6��_�}~�m�1<Y.k�'���F�8�GVUK��@tCSk�����Kf�M��>Kv1^����������_N�#��!�K�T�t:C�u��_��!R�RQ�I�z��?���1���� ��P�p����E������j����8�:������.�lG�9(��)$����j���
�o#2���1p�V���9P��A��~<�����?��9{���	���wkP��R|���~��������&�����0|��*c�ee���n�����w�*�g�<��@����Y8�?p:����t��;+��s����C�|���sL�e��`�~�>�>��I�J�k_��__�k�__�`�����!�5�lL��h��q�������zg�<����
��qv�9�R���DvcI
������~T������g"�  3����/-�����3�.
���%b�N{�]�*�&�L���D����f`z�9��Ap������O����X�e�Xx�,=�`�d�t���tsV0�9��N��yT#�Z�	������Z��#O<�>n�t(=:�S{QE���h=�#����D:~=����+$j�2
=�7�5��JNbu �s�	0�\u��W6*�[��j88�����YP;f�=F�)�=c�aI��&2�C������:�.�T��
�e�N4<���Q!G4�Q�&�F�f�%��]�iMa<c�q��c3Y$K�d��KJ�sb�k��yv���7?Z������';�,���C��>t�_���x���==�9����niGF;:;����"�tT^�,�AK�)Ns6����F���7&���XW0��
4��daG��"�K;�?�NW����V���F�����������v��������J)
S�S�-�^3�C �0V:%�L�J��DP��=|�dd�2|��QO}^�]����+��#IzC�8�D$�4i�=�7}Y�+�xX"�����:K�R��s�WL��O��|�
�������r���N���6T���c�iY���8�7�v����3{���A�3^�Z�`0�(h������R�V��T�|h�a{��z���n��\'~���
�) X�'DA
F��u�����8{�].k���{��kzC�]���%nI28a5����\DI����d�����LJ�;����
4��r���4V����a,sbt�e.��]�C���UR�>.�%fb^a��`����;������:���,b���C�)'�������g�:�T����1yt�n�5�_dXw}�19�l�y�pCUU�Mf?��Z
+9F������h>'�{���u|?=��-;9��Gt��ul�yj3��>2c����(�a��4��������/�a+���x�M�����W+�	��3��\T�*����s����x������p�	����![������I�O��S�����a����DpY�B3�g+���62�g�r�C� ����8�S�����&q�b���h�1I��_���5�T<F�'wu������A���o�]k4F���H�U�-�v������W
�JK�a-UWR��4K��9��
@�t�����G����5G
�o
���'~�.��^���"�}�����X��(��y�/�*Z��V/XE��,.gr��sA{6�����D�z�\���O���Y�4��<�rXN6�ON2+k�+*�W����dP[8��'�p1��Z�`��A�?���K�+^v%
)�R����6Z�/j�7�Bw�����2����q�V��������T������Gq�N��/8�3.z8�"��B{��)��E�$)�5�������v��ug2c~���Vr��������\0)�8{���������=�%�C�?�:�?�w�q2�b���v��k�5�<A��a<"F���vc�GB@	 -�z�b��
d���,E]�Q�[���"<_���dY	�,L)�!RqG�)Q�f�vg�;��s;j�JV

��]j����Gm����#3w�C��QT$�����`>8�2�s��a�<r�e$����)��J�B��p�	��D�������E)Sa�BB���i�G	i���}�����H�M��j�O�]���d&�b��)�>3r_Y� �[����:� �u��e�e����wc��PC�t�/�O�~D1�gY�zT�q�"��[���o�~��o�D�~*�X�a+���,4�zQ-�
D���p���7���z�z'������D)��sT��t��0^0���\�7�GF4Q��E��e��jmm��.K��96bJX/��D	Z������}i'���<������
B�^��������#*�9�O��[>�$��m*Q�r��4BH���X��)������rG�Z����t)��PQSY�J�v�G�N�������1�2�6J����]kD�����������t#�Q����X���+��:W��)��*�r�F�������8u���&��o�s.9�J2��P4=�������(��^P�t��tH���=��~g����Q�,�S�u`TP�&�i��RC����"�Z�
�I>�i X
hV�"+��W
K`����
�
�@�*XBx�������6����|�0��s�s��#�4FF�>�N	Zt�e6%��d�PA��k.���H��fi�
�s�d�w��~��E�)-�W�P��|_'�����t���l����=�[��,���&V=�
/��y��6��r����(�aJ.9�09�f�T����\h+����SlEp"������F�6�L�*���l��s��r0	EY��}��Y�I���~��B����#6�&�O`�9<��_	vC�r*��X�����L��f
��c�um���b�$��G<��'�{W�T}o����[q�&�`����1x���;���$7��T�X\D�g����v��e���"��Wocq
d
��U�Z���KKVD�����d�����a3��D�B��N��n�1 Bz��� �9C8YQf���E����B��C���'�PJ��9���:�j���n�Q�
E�4�S�X��Co�~�|z,E�_���%
:��#d�:��\0D�h�e���q��"'�;��!
XB�n����
�F����W����*�X��80/�l�o$xHJ�W[�����`<a_p4�q8�����B���V05��PL��	#���(�f�2��VT���6D������Pd�����!�+�'���i&D�E��o����������/^�w��,^������=�f����9���"R>ZeW����6Iz-\C,��W����g��KT ���f��R�h�������\�KcRfl-'cv����>/�>�t7����C�����9\�u�����5
��>�#�q��"��.Y'��t�����c�
V��q+,�������i����O
��������=�C��~|1�m���M$P+������U3����a64��39�Y����C��$A��,oF����Xo9�CH
F��o}������h:"�e�\f�����%G{�K�!Yh~?�j{�K�����0����o��
9�k��_TJ�����F��A��`@�������JF�B5Q~
�D�,V_�u�/@�E��x�M&���R7t���d��|7j���e������%y
*}�
Y��3�!��Q���N
q��RT`�Y��� ��5��gQ&(>|�l��3���7��<O���-��%Y���u���9�UC��0���#���D�$����/Hh����d��6����F9J������&$\�RO]q}�MI��������N��h
S���t)(�,������|���ZW4���XGe����t�������W?�]�%��^�}�U�,���8��*X����=�l��qK��2Wh����0:w,s����������l�9BR$sXy����s���^��s7��i_l
��~>C�?�$1*���

�����}� l����������^��#Yl��d�BU=?��c�<L�J���������^�V`�:j������$=}������-�/k��*�e�
r����!��arl�V��������nv������7\_g7���x����U�'A�"o����4�(�^���
%w��fgO�v�����c��>�Y6���5�z���3��J"�1��z�vca1l�?����j����AJ����j��d���y��L�O�N���m���6��3�H%x�^��q��@��or��-�#ey�x� ��xrsTK}�m	���B��_&P�������a��ub�������xdp+��Q.��0�@�����0M�Z�><
��m�h����m��6^�����C��3�r��P���S��S^<u�{�dX��G[�"����d�9���o��������K��&R�����u#�3�i�����z����<}
�j������7��
o
�����>J���o���*#iU��T
���	y8
n}�a&�U������th�%`
B&�c]��#6mJ��)���q@���P��~}!m�e��{��$�KTx�Z9�
@�z��|e����q�t�X8��;2"��L�kz����i`,����V;�n�;���� ���Tt_��
��X��Z��8��"
�?+��������;���{O� �	i*�v�lA6�(�/���Mvu�c�0��X����W�x DZZ���q�v���I���gN����Je*�{iv�x�d��\���_���H�S��g�
X�������.M�����b���I}��jd3��-��P+����S�P���X5z��0�=�jF��R>Bn��8�w�hK�;�nH�� �D��C}����BkZf���5���It��)`
LM��*hR��I�|�d��{���>����������F��G�_3!{�*�K���� B�R�F�%q�D����m�6oe_��=�W�S���|�?2z��2���)��GY�2��=����#��
�	�2@z�C`����
�
�����6���$n��������K��e�
���b����y+��o���&%�@-�'��e@���*������j`;L1�h��qUU�rVf*�.C�����,W����2��U����X�U���Q����x�93;�v�1���1����E��~�����I��b%�.��HAV�#^��F�y�cU��2�������R���v��z����2�.���
�i��p���f��d����/����Nw8��>L���L5�W�$���A��gxp�ez���E�Y�
���u��O�0@�Q�dz
	F�����~��p~1={wuzq�������2u�������a�D�������t���A��[�*#�PK��h�p�i�F���b���G|�l��Q�Ej���c����g�iI�0kZ�A���!0�1G��t�J��J�"	����S�+�,��~�J*be���������bNc��
3��e'�_Y@se,��2��;H���+�U�j�9\.r
4�?�����={Zk����>�}���������4��Cvp�tMzF��\D{�
�r�
iK�}��B�P���� =��x��u�n:�
��aM8����-��2�c���I�?���i<�8�=<�noB�cz�{�����4[�Fe�m���Ut}�	x�^�79���SH���u2�������+t�C�5������
��(��PA�M�$�Z0:4���~6I�1
�a�KVD
rZ#��/baE?��1�>��N�������<�1�81I���&M��s	n�|�(r���(��EpF�b�3$	�Y�>�i��m
�*��_?hU���Weq��,��2G�w�}��z��HK����0�5���?�ni:l.����t� �

BNzi����aP�{�pU�OG�R�(�"-ZiVT�����/a
�+U��������\��|���bA�����J����(����
��aP(i�����f�e�R�-91��r��������d�w�pG���3��{�q������4}A�9D#q"�F�
�����C*������!���\���v����eg�������l8aE	����n
���A��N�g�z�%a>���=[e����������j`/�][)/�����i2� A��Q����f���3fmC�;G/�|���(y	
�.�������=k���pR!�L�����h
��8-3��YHR���I������W�"Md;�vF���;��������I�1����o���TE��P���J��6�iy��1f��\���G���yp��,J?x��
|��A�w�N];�&��������%���72�
�gR;4vc�2[���T��f���n��01�hU,(k�1V�w�0�o��,��Fqj�
dI�nP�(���nip����]a�/����$7i�A�;��.*��v;�6�����f�&�9��c�(���D�w1��fX��[<�)�z��X9.���@�9���D]p�-��������T��������z��2\B��3)9�
����&�:7��hf�T������� �>m�������������<�[�����g�&���1�{��'")��}nC��I�<���f���~�Q`����	��\�q�uq?��m,���=\��Y
%k�{��|4��[�Ag�{��h���5�������Q6�:r��,'G\3���0�2��
#���+�Z��5C�l�apn���~��^{*nu��/���y��L2��(�����
��c6���~�A���Z��`1����(�s_�wl��v�0�?��M��������i����6�("�9��=�����|������K���6Z=�O���C}�r�P)�N��A�a�f�1k�P�wl��
�����(������
����yU�@�=���I~�j0���[�����_��������{�(&�K��+��RS�i�w��������#cou���j��:�	,@�AW`i�,A��������\y���T�����N�x.���v#�W��9��!�Mg��P)�M��1M����A�[�������:�y������}�4��+,��X"������:��#.�L4N�U�y��y�6�������'���}����Nx����/�
hZ���
 �S�7`W~�LS4����<�pF���E��������%�g'$���k7.��
�-��S���n/���wq���S����+��w{���!r�V���-Z!+c��=���:Aa�7�q�������<�d��M�co��(R���AM����9��W7�L��d�	0�\�Z�A$&���K%5�W��dw9�������h;B����L��1_��XX��]w��B[`�����:������jo����q����oG����>�l�����(j��dCg�G�����U��U1(����OtQ]�-�nFJ���n
D.O����2D�z��\�[�����C�+F1�.�T|aH��3�p�~��(�P���8=����ZR�-������DgT����~8���9�������S�x���=�j���;:���#���J�x��,��G�D��$Y���B�~��b|�<�R�>E�t��[��d!c�8���H�~Oz%�����k`��"�P�>�o�w�q����vC�i��C����UA�Y��C����W
���M����8\�N��N.~�&g�Gs�v����Z(�����l���)�c�T;�ZJ�-��}O��������'L}���d�fb
�z��p$�8j�
b;�|g5*|�w����P8rh�Q6��
-	�"�'�O��2��=�!
"�����Fkx�
��7K�{,��"���]�:N��^�Fv�1�!#c��0��?��6��R	Y��Tew*���Z.tQ]�Y�7wz�W�Z�wN��Q���������Oz�m����8�����u9�����$Q�u��B�;�rQS�����t#-�P�S�����U�qs
�����T���;�V��;v�G��u3��
��c����E���l)���P��\��x�i�f�a���e��?;�A�Qh������h�v
��h�X���i�ES�O��3�SL�`���D
M��.��zUT#�����k�s�F��'.�0g�mx��o����D�.
C{!��~�)��j�W����?Z;V���d"J�?�{������V��9x��Fih���q^z/��(��3s'����hck\�&��F`�b�s�T���N��T6����qw<���y�5X�N/O���J��e7U
)Y����rh�M('k7�f��f�
O:;�3�������U��{�w�Me�q���@��7��kt�i��:�2�VmV.��^$X��V"�/(���
�97�;>Zp1�E�%k=��4��F��(�
���;R��v����-!Q�����9,Q%����BqSw�������`F�*j����h
>cH��1A�R���0�C~9�mT;��
Y����~>�b������t�4�p
��4���;������v��aD��	����c�m�wS��G	�����\�r�R7W���n�L�#��_5�]�|9���*�[f�7�=�m��oSi�~�+S��X�S�e���*���d�\��
�"H���T.	�!%Qg��J
q[@/V�3���3Me
��	���B<$X�j����v�R}Nd�KS�@=M7�,�@�����3�9X�o7Uh�����p�(���y(t�������y���bx��7�i�U����v���t3��p�4N^nj��a��v���XI�����fl���y}���+��Em���mZS�X���F�%��>S}�6|�$�9��j�~��5�o��Q��V��&�'�R�Q�1F��<�gU���m�
���I�;��SL*�R�Q��(��}p��*�����x���]��h��ud���	�\�����d�]>v�/�q
\����:jBV���[�`�5�?c���;��L�[W�R�w
��T�����G�X��x���{�R]���JK'��,��B��?f`vL���v��p�3��z]�n���?FawP�>)���A)oK�����_�<��iv-�,�_T�V��*���B�����D��Zj]
j?���A���Kt��
��3���6�j)3J����0����
�(n
���E���E1�lvI}����*N�dG�2x�������e(�a8o@�sH\���
��)l'"��R��(3A�H�0���c�5TT���qFbFK}�p�**)�6����U��1�����:��P��I��
w����$�`��I���TB��������#2[T-��9_�5B2����[&��^'����9�E�:�7e�"����~H���u��PaT9tj����}��G����$��J��t:���7���`0D�"Z��?�-i��PA|����
���-���[`�`G�I���7X���(u��97b��z~��x���'��]�d8��i8��5`zX�z#�F�+�a����wgh��}�/wP�?K=l"K���4-�{4eY��t�G�E���&m/���R�X������:lQ�b�qi��)������W�f�q�
BFe�C
���a7�`�j���v��h�)S���U�������
�V��g��Xk�U��	����qQO�!6QVa�|�����n�����i�iO�#��3x��<&�TQ����^���F����������k#t�J����$L����0%���[m�u�����`���n��������?e7��H\�)_]:�/��%�m����!��;S�|�������;���0����I8�
�����f���p��L]��U����"/����
��M�1p���u��4;6�'?�w I��BM]�e���~�r�GG/�N!�2�l��wdJ�`�
�R��!�D}p,����o~:{�z�������Oem�v�#X61��wX��X4�;����w�N$���X��W�B8���������dq5*\/~��an�����k������4B���E��t���Hl��!?�*6L��)9�^w8���Y�j	�w�}6��b�T_���j�:�!�C��y ��=&g����b�{2Y]�C�s��~��R>LH�Mj�W���_�h6;����j�(����K�4n���;�����!���t�-�sI���.�B�
���r1_�GE<�����]K�����nA��c�pf&���&J���Zw�=�w�����-YbD*�Q�jx��kOy��H6=��M�R?���C��	KI[n�yF?��������]��6)P����
�`6��a�;o��`��f�`4�	��n��o�deF���oO"�E���-Kt�v���h#u��Pyl%T��lW.dr��^�����7�c���1/���/�3����3�����y��E��^G6ez#��`�������
����.���a�Fu��Q��F�*Qw�O��n*��@������x�������Q1������v���H�+��N�fE!����8��(��"�p[��{�[E���q��#o���G	�N�CHN$z���������jR��4F3����7' B�&��<�,U����{.��2����LL��j�V��$�B��u����d`%��H���a8\���`
����?�Y�_u$���N���^���|v��#�3�T���M��|�G���m��]<j�x
)���v���2���Pge*�`�1Dc��PJ��R�����_��O�����+���?+��t�	_K��[���~�&������������w���B
|sz����B��7����I���-r��������H�(��#��cVy�l�.$��������l(Da�\d@��&�<Bx���������9}u5}w~5={��.N��������������N��OW�u��9�z�

PG(�X�__�k�__cY�c��,�TX>��_�sGU*'�7m�;��N��>�.DPq�]_����J�9�e�A�2
����j"���Yo�'�A����N������/���T��Ix��6����L��n:z]���b[z��YV���/K�7e���0
W?;�h�zA��=?��'��Bm��{��H��y��p��-�|��H��o�xB��em�6/����$�T����O���+���sSR^��$��d��#T}c��m��E���_��u���^r�4�(�T9��qN��w����"�1�
k�'`
+���	���*�b�A�f��!�.
� W<8�C�*9@���j�����r$�m�~v�� b���4��R�6��
ND
����&\�/��r�#��9�|/���i�����h���`�bI�e��8}DX��E
��B�p[�M��������r1���7��:�K���ey��rm�jn/����/;�;��Hsm��������<�X�)�)�	���r�Z{tu���221CV��������C��eI	Y���3,N�d)!�P�H(T��x2������M����[?������d��v�������C�6����a�����V+�M��E8&�����qD�v����*��e�����?6[T�����g;�>��@]$�w�B���-�,=�����=_��@<�
TI�f72�j��o!E6{��������,�V:{;���)�K��x`��W��H�����s�r+�9y��s��2�<��<���>'���X������'C�
4�
;��|�s8��t��cI��������lC�'���W��d���$L�%�)G}9�.����Y����{���F�qH�k�U�P���o�w����E]��[qU�|�x�����gb��puD�������Y�J����a_�E���]������3jEg�D����������s��qM<��plH�;�Fr��y���>�-���k���^����N�=��������Z�qCM�@�{
*��OO�������m���uf��p\gbwK��p��OIo`���M�`P��6��Q��7����b���U�x
�Z����j��	`��.yB��5K"�Q�raW�|�_L��
�	�0�*�`�Bo}No3�UauF���-iK������Fp��9���t�B�O��r ������;�Mp���x=����z%����,8�@P��)������Wy��:�y�1���:�:Vym�������V(|��k!$?���!������:�E�g����5��gF�c����s��0���P����U�����/
�B0s�\42�������J���B���������
�6!odZ������FpA	�sv��^~xw�{y2����V�t
$�/����X���|�E�w/��t������V:J�/H����)M�Q,����+b^��[	a�w�x�d�|�2U�rJ��H���_6t��%Z��%i��Y=,,(T ��6���7U�,�;�Y�=H$�$��#� ����&eiS��1J����.����y+�*L�H�le�]��������������:�/i
��lkQ�]T�{f>��3���\dX�{C�i���W�r[����h�0�~F�TP?G����N�S����'�q���;3�vf>;V�z0�!�I``�D���e�*Y�U(PB�J�I��E_�F�g�K���m<i"�Gx"���l)�*@�j"��x�>��
��w9�w�7/�N�
0?��A	�]%[H=���$&b?p'�e��/�=L��CPPo����"m��Zhm�D%��a����u�#_�=FR�cD�/��<� =`A�Gv-H�FY��j@�
���z���f�C��@8��/�!���8�H�����(2"g���8S �b�e������)��J �r����G[�t/l�Wa�z]���������z�����U
u�]$�=���q��T�A�_e�j�O���Ee\�Y�a�
�����`�ts��rv�"~������,��4��Tw�(�HN~px�E��]��#�v���6���������)�B����?�RmY�������]�.M�v	5�+�[��s�e)��)N��Qj2�{X+�;��I���
����q"���"*�K���J���Y��������5e4,Ue��|��E��3�3A�����14�8��Kf��h�`�n��C��Z���3�'�0�3N����1��q��[��i���{u"2MA%�rf��(�\�#'9z�<J���o��:��Z����4 bSl5�7N&�7���oN�����U�f��l4�E�[-��;����s�6K;*���&(��N N����zUHL
U��M��K%��B��0�&���%`i
�t���h��
��)�&a����G������X0��-�{a@w|��.,dqo�M}�)Pz
��n Eg<��8�)�X��6�$����L���6	[�?����=f��
DS�6��Y�x&P�L�m��I"�9��PC��-6��7hRb��p 0�����:S�A���XM+���E!�Lh}�����@�!?�2���5�'���l�Rt7��*]�����>�~�a�����'uc�`E�b�\�#?cm����E

�Md���NJ�������M1���������=C���>9��L���`u��U4�n���K�y����W�^�X^(�J�����V
�L����t���������l�7np���
o�����_�^�9��\\�����������s)���z�"?�u���F�S��h�IV
u�i��
,�9
X���s����M�G.RN��-�x�����������DEW�<y>��f��txA�8H�2+����a���:�����b�@+�
6���t�A����t-��4�l����Jj��^�q�?Wr'~�U���F��	:MX)�rsM�a������k��d�i>�%���c��A�=�+���y/�Q�A����hnj����|4s���v����0���HCl0&���Et��7�q�G����05�x�,1�c������Y�������W^U�zonZl����-R����|���i����*~��t)C��4�wO�����2���Q��Q��M���,��8�cC.Z��d�������6�=�L�
�<��q����D�c�6)���y����g��!����<Sy��K�1P�
�r�q���S|ob�K�q���X�3Y���;C�CN:���"G������D��^2������S�����%����K��<�G!�����&�5��8������5���81�2�CNY���sNj�qm���M�>wDFP����	�4�Vk�$r��zV����&#��oaF����638�O�z>gW�����NP2�{�.5���g���x�O.�Vw���8t�\�:�
�\���K����|_���
���:�
���-h��[���;����.�����Cvr��<�
��R�'50�
�
���(�"Yn&���p��N�	�;�!E����84����I&�;{I_8���_(�	�/u�
A
B���x~q��o	b��%���_i�#������q�3�
D-�i9��y��n��C�
�@�r
�D����
jg����|MK�3a=��j,�Gi/�s�R�c<f�8ij����H��0�^����ucv���>}��py��NJ��&�%�	������������Z#������ ��Z�nJ�Ei�XR��@��l`i�n.YSu\��M�	*�#�|���zBH��c@?S�-("Y���
74X�>�le3j�BF�����/��h��8����|u�n�#t����b��&�Z�����~�{��"������#G���J�I�	Wz�L�CF�-������B�����:>�^�_0J]o��o�j���r�9�����N~~sE�J�'�^�^^
rr������
��6����Df��h,Z�t
2�+���$^1k����4��z�eo��N���w������duCi�����8�z��
Xr
�x�
�pP�$��=M�e���?��J]�r.^���������-��8�*W�2��*������8%rO}h
UWw��jp���D.��j��$�0r6KV����%!����������q������r_+��=���'6�m���xk�������a)�����	�nI^P����t�f���;h���y5�L��!�eN�{������1�e�+�j���Mf�-�p����c�������
��=�MC���{%���j�� �H��F��k�$x�VM�qU���[@���?�2��.^7�!�wp/������xm*w����.�k�p��]�@�v@'�*'�[�K����U7�wq��&H#��U<�����T�<B?���W����h�\�0��Y��\D�s�w"����C[zm��I^7� ���,������������ja��u�Z����L�DT�"{��������,~	����+���������<|��D�i\��TGM��x�,z��R�u����O��Q�m���a6��}��M����!w%��N!y����5��kPn��?#���0K@A4@K��K��	Q��{�x�"�*P��Y���PE���?�����[��L��j�8�����)-��UF��cgd��p�����57�2`���&Dga���R�i��)��l'���ph|T��J-��	\_�Xh�KS�����������7|r�	�7�X����JB�6����D���C�k�"������(�5v<�W+(�ew�����#[����R��tP�J��X�AI�����7�
8)m�����&��c_���iI���n���
"�}De:ZX[��l��A$���WG�CC���j������?(<��
^�3�.�h����a���q�;�#�sz�H��cL�>�����D����-���J%�Yb&M�����|�/R���P���l6Ng��/z�?���l��6�����n�'��V�W�!@vD-���
��
�#��Km�5�)�.�m��� @��,�����/{�e�{?8#?+�� ��}��~k+UI�7~?H��n���bs�J9���&_F��)���z�0l��,�X�n�s(�hy�+?O����*q�g���T.B���'��9���J�|�>������BLsP���,�=�7��.eR!j��J�����-�� �X2�
��;,�{�<�,\@iD�����
������E�������m��T��z�P�=W�b:�Z���N������Iv���M��P�������m$  ���&�v���`"`�"R���R,G#Sql�eV��J��K,a��v�
U�&zO=�>0����d�Z>9=����/�p�f6��	�t����q���;�y���tte���.�^��cy���:����|$�������J��A�mpj�-���� a~
]�X��`�r�������6��������TrG�>�\�E���q�P��o���r�
m�/��^�.*l���},���K6�h���f�4����u�=��4���)�&S��T$�Q�RHVP#����v%����Ie/���XR��B��$�$�'�vK���s�}	uN���eb����MN�w��1^#���I�h�;[x)��Vwp�))��p�?�:�+������xWfk��@N�)e���b�`$	c����c�T@_<K�d�����,�(Cep=8�=x7������0�~���O9�9���uoFx�������=B1Z���Z��p��Kas�9�����l�e?��A!@�<�WTF112V�������Y���T�}W?br��<>�����9���?h�-��������<h���������NE&�|?E��|�@!oI���������e`�~Wi�T�$q�����g�1�L�t����~�<hoA��T�bT�A]5�Y��f\|&�pp�q�������p"�5H�>�FT4[>�ruNBX� S�KY�J���w���L;
���9���0Q��U ��&=h2�LxD��=�J�U���
_��
z;�2n��A!
��A�syh�wF�R2�����O�+��{I*:�n$��o�f��7���lXN*�=�E�
��pBx0�8s��0<9KC�#��h�����\���f��\�E�N9vK>zQ[����/��(���W�N�����	��*��	r�>�\�������n;��&��?
�N�=G��p1,:�,�u+;�;[���v�T�P����j6�c��]���ZB���P�}*�'uW�fWD�&��+�=����������;8�a�G������������'��:�l�a�T�:8 2��z9�U���.������}�%�c���@=��`�q���1�gv�rM���Oo���7O�g�G�/}
�����$N��i�MW��S�3'w]����~���2��YQ�����Fu���R���3���M�!$�������Y;fK�6�\`��F��~z��R�;��=�Q|�mu��v+�w[('?y���@�k

��'E\v12-0024-tableam-Inquire-slot-type-from-AM-rather-than-ha.patch�<is�F���_1�W��I��y��,QmlK+���J�X8$l�
��6��=��AJVj_��*1HLO�L�=���(\0���Vz���G�c���2��5��+��U��a��a�&|��!S���i��\�v8��E�W���l��Wf`F����u���s3�'l�
�������L�N��e�:�HQ&+������������1�w��~a�i����.�O+/�,���%�K�\\���6��d�#���������������dF'7������y}rp���*��08a�$Y�'���0NfQ���������qi&�������8��-x����m��sn.���2	�8�Q�f���1�U���9���\�����m�,I�w���t��+��������8��t>�������������l�:;����k/�xm�������*	#�p����Y����uJ}��^P����:]�Q�% ����/}���)���>��uRE�-���^�0�?������U���������o�\�M���6t<��y�Q�H���)I��s��ya���M�����r�9]6	�LE���X!X�8���U�6���>��wa�Q��v�Z��Nrs�]��H�	j*s=�������f��yA�#1n��l�0��\����!.�tf^��������
Y
f;���������!7�A����_�zh#��H����^����A���!{������0Hg���=����	Q�������Vv,L����i'k-���Ol����?�$J	D2������6����j��\qG}G���2���(����
�d��c"���3�LP��
�I#�<��F�5A:/�iq��(A=/�x��:�{r�/�[�#�����vf�l�������s�.Q�8B�
��?���vr��_�\�Gh`	Y������b�3o����.�n�w������T�e�8�=��/D������
���^�a���;ONNdi���.[�*%~
H��j���`��v��Z�5rz#�;�l�VM[D!�t4x�o��2N j�{8t�k��d*'L�[�y>�8}��vz{���xzzv6�L�o��?\��0�����G������p�1r"Zq����
�$ae	~���#1,ri
�������F�@�
���'I��m�<�4��y9SI��h@�]���<��Q��sx�<���/;d�ssp��$d���2�t�f��p�1]H"8���5}�#ggW��jI<);���P"37��=�&H�e�	�9_�0^�`rJ,6����4�� ���3�o&�1��Hr�� "o6��g
�,��m�� ��T����4�h�L]�O��F���������������
�l�>W7�����FD�&m@����1<��*
X&��,$���Y�
Ik�7���a�g>|�[��#"~!��*��$d6�Y��$@����t=��7�K0��U�DB�����GR��C�Y�;�
�Ys2 ��*p�!���
�c��vu=���Z�%�#s44y�u��k�w��nI��l��u��}EEKOr����^y��y�
��.\!
b
���;#=��b�o���$-�_�O��k���,�3��8Z�m����kWQ�RAZN�	B�+]��1�K���h��w����q���:/��%�bO
�BJ&qe4
7��9|$Wo�"��%io��}�c/y4���)"�\&�s��Z�2�\a�����i�����c������	��g�&R�'��m���j�����b��NsEhVn>K����T��3}����A��<���w��{p/0���G	R���H���l����/��+�J�_a��������U�9�'I.���s��5��d�h4��<�����������8�����+��jG-"UC�1L��a
����_�~z��U�]Q�Gp$Mp�m�6��#�SH�1H�f�������F%|v��~��o=G��Q/� G
�SXB�(�-)�H���kl��+���'
�A��"��@+	�Y6q���[���@d�����m��Y��-_��nM����m������4���;�A��(��W�^���/��*��M ����}���.��$}<�+�aW���������+�I��/
����<����8��&BPP����x���V���-�C�- �a�����������M8cw(!w�{�'�l	Dz�L�+�p�"��ojzo�G��t�}�o�z���5�p��j$���1�F�`G�	�@u=�N��s����r��f��Gh��lk
�Z^�z^zB��6b��;�|��'�B0:�|^
 ���I;�
%3�B�����tN�k8h�f|��[	�-���u��\QX�L	�fYd�HH*lU��W�!Q�7���H��o�����lG&<���M��&�����D��E���]�>��S|m�dS��_�
�1��{�Q
8����p�,��p\(c@���=T���G�}��b�����j��<�#'���H�c���Q�������(���H����Q���\�����m���>P�����sYc��S3z�����v�M{�
BUF���1P t����&��Qn+�
?`;.`����P����L��4����tx�V|jW��|r�UeB�@����0u{�[��������R�p�G�{PJ�z'PdV�+S��X0#@������G��5�*�U0�`��%����>�Swd�C��
�����+�����C���UC�\�r���k��H(Jth�A7�kJ~[���:<1�T����CF�l9���]�F�=M�����c��k���2}����E0t����aDk�
I&�XE���������4/���8��P�X�E�|(Em����v��*q&���
���]�2`�����F������;�I�"Nn�����Cc��h;/q�=IC��[�(����5C5JQ����#�5���]�q5}�;�`��.�P�"(y�9����\�E�'e�RVb�C41�OYU������<��x;V��Zi("'N7������&\�	���Y�I���Hr�g����(����6�9G��{���r�M3:��Sn���$}��J�(
{S�5���5l]�*uJb��~�����I��~����~�_.|��`z�����e(w!x�-C����)�e�;����c�U���H�g�aZ���K�����KVV������������+�H4MS�8Ev<'�ECg�0@@�MS��������cnFv�KR�?��`�X����L�:����]C�O�&sVc=�+Q�R�e��"d�Ol���P�M]O��i��L/'����������9��������/.�7�Co�T�C��[M��� �cwY!
��K�����!���tx��^^�k�]����jh��vym��'���� w��Pd���^uq�W?����*� �e�$��E�������f*�,E_��?+,�`D�)�Bb.��%5.��!�Z/����;>+�t�F�Q3Hr#�1��1q��&�[- ���k��La����.��%y�+��f�TP
�`�q��(i����%���;�K?k��*�J2Z��D{	B6��]����6����-A��?����V�;Pm���HQ�t)�N"#}��7���d���F�L�� ��MW*S�B�/9����I�?������M��x�����|f��l�7�@�

�(���Q�x�:�����h[�Nj���X����I�LW�t��d�����P��H�3��J�n�L�[�&��a��vV^��b��`�����ai
]�w���R�	�+����JxJ��!%o������T�S��D4k2N�q�7gq+��Hb��t�����<�3��
{E�lf�HG'��-����U>��i{�T��RFX�(� �j�k���0j
4�����}��)���=E7k��j���u�o�����vyhV����=�������%;�Z�R���u4�}�W�zZ5�q$��o�y���8)$sB��1o�4E�%�3�����5��sa�>���K?�����������a�h�iu���������Q6�}>�}��F�k�����kPS���>*Q4�B��c]�r
zb��&Ol1%1�[$�.�X�tDzI'��������t���}�xA�R�}����5+
�u!*�Q]���������?��Un��!1e���!�~����Y����s�Oa�����V\���O�rO��r�L�>?{�dY����xeaS;��e���(� u
i�eR��$��h��x7���������ng�U��9����<a�?�@5�v�1�?�
��{��C�}��A����
W1�/�;Q� �� �dM5��W����8��#�"#qL0��;�LVI@b�<�{�sm��yk./�h"$ ����*�(
��y��z�+ k����z�����Q��[�j��2U�*S��T���Z���hm/�\5&���w^�I%U��f�^l���� 8J+O����xy*z�/K�1����m���7bU������;��tT����h�h���@��2�����h����$)_�z�%�,��B394��VM�;����jK��B�%�n
���"|�g�����|h�K�%����m�K����VdV{�-������T�m3�<XW���8�9�z����(�>��.��|����d"~����[|�J}�'���^l�w}���3|J�]>t<�*����.�������^��n�����,���{}~z;f��m1�5��BQ����>�������8�@�iz0;�9����0����H�*���U��������I�����7�bP���S���`�/j|"Z�`��20�go����&��[<��h�kIy���2�j�,W�W:������3IR>Zhaa �G�x5G����X���x��PIs^4+��V���<��FEhY��[�I+�v%��W��|�f�������_��I��p2i}�����n��U�[C�u���,a����`i[�/�k����=�����
�����sv�%sf.��,#�F�m�<��h	��I|������i��BuN��$�uF�������jv��b8�
W�n�de�$VC�I&E����L���	F��o����j��
I����h�������� cU�),��!T9�8(��=n��Pw��:���o��z@q)��;�����NIA�D>�p�4�	���+}*q���h�~pR�]�6�}p��t8��@���Rn��)��a�^jJ���3�����N�EP�$���Y��P��C�	�Y����7�
�����7������FTv���*/����T^��r�n���Yq�����iL/((�Cz�����Y�J�N\B-\���3�P-Veu�4=���H�x�'��	��,�[�^ni��	K!���P�sYX�gB�$�fS��LK��jKb
��
<�Z��v�v_>y��<A�o�aX������YS����`��m�w_��������
�B3���UO��'�8(n�\��*��y}0��y�����9Z�-��q��d/K�
����_���M/��������*x*��{��
��vOU�t�Y��S(F�
7�j��*k�����������UV��-0�)�����WU�����O��������A�@�e�$��U
F�U�,"����SP��^^^zf�43��;A��}5��*����qSa�:
�o������W�Y6�xQBm��m;�����;n����U~J{Gx���'C��U<?���=�-U��5*��_���w�`�������)�V���'xA����YJc=�8�����CcC�$#�.V33#���T|;���YcU�D����i��d
�w��>�	�	�
��J�`�K-�.a���aP�~������:���������	����
c_:�2|�}q	0�@wY�}��4������ �g�U?��*�%�'����T	L�������A=TP����'5�p�K���Y����\Z��),��(�����M��������L������e�gh�g�W�l�����\\�2�a

From d3471dfa797ae83b97acb5404b31cafeac88492e Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 22 Jan 2019 11:29:20 +1100
Subject: [PATCH 2/2] Removal of scan_update_snapshot

The snapshot structure is avaiable in the tablescandesc
structure itself, so it can be accessed outside itself,
no need of any callback.
---
 src/backend/access/heap/heapam.c          | 18 ------------------
 src/backend/access/heap/heapam_handler.c  |  1 -
 src/backend/executor/nodeBitmapHeapscan.c |  6 +++++-
 src/include/access/heapam.h               |  1 -
 src/include/access/tableam.h              | 10 ----------
 5 files changed, 5 insertions(+), 31 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 7f594b3e4f..6655a95433 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -1252,24 +1252,6 @@ heap_endscan(TableScanDesc sscan)
 	pfree(scan);
 }
 
-/* ----------------
- *		heap_update_snapshot
- *
- *		Update snapshot info in heap scan descriptor.
- * ----------------
- */
-void
-heap_update_snapshot(TableScanDesc sscan, Snapshot snapshot)
-{
-	HeapScanDesc scan = (HeapScanDesc) sscan;
-
-	Assert(IsMVCCSnapshot(snapshot));
-
-	RegisterSnapshot(snapshot);
-	scan->rs_scan.rs_snapshot = snapshot;
-	scan->rs_scan.rs_temp_snap = true;
-}
-
 /* ----------------
  *		heap_getnext	- retrieve next tuple in scan
  *
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 62c5f9fa9f..3dc1444739 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -2308,7 +2308,6 @@ static const TableAmRoutine heapam_methods = {
 	.scan_begin = heap_beginscan,
 	.scan_end = heap_endscan,
 	.scan_rescan = heap_rescan,
-	.scan_update_snapshot = heap_update_snapshot,
 	.scan_getnextslot = heap_getnextslot,
 
 	.parallelscan_estimate = table_block_parallelscan_estimate,
diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index 59061c746b..b48ab5036c 100644
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -954,5 +954,9 @@ ExecBitmapHeapInitializeWorker(BitmapHeapScanState *node,
 	node->pstate = pstate;
 
 	snapshot = RestoreSnapshot(pstate->phs_snapshot_data);
-	table_scan_update_snapshot(node->ss.ss_currentScanDesc, snapshot);
+	Assert(IsMVCCSnapshot(snapshot));
+
+	RegisterSnapshot(snapshot);
+	node->ss.ss_currentScanDesc->rs_snapshot = snapshot;
+	node->ss.ss_currentScanDesc->rs_temp_snap = true;
 }
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 7c9c4f5e98..dd67e7e270 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -182,7 +182,6 @@ extern void simple_heap_update(Relation relation, ItemPointer otid,
 				   HeapTuple tup);
 
 extern void heap_sync(Relation relation);
-extern void heap_update_snapshot(TableScanDesc scan, Snapshot snapshot);
 
 extern TransactionId heap_compute_xid_horizon_for_tuples(Relation rel,
 														 ItemPointerData *items,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 428ff90cad..092980e205 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -89,7 +89,6 @@ typedef struct TableAmRoutine
 	void		(*scan_end) (TableScanDesc scan);
 	void		(*scan_rescan) (TableScanDesc scan, struct ScanKeyData *key, bool set_params,
 								bool allow_strat, bool allow_sync, bool allow_pagemode);
-	void		(*scan_update_snapshot) (TableScanDesc scan, Snapshot snapshot);
 	TupleTableSlot *(*scan_getnextslot) (TableScanDesc scan,
 										 ScanDirection direction, TupleTableSlot *slot);
 
@@ -389,15 +388,6 @@ table_rescan_set_params(TableScanDesc scan, struct ScanKeyData *key,
 										 allow_pagemode);
 }
 
-/*
- * Update snapshot info in heap scan descriptor.
- */
-static inline void
-table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
-{
-	scan->rs_rd->rd_tableam->scan_update_snapshot(scan, snapshot);
-}
-
 static inline TupleTableSlot *
 table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 {
-- 
2.18.0.windows.1

From feec41723edd21987838080487349e4852d7daa7 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Wed, 16 Jan 2019 18:43:47 +1100
Subject: [PATCH 1/2] Reduce the use of HeapTuple t_tableOid

Except trigger and where the HeapTuple is generated
and passed from slots, still the t_tableOid is used.
This needs to be replaced when the t_tableOid is stored
as a seperate variable/parameter.
---
 contrib/hstore/hstore_io.c                    |  2 --
 contrib/pg_visibility/pg_visibility.c         |  1 -
 contrib/pgstattuple/pgstatapprox.c            |  1 -
 contrib/pgstattuple/pgstattuple.c             |  3 +-
 contrib/postgres_fdw/postgres_fdw.c           | 11 ++++--
 src/backend/access/common/heaptuple.c         |  7 ----
 src/backend/access/heap/heapam.c              | 35 +++++--------------
 src/backend/access/heap/heapam_handler.c      | 27 +++++++-------
 src/backend/access/heap/heapam_visibility.c   | 20 ++++-------
 src/backend/access/heap/pruneheap.c           |  2 --
 src/backend/access/heap/tuptoaster.c          |  3 --
 src/backend/access/heap/vacuumlazy.c          |  2 --
 src/backend/access/index/genam.c              |  1 -
 src/backend/catalog/indexing.c                |  2 +-
 src/backend/commands/analyze.c                |  2 +-
 src/backend/commands/functioncmds.c           |  3 +-
 src/backend/commands/schemacmds.c             |  1 -
 src/backend/commands/trigger.c                | 21 +++++------
 src/backend/executor/execExprInterp.c         |  1 -
 src/backend/executor/execTuples.c             | 29 +++++++++------
 src/backend/executor/execUtils.c              |  2 --
 src/backend/executor/nodeAgg.c                |  3 +-
 src/backend/executor/nodeGather.c             |  1 +
 src/backend/executor/nodeGatherMerge.c        |  1 +
 src/backend/executor/nodeIndexonlyscan.c      |  4 +--
 src/backend/executor/nodeIndexscan.c          |  3 +-
 src/backend/executor/nodeModifyTable.c        |  6 +---
 src/backend/executor/nodeSetOp.c              |  1 +
 src/backend/executor/spi.c                    |  1 -
 src/backend/executor/tqueue.c                 |  1 -
 src/backend/replication/logical/decode.c      |  9 -----
 .../replication/logical/reorderbuffer.c       |  4 +--
 src/backend/utils/adt/expandedrecord.c        |  1 -
 src/backend/utils/adt/jsonfuncs.c             |  2 --
 src/backend/utils/adt/rowtypes.c              | 10 ------
 src/backend/utils/cache/catcache.c            |  1 -
 src/backend/utils/sort/tuplesort.c            |  7 ++--
 src/include/access/heapam.h                   |  3 +-
 src/include/executor/tuptable.h               |  5 ++-
 src/pl/plpgsql/src/pl_exec.c                  |  2 --
 src/test/regress/regress.c                    |  1 -
 41 files changed, 92 insertions(+), 150 deletions(-)

diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
index 745497c76f..05244e77ef 100644
--- a/contrib/hstore/hstore_io.c
+++ b/contrib/hstore/hstore_io.c
@@ -845,7 +845,6 @@ hstore_from_record(PG_FUNCTION_ARGS)
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = rec;
 
 		values = (Datum *) palloc(ncolumns * sizeof(Datum));
@@ -998,7 +997,6 @@ hstore_populate_record(PG_FUNCTION_ARGS)
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = rec;
 	}
 
diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index c9166730fe..503f00408c 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -657,7 +657,6 @@ collect_corrupt_items(Oid relid, bool all_visible, bool all_frozen)
 			ItemPointerSet(&(tuple.t_self), blkno, offnum);
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = relid;
 
 			/*
 			 * If we're checking whether the page is all-visible, we expect
diff --git a/contrib/pgstattuple/pgstatapprox.c b/contrib/pgstattuple/pgstatapprox.c
index 636c8d40ac..6abe22ed61 100644
--- a/contrib/pgstattuple/pgstatapprox.c
+++ b/contrib/pgstattuple/pgstatapprox.c
@@ -152,7 +152,6 @@ statapprox_heap(Relation rel, output_type *stat)
 
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = RelationGetRelid(rel);
 
 			/*
 			 * We follow VACUUM's lead in counting INSERT_IN_PROGRESS tuples
diff --git a/contrib/pgstattuple/pgstattuple.c b/contrib/pgstattuple/pgstattuple.c
index 9bcb640884..a0e7abe748 100644
--- a/contrib/pgstattuple/pgstattuple.c
+++ b/contrib/pgstattuple/pgstattuple.c
@@ -344,7 +344,8 @@ pgstat_heap(Relation rel, FunctionCallInfo fcinfo)
 		/* must hold a buffer lock to call HeapTupleSatisfiesVisibility */
 		LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
-		if (HeapTupleSatisfiesVisibility(tuple, &SnapshotDirty, hscan->rs_cbuf))
+		if (HeapTupleSatisfiesVisibility(tuple, RelationGetRelid(hscan->rs_scan.rs_rd),
+								&SnapshotDirty, hscan->rs_cbuf))
 		{
 			stat.tuple_len += tuple->t_len;
 			stat.tuple_count++;
diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index 525629a6cc..1f806a588b 100644
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -1468,6 +1468,8 @@ postgresIterateForeignScan(ForeignScanState *node)
 	 */
 	ExecStoreHeapTuple(fsstate->tuples[fsstate->next_tuple++],
 					   slot,
+					   fsstate->rel ?
+							   RelationGetRelid(fsstate->rel) : InvalidOid,
 					   false);
 
 	return slot;
@@ -3482,7 +3484,8 @@ store_returning_result(PgFdwModifyState *fmstate,
 		 * The returning slot will currently not necessarily be suitable to
 		 * store heaptuples directly, so allow for conversion.
 		 */
-		ExecForceStoreHeapTuple(newtup, slot);
+		ExecForceStoreHeapTuple(newtup, slot,
+					fmstate->rel ? RelationGetRelid(fmstate->rel) : InvalidOid);
 		ExecMaterializeSlot(slot);
 		pfree(newtup);
 	}
@@ -3756,7 +3759,11 @@ get_returning_data(ForeignScanState *node)
 												dmstate->retrieved_attrs,
 												node,
 												dmstate->temp_cxt);
-			ExecStoreHeapTuple(newtup, slot, false);
+			ExecStoreHeapTuple(newtup,
+								slot,
+								dmstate->rel ?
+								RelationGetRelid(dmstate->rel) : InvalidOid,
+								false);
 		}
 		PG_CATCH();
 		{
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index ed4549ca57..d4ede6d47a 100644
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -689,7 +689,6 @@ heap_copytuple(HeapTuple tuple)
 	newTuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple->t_len);
 	newTuple->t_len = tuple->t_len;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 	newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
 	memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
 	return newTuple;
@@ -715,7 +714,6 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
 
 	dest->t_len = src->t_len;
 	dest->t_self = src->t_self;
-	dest->t_tableOid = src->t_tableOid;
 	dest->t_data = (HeapTupleHeader) palloc(src->t_len);
 	memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
 }
@@ -850,7 +848,6 @@ expand_tuple(HeapTuple *targetHeapTuple,
 			= targetTHeader
 			= (HeapTupleHeader) ((char *) *targetHeapTuple + HEAPTUPLESIZE);
 		(*targetHeapTuple)->t_len = len;
-		(*targetHeapTuple)->t_tableOid = sourceTuple->t_tableOid;
 		(*targetHeapTuple)->t_self = sourceTuple->t_self;
 
 		targetTHeader->t_infomask = sourceTHeader->t_infomask;
@@ -1078,7 +1075,6 @@ heap_form_tuple(TupleDesc tupleDescriptor,
 	 */
 	tuple->t_len = len;
 	ItemPointerSetInvalid(&(tuple->t_self));
-	tuple->t_tableOid = InvalidOid;
 
 	HeapTupleHeaderSetDatumLength(td, len);
 	HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
@@ -1162,7 +1158,6 @@ heap_modify_tuple(HeapTuple tuple,
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 
 	return newTuple;
 }
@@ -1225,7 +1220,6 @@ heap_modify_tuple_by_cols(HeapTuple tuple,
 	 */
 	newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
 	newTuple->t_self = tuple->t_self;
-	newTuple->t_tableOid = tuple->t_tableOid;
 
 	return newTuple;
 }
@@ -1465,7 +1459,6 @@ heap_tuple_from_minimal_tuple(MinimalTuple mtup)
 	result = (HeapTuple) palloc(HEAPTUPLESIZE + len);
 	result->t_len = len;
 	ItemPointerSetInvalid(&(result->t_self));
-	result->t_tableOid = InvalidOid;
 	result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
 	memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
 	memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 8837f83292..7f594b3e4f 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -414,7 +414,6 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
 			HeapTupleData loctup;
 			bool		valid;
 
-			loctup.t_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 			loctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lpp);
 			loctup.t_len = ItemIdGetLength(lpp);
 			ItemPointerSet(&(loctup.t_self), page, lineoff);
@@ -422,7 +421,8 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
 			if (all_visible)
 				valid = true;
 			else
-				valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
+				valid = HeapTupleSatisfiesVisibility(&loctup, RelationGetRelid(scan->rs_scan.rs_rd),
+									snapshot, buffer);
 
 			CheckForSerializableConflictOut(valid, scan->rs_scan.rs_rd, &loctup,
 											buffer, snapshot);
@@ -640,7 +640,7 @@ heapgettup(HeapScanDesc scan,
 				/*
 				 * if current tuple qualifies, return it.
 				 */
-				valid = HeapTupleSatisfiesVisibility(tuple,
+				valid = HeapTupleSatisfiesVisibility(tuple, RelationGetRelid(scan->rs_scan.rs_rd),
 													 snapshot,
 													 scan->rs_cbuf);
 
@@ -1156,9 +1156,6 @@ heap_beginscan(Relation relation, Snapshot snapshot,
 	if (!is_bitmapscan && snapshot)
 		PredicateLockRelation(relation, snapshot);
 
-	/* we only need to set this up once */
-	scan->rs_ctup.t_tableOid = RelationGetRelid(relation);
-
 	/*
 	 * we do this here instead of in initscan() because heap_rescan also calls
 	 * initscan() and we don't want to allocate memory again
@@ -1383,6 +1380,7 @@ heap_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *s
 
 	pgstat_count_heap_getnext(scan->rs_scan.rs_rd);
 
+	slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 	return ExecStoreBufferHeapTuple(&scan->rs_ctup, slot,
 									scan->rs_cbuf);
 }
@@ -1486,12 +1484,11 @@ heap_fetch(Relation relation,
 	ItemPointerCopy(tid, &(tuple->t_self));
 	tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tuple->t_len = ItemIdGetLength(lp);
-	tuple->t_tableOid = RelationGetRelid(relation);
 
 	/*
 	 * check tuple visibility, then release lock
 	 */
-	valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
+	valid = HeapTupleSatisfiesVisibility(tuple, RelationGetRelid(relation), snapshot, buffer);
 
 	if (valid)
 		PredicateLockTuple(relation, tuple, snapshot);
@@ -1596,7 +1593,6 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
 
 		heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp);
 		heapTuple->t_len = ItemIdGetLength(lp);
-		heapTuple->t_tableOid = RelationGetRelid(relation);
 		ItemPointerSetOffsetNumber(&heapTuple->t_self, offnum);
 
 		/*
@@ -1633,7 +1629,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
 			ItemPointerSet(&(heapTuple->t_self), BufferGetBlockNumber(buffer), offnum);
 
 			/* If it's visible per the snapshot, we must return it */
-			valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
+			valid = HeapTupleSatisfiesVisibility(heapTuple, RelationGetRelid(relation), snapshot, buffer);
 			CheckForSerializableConflictOut(valid, relation, heapTuple,
 											buffer, snapshot);
 			/* reset to original, non-redirected, tid */
@@ -1790,7 +1786,6 @@ heap_get_latest_tid(Relation relation,
 		tp.t_self = ctid;
 		tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 		tp.t_len = ItemIdGetLength(lp);
-		tp.t_tableOid = RelationGetRelid(relation);
 
 		/*
 		 * After following a t_ctid link, we might arrive at an unrelated
@@ -1807,7 +1802,7 @@ heap_get_latest_tid(Relation relation,
 		 * Check tuple visibility; if visible, set it as the new result
 		 * candidate.
 		 */
-		valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
+		valid = HeapTupleSatisfiesVisibility(&tp, RelationGetRelid(relation), snapshot, buffer);
 		CheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
 		if (valid)
 			*tid = ctid;
@@ -2160,7 +2155,6 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
 
 	HeapTupleHeaderSetCmin(tup->t_data, cid);
 	HeapTupleHeaderSetXmax(tup->t_data, 0); /* for cleanliness */
-	tup->t_tableOid = RelationGetRelid(relation);
 
 	/*
 	 * If the new tuple is too big for storage or contains already toasted
@@ -2218,9 +2212,6 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
 	{
 		heaptuples[i] = heap_prepare_insert(relation, ExecFetchSlotHeapTuple(slots[i], true, NULL),
 											xid, cid, options);
-
-		if (slots[i]->tts_tableOid != InvalidOid)
-			heaptuples[i]->t_tableOid = slots[i]->tts_tableOid;
 	}
 
 	/*
@@ -2610,7 +2601,6 @@ heap_delete(Relation relation, ItemPointer tid,
 	lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
 	Assert(ItemIdIsNormal(lp));
 
-	tp.t_tableOid = RelationGetRelid(relation);
 	tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tp.t_len = ItemIdGetLength(lp);
 	tp.t_self = *tid;
@@ -2727,7 +2717,7 @@ l1:
 	if (crosscheck != InvalidSnapshot && result == HeapTupleMayBeUpdated)
 	{
 		/* Perform additional check for transaction-snapshot mode RI updates */
-		if (!HeapTupleSatisfiesVisibility(&tp, crosscheck, buffer))
+		if (!HeapTupleSatisfiesVisibility(&tp, RelationGetRelid(relation), crosscheck, buffer))
 			result = HeapTupleUpdated;
 	}
 
@@ -3130,14 +3120,10 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
 	 * Fill in enough data in oldtup for HeapDetermineModifiedColumns to work
 	 * properly.
 	 */
-	oldtup.t_tableOid = RelationGetRelid(relation);
 	oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	oldtup.t_len = ItemIdGetLength(lp);
 	oldtup.t_self = *otid;
 
-	/* the new tuple is ready, except for this: */
-	newtup->t_tableOid = RelationGetRelid(relation);
-
 	/* Determine columns modified by the update. */
 	modified_attrs = HeapDetermineModifiedColumns(relation, interesting_attrs,
 												  &oldtup, newtup);
@@ -3368,7 +3354,7 @@ l2:
 	if (crosscheck != InvalidSnapshot && result == HeapTupleMayBeUpdated)
 	{
 		/* Perform additional check for transaction-snapshot mode RI updates */
-		if (!HeapTupleSatisfiesVisibility(&oldtup, crosscheck, buffer))
+		if (!HeapTupleSatisfiesVisibility(&oldtup, RelationGetRelid(relation), crosscheck, buffer))
 			result = HeapTupleUpdated;
 	}
 
@@ -4122,7 +4108,6 @@ heap_lock_tuple(Relation relation, ItemPointer tid,
 
 	tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tuple->t_len = ItemIdGetLength(lp);
-	tuple->t_tableOid = RelationGetRelid(relation);
 	tuple->t_self = *tid;
 
 l3:
@@ -5676,7 +5661,6 @@ heap_abort_speculative(Relation relation, HeapTuple tuple)
 	lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
 	Assert(ItemIdIsNormal(lp));
 
-	tp.t_tableOid = RelationGetRelid(relation);
 	tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
 	tp.t_len = ItemIdGetLength(lp);
 	tp.t_self = *tid;
@@ -7508,7 +7492,6 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
 	HeapTupleHeader hdr = tup->t_data;
 
 	Assert(ItemPointerIsValid(&tup->t_self));
-	Assert(tup->t_tableOid != InvalidOid);
 
 	xlrec.top_xid = GetTopTransactionId();
 	xlrec.target_node = relation->rd_node;
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 1f6bcf1c51..62c5f9fa9f 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -119,8 +119,6 @@ heapam_heap_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
 
 	/* Update the tuple with table oid */
 	slot->tts_tableOid = RelationGetRelid(relation);
-	if (slot->tts_tableOid != InvalidOid)
-		tuple->t_tableOid = slot->tts_tableOid;
 
 	/* Perform the insertion, and copy the resulting ItemPointer */
 	heap_insert(relation, tuple, cid, options, bistate);
@@ -139,8 +137,6 @@ heapam_heap_insert_speculative(Relation relation, TupleTableSlot *slot, CommandI
 
 	/* Update the tuple with table oid */
 	slot->tts_tableOid = RelationGetRelid(relation);
-	if (slot->tts_tableOid != InvalidOid)
-		tuple->t_tableOid = slot->tts_tableOid;
 
 	HeapTupleHeaderSetSpeculativeToken(tuple->t_data, specToken);
 
@@ -567,7 +563,9 @@ heapam_tuple_satisfies_snapshot(Relation rel, TupleTableSlot *slot, Snapshot sna
 	 * Caller should be holding pin, but not lock.
 	 */
 	LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
-	res = HeapTupleSatisfiesVisibility(bslot->base.tuple, snapshot,
+	res = HeapTupleSatisfiesVisibility(bslot->base.tuple,
+									   RelationGetRelid(rel),
+									   snapshot,
 									   bslot->buffer);
 	LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
 
@@ -733,7 +731,6 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 
 		ItemPointerSet(&targtuple->t_self, scan->rs_cblock, scan->rs_cindex);
 
-		targtuple->t_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 		targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
 		targtuple->t_len = ItemIdGetLength(itemid);
 
@@ -818,6 +815,7 @@ heapam_scan_analyze_next_tuple(TableScanDesc sscan, TransactionId OldestXmin, do
 		if (sample_it)
 		{
 			ExecStoreBufferHeapTuple(targtuple, slot, scan->rs_cbuf);
+			slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 			scan->rs_cindex++;
 
 			/* note that we leave the buffer locked here! */
@@ -1478,7 +1476,7 @@ heapam_index_build_range_scan(Relation heapRelation,
 		MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
 		/* Set up for predicate or expression evaluation */
-		ExecStoreHeapTuple(heapTuple, slot, false);
+		ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(sscan->rs_rd), false);
 
 		/*
 		 * In a partial index, discard tuples that don't satisfy the
@@ -1732,7 +1730,7 @@ heapam_index_validate_scan(Relation heapRelation,
 			MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
 			/* Set up for predicate or expression evaluation */
-			ExecStoreHeapTuple(heapTuple, slot, false);
+			ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(sscan->rs_rd), false);
 
 			/*
 			 * In a partial index, discard tuples that don't satisfy the
@@ -1885,9 +1883,9 @@ heapam_scan_bitmap_pagescan(TableScanDesc sscan,
 				continue;
 			loctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
 			loctup.t_len = ItemIdGetLength(lp);
-			loctup.t_tableOid = scan->rs_scan.rs_rd->rd_id;
 			ItemPointerSet(&loctup.t_self, page, offnum);
-			valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
+			valid = HeapTupleSatisfiesVisibility(&loctup, 
+					RelationGetRelid(scan->rs_scan.rs_rd), snapshot, buffer);
 			if (valid)
 			{
 				scan->rs_vistuples[ntup++] = offnum;
@@ -1924,7 +1922,6 @@ heapam_scan_bitmap_pagescan_next(TableScanDesc sscan, TupleTableSlot *slot)
 
 	scan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem((Page) dp, lp);
 	scan->rs_ctup.t_len = ItemIdGetLength(lp);
-	scan->rs_ctup.t_tableOid = scan->rs_scan.rs_rd->rd_id;
 	ItemPointerSet(&scan->rs_ctup.t_self, scan->rs_cblock, targoffset);
 
 	pgstat_count_heap_fetch(scan->rs_scan.rs_rd);
@@ -1936,6 +1933,7 @@ heapam_scan_bitmap_pagescan_next(TableScanDesc sscan, TupleTableSlot *slot)
 	ExecStoreBufferHeapTuple(&scan->rs_ctup,
 							 slot,
 							 scan->rs_cbuf);
+	slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 
 	scan->rs_cindex++;
 
@@ -1982,8 +1980,10 @@ SampleHeapTupleVisible(HeapScanDesc scan, Buffer buffer,
 	else
 	{
 		/* Otherwise, we have to check the tuple individually. */
-		return HeapTupleSatisfiesVisibility(tuple, scan->rs_scan.rs_snapshot,
-											buffer);
+		return HeapTupleSatisfiesVisibility(tuple, 
+				RelationGetRelid(scan->rs_scan.rs_rd), 
+				scan->rs_scan.rs_snapshot,
+				buffer);
 	}
 }
 
@@ -2132,6 +2132,7 @@ heapam_scan_sample_next_tuple(TableScanDesc sscan, struct SampleScanState *scans
 				LockBuffer(scan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
 			ExecStoreBufferHeapTuple(tuple, slot, scan->rs_cbuf);
+			slot->tts_tableOid = RelationGetRelid(scan->rs_scan.rs_rd);
 
 			/* Count successfully-fetched tuples as heap fetches */
 			pgstat_count_heap_getnext(scan->rs_scan.rs_rd);
diff --git a/src/backend/access/heap/heapam_visibility.c b/src/backend/access/heap/heapam_visibility.c
index cf9aa5c126..8c298f08e4 100644
--- a/src/backend/access/heap/heapam_visibility.c
+++ b/src/backend/access/heap/heapam_visibility.c
@@ -176,7 +176,6 @@ HeapTupleSatisfiesSelf(HeapTuple htup, Snapshot snapshot, Buffer buffer)
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -367,7 +366,6 @@ HeapTupleSatisfiesToast(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -461,7 +459,6 @@ HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -754,7 +751,6 @@ HeapTupleSatisfiesDirty(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	snapshot->xmin = snapshot->xmax = InvalidTransactionId;
 	snapshot->speculativeToken = 0;
@@ -978,7 +974,6 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	if (!HeapTupleHeaderXminCommitted(tuple))
 	{
@@ -1179,7 +1174,6 @@ HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/*
 	 * Has inserting transaction committed?
@@ -1434,7 +1428,6 @@ HeapTupleIsSurelyDead(HeapTuple htup, TransactionId OldestXmin)
 	HeapTupleHeader tuple = htup->t_data;
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/*
 	 * If the inserting transaction is marked invalid, then it aborted, and
@@ -1550,7 +1543,7 @@ TransactionIdInArray(TransactionId xid, TransactionId *xip, Size num)
  * complicated than when dealing "only" with the present.
  */
 static bool
-HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
+HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Oid relid, Snapshot snapshot,
 							   Buffer buffer)
 {
 	HeapTupleHeader tuple = htup->t_data;
@@ -1558,7 +1551,6 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 	TransactionId xmax = HeapTupleHeaderGetRawXmax(tuple);
 
 	Assert(ItemPointerIsValid(&htup->t_self));
-	Assert(htup->t_tableOid != InvalidOid);
 
 	/* inserting transaction aborted */
 	if (HeapTupleHeaderXminInvalid(tuple))
@@ -1579,7 +1571,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 		 * values externally.
 		 */
 		resolved = ResolveCminCmaxDuringDecoding(HistoricSnapshotGetTupleCids(), snapshot,
-												 htup, buffer,
+												 htup, relid, buffer,
 												 &cmin, &cmax);
 
 		if (!resolved)
@@ -1650,7 +1642,7 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
 
 		/* Lookup actual cmin/cmax values */
 		resolved = ResolveCminCmaxDuringDecoding(HistoricSnapshotGetTupleCids(), snapshot,
-												 htup, buffer,
+												 htup, relid, buffer,
 												 &cmin, &cmax);
 
 		if (!resolved)
@@ -1698,8 +1690,10 @@ HeapTupleSatisfiesHistoricMVCC(HeapTuple htup, Snapshot snapshot,
  *	if so, the indicated buffer is marked dirty.
  */
 bool
-HeapTupleSatisfiesVisibility(HeapTuple tup, Snapshot snapshot, Buffer buffer)
+HeapTupleSatisfiesVisibility(HeapTuple tup, Oid relid, Snapshot snapshot, Buffer buffer)
 {
+	Assert(relid != InvalidOid);
+	
 	switch (snapshot->snapshot_type)
 	{
 		case SNAPSHOT_MVCC:
@@ -1718,7 +1712,7 @@ HeapTupleSatisfiesVisibility(HeapTuple tup, Snapshot snapshot, Buffer buffer)
 			return HeapTupleSatisfiesDirty(tup, snapshot, buffer);
 			break;
 		case SNAPSHOT_HISTORIC_MVCC:
-			return HeapTupleSatisfiesHistoricMVCC(tup, snapshot, buffer);
+			return HeapTupleSatisfiesHistoricMVCC(tup, relid, snapshot, buffer);
 			break;
 		case SNAPSHOT_NON_VACUUMABLE:
 			return HeapTupleSatisfiesNonVacuumable(tup, snapshot, buffer);
diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
index a3e51922d8..e09a9d7340 100644
--- a/src/backend/access/heap/pruneheap.c
+++ b/src/backend/access/heap/pruneheap.c
@@ -366,8 +366,6 @@ heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
 				i;
 	HeapTupleData tup;
 
-	tup.t_tableOid = RelationGetRelid(relation);
-
 	rootlp = PageGetItemId(dp, rootoffnum);
 
 	/*
diff --git a/src/backend/access/heap/tuptoaster.c b/src/backend/access/heap/tuptoaster.c
index 7ea964c493..257ae9761b 100644
--- a/src/backend/access/heap/tuptoaster.c
+++ b/src/backend/access/heap/tuptoaster.c
@@ -1022,7 +1022,6 @@ toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,
 		result_tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + new_tuple_len);
 		result_tuple->t_len = new_tuple_len;
 		result_tuple->t_self = newtup->t_self;
-		result_tuple->t_tableOid = newtup->t_tableOid;
 		new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);
 		result_tuple->t_data = new_data;
 
@@ -1123,7 +1122,6 @@ toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
 	 * a syscache entry.
 	 */
 	new_tuple->t_self = tup->t_self;
-	new_tuple->t_tableOid = tup->t_tableOid;
 
 	new_tuple->t_data->t_choice = tup->t_data->t_choice;
 	new_tuple->t_data->t_ctid = tup->t_data->t_ctid;
@@ -1194,7 +1192,6 @@ toast_flatten_tuple_to_datum(HeapTupleHeader tup,
 	/* Build a temporary HeapTuple control structure */
 	tmptup.t_len = tup_len;
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tup;
 
 	/*
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 85680ab6db..860ea42cba 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -1003,7 +1003,6 @@ lazy_scan_heap(Relation onerel, int options, LVRelStats *vacrelstats,
 
 			tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 			tuple.t_len = ItemIdGetLength(itemid);
-			tuple.t_tableOid = RelationGetRelid(onerel);
 
 			tupgone = false;
 
@@ -2236,7 +2235,6 @@ heap_page_is_all_visible(Relation rel, Buffer buf,
 
 		tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
 		tuple.t_len = ItemIdGetLength(itemid);
-		tuple.t_tableOid = RelationGetRelid(rel);
 
 		switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
 		{
diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index f4a527b126..250c746971 100644
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -510,7 +510,6 @@ systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup)
 	result = table_tuple_satisfies_snapshot(sysscan->heap_rel,
 											sysscan->slot,
 											freshsnap);
-
 	return result;
 }
 
diff --git a/src/backend/catalog/indexing.c b/src/backend/catalog/indexing.c
index 0c994122d8..7d443f8fe7 100644
--- a/src/backend/catalog/indexing.c
+++ b/src/backend/catalog/indexing.c
@@ -99,7 +99,7 @@ CatalogIndexInsert(CatalogIndexState indstate, HeapTuple heapTuple)
 	/* Need a slot to hold the tuple being examined */
 	slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
 									&TTSOpsHeapTuple);
-	ExecStoreHeapTuple(heapTuple, slot, false);
+	ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(heapRelation), false);
 
 	/*
 	 * for each index, form and insert the index tuple
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index fb4384d556..a71d7b658e 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -760,7 +760,7 @@ compute_index_stats(Relation onerel, double totalrows,
 			ResetExprContext(econtext);
 
 			/* Set up for predicate or expression evaluation */
-			ExecStoreHeapTuple(heapTuple, slot, false);
+			ExecStoreHeapTuple(heapTuple, slot, RelationGetRelid(onerel), false);
 
 			/* If index is partial, check predicate */
 			if (predicate != NULL)
diff --git a/src/backend/commands/functioncmds.c b/src/backend/commands/functioncmds.c
index eae2b09830..734b5165dd 100644
--- a/src/backend/commands/functioncmds.c
+++ b/src/backend/commands/functioncmds.c
@@ -2359,10 +2359,9 @@ ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver
 
 		rettupdata.t_len = HeapTupleHeaderGetDatumLength(td);
 		ItemPointerSetInvalid(&(rettupdata.t_self));
-		rettupdata.t_tableOid = InvalidOid;
 		rettupdata.t_data = td;
 
-		slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, false);
+		slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, InvalidOid, false);
 		tstate->dest->receiveSlot(slot, tstate->dest);
 
 		end_tup_output(tstate);
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index 6cf94a3140..4492ae2b0e 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -355,7 +355,6 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
 {
 	Form_pg_namespace nspForm;
 
-	Assert(tup->t_tableOid == NamespaceRelationId);
 	Assert(RelationGetRelid(rel) == NamespaceRelationId);
 
 	nspForm = (Form_pg_namespace) GETSTRUCT(tup);
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index ced31bf552..ddc804af29 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -2570,7 +2570,7 @@ ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		if (newtuple != oldtuple)
 		{
-			ExecForceStoreHeapTuple(newtuple, slot);
+			ExecForceStoreHeapTuple(newtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 			newtuple = ExecFetchSlotHeapTuple(slot, true, NULL);
 		}
 	}
@@ -2647,7 +2647,8 @@ ExecIRInsertTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		if (oldtuple != newtuple)
 		{
-			ExecForceStoreHeapTuple(newtuple, LocTriggerData.tg_trigslot);
+			ExecForceStoreHeapTuple(newtuple, LocTriggerData.tg_trigslot,
+									RelationGetRelid(relinfo->ri_RelationDesc));
 			newtuple = ExecFetchSlotHeapTuple(slot, true, NULL);
 		}
 	}
@@ -2770,7 +2771,7 @@ ExecBRDeleteTriggers(EState *estate, EPQState *epqstate,
 	else
 	{
 		trigtuple = fdw_trigtuple;
-		ExecForceStoreHeapTuple(trigtuple, slot);
+		ExecForceStoreHeapTuple(trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 
 	LocTriggerData.type = T_TriggerData;
@@ -2846,7 +2847,7 @@ ExecARDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
 		}
 		else
 		{
-			ExecForceStoreHeapTuple(fdw_trigtuple, slot);
+			ExecForceStoreHeapTuple(fdw_trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 		}
 
 		AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_DELETE,
@@ -2876,7 +2877,7 @@ ExecIRDeleteTriggers(EState *estate, ResultRelInfo *relinfo,
 	LocTriggerData.tg_oldtable = NULL;
 	LocTriggerData.tg_newtable = NULL;
 
-	ExecForceStoreHeapTuple(trigtuple, slot);
+	ExecForceStoreHeapTuple(trigtuple, slot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 	for (i = 0; i < trigdesc->numtriggers; i++)
 	{
@@ -3036,7 +3037,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
 	}
 	else
 	{
-		ExecForceStoreHeapTuple(fdw_trigtuple, oldslot);
+		ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 		trigtuple = fdw_trigtuple;
 	}
 
@@ -3082,7 +3083,7 @@ ExecBRUpdateTriggers(EState *estate, EPQState *epqstate,
 		}
 
 		if (newtuple != oldtuple)
-			ExecForceStoreHeapTuple(newtuple, newslot);
+			ExecForceStoreHeapTuple(newtuple, newslot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 	if (false && trigtuple != fdw_trigtuple && trigtuple != newtuple)
 		heap_freetuple(trigtuple);
@@ -3124,7 +3125,7 @@ ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 							   NULL,
 							   NULL);
 		else if (fdw_trigtuple != NULL)
-			ExecForceStoreHeapTuple(fdw_trigtuple, oldslot);
+			ExecForceStoreHeapTuple(fdw_trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 		AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE,
 							  true, oldslot, newslot, recheckIndexes,
@@ -3153,7 +3154,7 @@ ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 	LocTriggerData.tg_oldtable = NULL;
 	LocTriggerData.tg_newtable = NULL;
 
-	ExecForceStoreHeapTuple(trigtuple, oldslot);
+	ExecForceStoreHeapTuple(trigtuple, oldslot, RelationGetRelid(relinfo->ri_RelationDesc));
 
 	for (i = 0; i < trigdesc->numtriggers; i++)
 	{
@@ -3185,7 +3186,7 @@ ExecIRUpdateTriggers(EState *estate, ResultRelInfo *relinfo,
 			return false;		/* "do nothing" */
 
 		if (oldtuple != newtuple)
-			ExecForceStoreHeapTuple(newtuple, newslot);
+			ExecForceStoreHeapTuple(newtuple, newslot, RelationGetRelid(relinfo->ri_RelationDesc));
 	}
 
 	return true;
diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index d793efdd9c..928052b1ae 100644
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -3003,7 +3003,6 @@ ExecEvalFieldStoreDeForm(ExprState *state, ExprEvalStep *op, ExprContext *econte
 		tuphdr = DatumGetHeapTupleHeader(tupDatum);
 		tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
 		ItemPointerSetInvalid(&(tmptup.t_self));
-		tmptup.t_tableOid = InvalidOid;
 		tmptup.t_data = tuphdr;
 
 		heap_deform_tuple(&tmptup, tupDesc,
diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 9afea31e6a..7c48d50784 100644
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -387,7 +387,7 @@ tts_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 	tuple = ExecCopySlotHeapTuple(srcslot);
 	MemoryContextSwitchTo(oldcontext);
 
-	ExecStoreHeapTuple(tuple, dstslot, true);
+	ExecStoreHeapTuple(tuple, dstslot, srcslot->tts_tableOid, true);
 }
 
 static HeapTuple
@@ -1117,6 +1117,7 @@ MakeTupleTableSlot(TupleDesc tupleDesc,
 	slot->tts_tupleDescriptor = tupleDesc;
 	slot->tts_mcxt = CurrentMemoryContext;
 	slot->tts_nvalid = 0;
+	slot->tts_tableOid = InvalidOid;
 
 	if (tupleDesc != NULL)
 	{
@@ -1329,6 +1330,7 @@ ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
 TupleTableSlot *
 ExecStoreHeapTuple(HeapTuple tuple,
 				   TupleTableSlot *slot,
+				   Oid relid,
 				   bool shouldFree)
 {
 	/*
@@ -1342,7 +1344,7 @@ ExecStoreHeapTuple(HeapTuple tuple,
 		elog(ERROR, "trying to store a heap tuple into wrong type of slot");
 	tts_heap_store_tuple(slot, tuple, shouldFree);
 
-	slot->tts_tableOid = tuple->t_tableOid;
+	slot->tts_tableOid = relid;
 
 	return slot;
 }
@@ -1364,6 +1366,8 @@ ExecStoreHeapTuple(HeapTuple tuple,
  *
  * If the target slot is not guaranteed to be TTSOpsBufferHeapTuple type slot,
  * use the, more expensive, ExecForceStoreHeapTuple().
+ *
+ * NOTE: Don't set the tts_tableOid from tuple t_tableOid.
  * --------------------------------
  */
 TupleTableSlot *
@@ -1383,8 +1387,6 @@ ExecStoreBufferHeapTuple(HeapTuple tuple,
 		elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
 	tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
 
-	slot->tts_tableOid = tuple->t_tableOid;
-
 	return slot;
 }
 
@@ -1409,8 +1411,6 @@ ExecStorePinnedBufferHeapTuple(HeapTuple tuple,
 		elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
 	tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
 
-	slot->tts_tableOid = tuple->t_tableOid;
-
 	return slot;
 }
 
@@ -1445,11 +1445,12 @@ ExecStoreMinimalTuple(MinimalTuple mtup,
  */
 void
 ExecForceStoreHeapTuple(HeapTuple tuple,
-						TupleTableSlot *slot)
+						TupleTableSlot *slot,
+						Oid relid)
 {
 	if (TTS_IS_HEAPTUPLE(slot))
 	{
-		ExecStoreHeapTuple(tuple, slot, false);
+		ExecStoreHeapTuple(tuple, slot, relid, false);
 	}
 	else if (TTS_IS_BUFFERTUPLE(slot))
 	{
@@ -1462,6 +1463,7 @@ ExecForceStoreHeapTuple(HeapTuple tuple,
 		oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
 		bslot->base.tuple = heap_copytuple(tuple);
 		MemoryContextSwitchTo(oldContext);
+		slot->tts_tableOid = relid;
 	}
 	else
 	{
@@ -1469,6 +1471,7 @@ ExecForceStoreHeapTuple(HeapTuple tuple,
 		heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
 						  slot->tts_values, slot->tts_isnull);
 		ExecStoreVirtualTuple(slot);
+		slot->tts_tableOid = relid;
 	}
 }
 
@@ -1602,6 +1605,8 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
 HeapTuple
 ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
 {
+	HeapTuple htup;
+
 	/*
 	 * sanity checks
 	 */
@@ -1616,14 +1621,18 @@ ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
 	{
 		if (shouldFree)
 			*shouldFree = true;
-		return slot->tts_ops->copy_heap_tuple(slot);
+		htup = slot->tts_ops->copy_heap_tuple(slot);
 	}
 	else
 	{
 		if (shouldFree)
 			*shouldFree = false;
-		return slot->tts_ops->get_heap_tuple(slot);
+		htup = slot->tts_ops->get_heap_tuple(slot);
 	}
+
+	htup->t_tableOid = slot->tts_tableOid;
+
+	return htup;
 }
 
 /* --------------------------------
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 60928d3f80..b0bccb78ae 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -1011,7 +1011,6 @@ GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
 	 */
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuple;
 
 	result = heap_getattr(&tmptup,
@@ -1059,7 +1058,6 @@ GetAttributeByNum(HeapTupleHeader tuple,
 	 */
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuple;
 
 	result = heap_getattr(&tmptup,
diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index 508c919574..36d86bfdae 100644
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -1801,7 +1801,8 @@ agg_retrieve_direct(AggState *aggstate)
 				 * cleared from the slot.
 				 */
 				ExecForceStoreHeapTuple(aggstate->grp_firstTuple,
-								   firstSlot);
+								   firstSlot,
+								   InvalidOid);
 				aggstate->grp_firstTuple = NULL;	/* don't keep two pointers */
 
 				/* set up for first advance_aggregates call */
diff --git a/src/backend/executor/nodeGather.c b/src/backend/executor/nodeGather.c
index 70a4e90a05..37bce93cc3 100644
--- a/src/backend/executor/nodeGather.c
+++ b/src/backend/executor/nodeGather.c
@@ -280,6 +280,7 @@ gather_getnext(GatherState *gatherstate)
 			{
 				ExecStoreHeapTuple(tup, /* tuple to store */
 								   fslot,	/* slot to store the tuple */
+								   InvalidOid,
 								   true);	/* pfree tuple when done with it */
 				return fslot;
 			}
diff --git a/src/backend/executor/nodeGatherMerge.c b/src/backend/executor/nodeGatherMerge.c
index 8635865d1e..827578ca8d 100644
--- a/src/backend/executor/nodeGatherMerge.c
+++ b/src/backend/executor/nodeGatherMerge.c
@@ -703,6 +703,7 @@ gather_merge_readnext(GatherMergeState *gm_state, int reader, bool nowait)
 	ExecStoreHeapTuple(tup,			/* tuple to store */
 					   gm_state->gm_slots[reader],	/* slot in which to store
 													 * the tuple */
+					   InvalidOid,
 					   true);		/* pfree tuple when done with it */
 
 	return true;
diff --git a/src/backend/executor/nodeIndexonlyscan.c b/src/backend/executor/nodeIndexonlyscan.c
index 08527d527c..ab3e3a6c60 100644
--- a/src/backend/executor/nodeIndexonlyscan.c
+++ b/src/backend/executor/nodeIndexonlyscan.c
@@ -206,8 +206,8 @@ IndexOnlyNext(IndexOnlyScanState *node)
 			 */
 			Assert(slot->tts_tupleDescriptor->natts ==
 				   scandesc->xs_hitupdesc->natts);
-			ExecForceStoreHeapTuple(scandesc->xs_hitup, slot);
-			slot->tts_tableOid = RelationGetRelid(scandesc->heapRelation);
+			ExecForceStoreHeapTuple(scandesc->xs_hitup, slot,
+					RelationGetRelid(scandesc->heapRelation));
 		}
 		else if (scandesc->xs_itup)
 			StoreIndexTuple(slot, scandesc->xs_itup, scandesc->xs_itupdesc);
diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c
index b8580a896a..6e26d16f35 100644
--- a/src/backend/executor/nodeIndexscan.c
+++ b/src/backend/executor/nodeIndexscan.c
@@ -247,8 +247,7 @@ IndexNextWithReorder(IndexScanState *node)
 				tuple = reorderqueue_pop(node);
 
 				/* Pass 'true', as the tuple in the queue is a palloc'd copy */
-				slot->tts_tableOid = RelationGetRelid(scandesc->heapRelation);
-				ExecStoreHeapTuple(tuple, slot, true);
+				ExecStoreHeapTuple(tuple, slot, RelationGetRelid(scandesc->heapRelation), true);
 				return slot;
 			}
 		}
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 20e77db4a8..6440c4ed69 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -847,7 +847,7 @@ ldelete:;
 			slot = ExecTriggerGetReturnSlot(estate, resultRelInfo);
 			if (oldtuple != NULL)
 			{
-				ExecForceStoreHeapTuple(oldtuple, slot);
+				ExecForceStoreHeapTuple(oldtuple, slot, RelationGetRelid(resultRelationDesc));
 			}
 			else
 			{
@@ -2036,10 +2036,6 @@ ExecModifyTable(PlanState *pstate)
 					oldtupdata.t_len =
 						HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
 					ItemPointerSetInvalid(&(oldtupdata.t_self));
-					/* Historically, view triggers see invalid t_tableOid. */
-					oldtupdata.t_tableOid =
-						(relkind == RELKIND_VIEW) ? InvalidOid :
-						RelationGetRelid(resultRelInfo->ri_RelationDesc);
 
 					oldtuple = &oldtupdata;
 				}
diff --git a/src/backend/executor/nodeSetOp.c b/src/backend/executor/nodeSetOp.c
index 5d8c8b8b02..1c063f6a7b 100644
--- a/src/backend/executor/nodeSetOp.c
+++ b/src/backend/executor/nodeSetOp.c
@@ -269,6 +269,7 @@ setop_retrieve_direct(SetOpState *setopstate)
 		 */
 		ExecStoreHeapTuple(setopstate->grp_firstTuple,
 						   resultTupleSlot,
+						   InvalidOid,
 						   true);
 		setopstate->grp_firstTuple = NULL;	/* don't keep two pointers */
 
diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index 94a53e0e3f..0fb406c64f 100644
--- a/src/backend/executor/spi.c
+++ b/src/backend/executor/spi.c
@@ -870,7 +870,6 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
 		 */
 		mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
 		mtuple->t_self = tuple->t_self;
-		mtuple->t_tableOid = tuple->t_tableOid;
 	}
 	else
 	{
diff --git a/src/backend/executor/tqueue.c b/src/backend/executor/tqueue.c
index 6e2eaa5dcf..3ebf1e347e 100644
--- a/src/backend/executor/tqueue.c
+++ b/src/backend/executor/tqueue.c
@@ -208,7 +208,6 @@ TupleQueueReaderNext(TupleQueueReader *reader, bool nowait, bool *done)
 	 * (which had better be sufficiently aligned).
 	 */
 	ItemPointerSetInvalid(&htup.t_self);
-	htup.t_tableOid = InvalidOid;
 	htup.t_len = nbytes;
 	htup.t_data = data;
 
diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
index eec3a22842..f26dac0f70 100644
--- a/src/backend/replication/logical/decode.c
+++ b/src/backend/replication/logical/decode.c
@@ -940,12 +940,6 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
 			/* not a disk based tuple */
 			ItemPointerSetInvalid(&tuple->tuple.t_self);
 
-			/*
-			 * We can only figure this out after reassembling the
-			 * transactions.
-			 */
-			tuple->tuple.t_tableOid = InvalidOid;
-
 			tuple->tuple.t_len = datalen + SizeofHeapTupleHeader;
 
 			memset(header, 0, SizeofHeapTupleHeader);
@@ -1033,9 +1027,6 @@ DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
 	/* not a disk based tuple */
 	ItemPointerSetInvalid(&tuple->tuple.t_self);
 
-	/* we can only figure this out after reassembling the transactions */
-	tuple->tuple.t_tableOid = InvalidOid;
-
 	/* data is not stored aligned, copy to aligned storage */
 	memcpy((char *) &xlhdr,
 		   data,
diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index a49e226967..a2a3c4760e 100644
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -3482,7 +3482,7 @@ UpdateLogicalMappings(HTAB *tuplecid_data, Oid relid, Snapshot snapshot)
 bool
 ResolveCminCmaxDuringDecoding(HTAB *tuplecid_data,
 							  Snapshot snapshot,
-							  HeapTuple htup, Buffer buffer,
+							  HeapTuple htup, Oid relid, Buffer buffer,
 							  CommandId *cmin, CommandId *cmax)
 {
 	ReorderBufferTupleCidKey key;
@@ -3524,7 +3524,7 @@ restart:
 	 */
 	if (ent == NULL && !updated_mapping)
 	{
-		UpdateLogicalMappings(tuplecid_data, htup->t_tableOid, snapshot);
+		UpdateLogicalMappings(tuplecid_data, relid, snapshot);
 		/* now check but don't update for a mapping again */
 		updated_mapping = true;
 		goto restart;
diff --git a/src/backend/utils/adt/expandedrecord.c b/src/backend/utils/adt/expandedrecord.c
index 9971abd71f..a49cf9b467 100644
--- a/src/backend/utils/adt/expandedrecord.c
+++ b/src/backend/utils/adt/expandedrecord.c
@@ -610,7 +610,6 @@ make_expanded_record_from_datum(Datum recorddatum, MemoryContext parentcontext)
 
 	tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
 	ItemPointerSetInvalid(&(tmptup.t_self));
-	tmptup.t_tableOid = InvalidOid;
 	tmptup.t_data = tuphdr;
 
 	oldcxt = MemoryContextSwitchTo(objcxt);
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index dd88c09e6d..314777909d 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -3147,7 +3147,6 @@ populate_record(TupleDesc tupdesc,
 		/* Build a temporary HeapTuple control structure */
 		tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
 		ItemPointerSetInvalid(&(tuple.t_self));
-		tuple.t_tableOid = InvalidOid;
 		tuple.t_data = defaultval;
 
 		/* Break down the tuple into fields */
@@ -3546,7 +3545,6 @@ populate_recordset_record(PopulateRecordsetState *state, JsObject *obj)
 	/* ok, save into tuplestore */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = tuphead;
 
 	tuplestore_puttuple(state->tuple_store, &tuple);
diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
index 0467f97dc3..2fd3f49e7e 100644
--- a/src/backend/utils/adt/rowtypes.c
+++ b/src/backend/utils/adt/rowtypes.c
@@ -324,7 +324,6 @@ record_out(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	/*
@@ -671,7 +670,6 @@ record_send(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	/*
@@ -821,11 +819,9 @@ record_cmp(FunctionCallInfo fcinfo)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1063,11 +1059,9 @@ record_eq(PG_FUNCTION_ARGS)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1326,11 +1320,9 @@ record_image_cmp(FunctionCallInfo fcinfo)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
@@ -1570,11 +1562,9 @@ record_image_eq(PG_FUNCTION_ARGS)
 	/* Build temporary HeapTuple control structures */
 	tuple1.t_len = HeapTupleHeaderGetDatumLength(record1);
 	ItemPointerSetInvalid(&(tuple1.t_self));
-	tuple1.t_tableOid = InvalidOid;
 	tuple1.t_data = record1;
 	tuple2.t_len = HeapTupleHeaderGetDatumLength(record2);
 	ItemPointerSetInvalid(&(tuple2.t_self));
-	tuple2.t_tableOid = InvalidOid;
 	tuple2.t_data = record2;
 
 	/*
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 258a1d64cc..3e165af707 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -1846,7 +1846,6 @@ CatalogCacheCreateEntry(CatCache *cache, HeapTuple ntp, Datum *arguments,
 								MAXIMUM_ALIGNOF + dtp->t_len);
 		ct->tuple.t_len = dtp->t_len;
 		ct->tuple.t_self = dtp->t_self;
-		ct->tuple.t_tableOid = dtp->t_tableOid;
 		ct->tuple.t_data = (HeapTupleHeader)
 			MAXALIGN(((char *) ct) + sizeof(CatCTup));
 		/* copy tuple contents */
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 60b96df8f9..a3ed15214a 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -3792,11 +3792,11 @@ comparetup_cluster(const SortTuple *a, const SortTuple *b,
 
 		ecxt_scantuple = GetPerTupleExprContext(state->estate)->ecxt_scantuple;
 
-		ExecStoreHeapTuple(ltup, ecxt_scantuple, false);
+		ExecStoreHeapTuple(ltup, ecxt_scantuple, InvalidOid, false);
 		FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
 					   l_index_values, l_index_isnull);
 
-		ExecStoreHeapTuple(rtup, ecxt_scantuple, false);
+		ExecStoreHeapTuple(rtup, ecxt_scantuple, InvalidOid, false);
 		FormIndexDatum(state->indexInfo, ecxt_scantuple, state->estate,
 					   r_index_values, r_index_isnull);
 
@@ -3926,8 +3926,7 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 	tuple->t_len = t_len;
 	LogicalTapeReadExact(state->tapeset, tapenum,
 						 &tuple->t_self, sizeof(ItemPointerData));
-	/* We don't currently bother to reconstruct t_tableOid */
-	tuple->t_tableOid = InvalidOid;
+
 	/* Read in the tuple body */
 	LogicalTapeReadExact(state->tapeset, tapenum,
 						 tuple->t_data, tuple->t_len);
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 2bb170e708..7c9c4f5e98 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -211,7 +211,7 @@ extern void heap_vacuum_rel(Relation onerel, int options,
 				struct VacuumParams *params, BufferAccessStrategy bstrategy);
 
 /* in heap/heapam_visibility.c */
-extern bool HeapTupleSatisfiesVisibility(HeapTuple stup, Snapshot snapshot,
+extern bool HeapTupleSatisfiesVisibility(HeapTuple stup, Oid relid, Snapshot snapshot,
 										 Buffer buffer);
 extern HTSU_Result HeapTupleSatisfiesUpdate(HeapTuple stup, CommandId curcid,
 						 Buffer buffer);
@@ -231,6 +231,7 @@ struct HTAB;
 extern bool ResolveCminCmaxDuringDecoding(struct HTAB *tuplecid_data,
 							  Snapshot snapshot,
 							  HeapTuple htup,
+							  Oid relid,
 							  Buffer buffer,
 							  CommandId *cmin, CommandId *cmax);
 
diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index fe8630e67a..996153e03f 100644
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -306,9 +306,8 @@ extern TupleTableSlot *MakeSingleTupleTableSlot(TupleDesc tupdesc,
 extern void ExecDropSingleTupleTableSlot(TupleTableSlot *slot);
 extern void ExecSetSlotDescriptor(TupleTableSlot *slot, TupleDesc tupdesc);
 extern TupleTableSlot *ExecStoreHeapTuple(HeapTuple tuple,
-				   TupleTableSlot *slot,
-				   bool shouldFree);
-extern void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot);
+				   TupleTableSlot *slot, Oid relid, bool shouldFree);
+extern void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Oid relid);
 /* FIXME: Remove */
 extern void ExecForceStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
 extern TupleTableSlot *ExecStoreBufferHeapTuple(HeapTuple tuple,
diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
index 5c6dbe4c5f..1a61eb85b1 100644
--- a/src/pl/plpgsql/src/pl_exec.c
+++ b/src/pl/plpgsql/src/pl_exec.c
@@ -7236,7 +7236,6 @@ deconstruct_composite_datum(Datum value, HeapTupleData *tmptup)
 	/* Build a temporary HeapTuple control structure */
 	tmptup->t_len = HeapTupleHeaderGetDatumLength(td);
 	ItemPointerSetInvalid(&(tmptup->t_self));
-	tmptup->t_tableOid = InvalidOid;
 	tmptup->t_data = td;
 
 	/* Extract rowtype info and find a tupdesc */
@@ -7405,7 +7404,6 @@ exec_move_row_from_datum(PLpgSQL_execstate *estate,
 		/* Build a temporary HeapTuple control structure */
 		tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
 		ItemPointerSetInvalid(&(tmptup.t_self));
-		tmptup.t_tableOid = InvalidOid;
 		tmptup.t_data = td;
 
 		/* Extract rowtype info */
diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c
index 70727286ca..924bd85ce1 100644
--- a/src/test/regress/regress.c
+++ b/src/test/regress/regress.c
@@ -524,7 +524,6 @@ make_tuple_indirect(PG_FUNCTION_ARGS)
 	/* Build a temporary HeapTuple control structure */
 	tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
 	ItemPointerSetInvalid(&(tuple.t_self));
-	tuple.t_tableOid = InvalidOid;
 	tuple.t_data = rec;
 
 	values = (Datum *) palloc(ncolumns * sizeof(Datum));
-- 
2.18.0.windows.1

From 71ecc03b10a2877172d7a46dd4ef756bbe5ab879 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Tue, 22 Jan 2019 11:29:20 +1100
Subject: [PATCH] Removal of scan_update_snapshot callback

The snapshot structure is avaiable in the tablescandesc
structure itself, so it can be accessed outside itself,
no need of any callback.
---
 src/backend/access/heap/heapam.c         | 18 ------------------
 src/backend/access/heap/heapam_handler.c |  1 -
 src/backend/access/table/tableam.c       | 13 +++++++++++++
 src/include/access/heapam.h              |  1 -
 src/include/access/tableam.h             | 16 ++++++----------
 5 files changed, 19 insertions(+), 30 deletions(-)

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 7f594b3e4f..6655a95433 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -1252,24 +1252,6 @@ heap_endscan(TableScanDesc sscan)
 	pfree(scan);
 }
 
-/* ----------------
- *		heap_update_snapshot
- *
- *		Update snapshot info in heap scan descriptor.
- * ----------------
- */
-void
-heap_update_snapshot(TableScanDesc sscan, Snapshot snapshot)
-{
-	HeapScanDesc scan = (HeapScanDesc) sscan;
-
-	Assert(IsMVCCSnapshot(snapshot));
-
-	RegisterSnapshot(snapshot);
-	scan->rs_scan.rs_snapshot = snapshot;
-	scan->rs_scan.rs_temp_snap = true;
-}
-
 /* ----------------
  *		heap_getnext	- retrieve next tuple in scan
  *
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 62c5f9fa9f..3dc1444739 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -2308,7 +2308,6 @@ static const TableAmRoutine heapam_methods = {
 	.scan_begin = heap_beginscan,
 	.scan_end = heap_endscan,
 	.scan_rescan = heap_rescan,
-	.scan_update_snapshot = heap_update_snapshot,
 	.scan_getnextslot = heap_getnextslot,
 
 	.parallelscan_estimate = table_block_parallelscan_estimate,
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index f579fb0d71..a2da7b7809 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -394,3 +394,16 @@ table_block_parallelscan_nextpage(Relation rel, ParallelBlockTableScanDesc pbsca
 
 	return page;
 }
+
+/*
+ * Update snapshot info in table scan descriptor.
+ */
+void
+table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
+{
+	Assert(IsMVCCSnapshot(snapshot));
+
+	RegisterSnapshot(snapshot);
+	scan->rs_snapshot = snapshot;
+	scan->rs_temp_snap = true;
+}
diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index 7c9c4f5e98..dd67e7e270 100644
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -182,7 +182,6 @@ extern void simple_heap_update(Relation relation, ItemPointer otid,
 				   HeapTuple tup);
 
 extern void heap_sync(Relation relation);
-extern void heap_update_snapshot(TableScanDesc scan, Snapshot snapshot);
 
 extern TransactionId heap_compute_xid_horizon_for_tuples(Relation rel,
 														 ItemPointerData *items,
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 428ff90cad..4aa4369366 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -89,7 +89,6 @@ typedef struct TableAmRoutine
 	void		(*scan_end) (TableScanDesc scan);
 	void		(*scan_rescan) (TableScanDesc scan, struct ScanKeyData *key, bool set_params,
 								bool allow_strat, bool allow_sync, bool allow_pagemode);
-	void		(*scan_update_snapshot) (TableScanDesc scan, Snapshot snapshot);
 	TupleTableSlot *(*scan_getnextslot) (TableScanDesc scan,
 										 ScanDirection direction, TupleTableSlot *slot);
 
@@ -389,15 +388,6 @@ table_rescan_set_params(TableScanDesc scan, struct ScanKeyData *key,
 										 allow_pagemode);
 }
 
-/*
- * Update snapshot info in heap scan descriptor.
- */
-static inline void
-table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot)
-{
-	scan->rs_rd->rd_tableam->scan_update_snapshot(scan, snapshot);
-}
-
 static inline TupleTableSlot *
 table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 {
@@ -799,6 +789,12 @@ extern BlockNumber table_block_parallelscan_nextpage(Relation rel, ParallelBlock
 extern void table_block_parallelscan_startblock_init(Relation rel, ParallelBlockTableScanDesc pbscan);
 
 
+/* ----------------------------------------------------------------------------
+ * Helper function to update the snapshot of the scan descriptor
+ * ----------------------------------------------------------------------------
+ */
+extern void table_scan_update_snapshot(TableScanDesc scan, Snapshot snapshot);
+
 /* ----------------------------------------------------------------------------
  * Functions in tableamapi.c
  * ----------------------------------------------------------------------------
-- 
2.18.0.windows.1

diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 0a181b01d9..f76c734a28 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1484,6 +1484,8 @@ describeOneTableDetails(const char *schemaname,
 		char	   *reloftype;
 		char		relpersistence;
 		char		relreplident;
+		char	   *relam;
+		bool	    relam_is_default;
 	}			tableinfo;
 	bool		show_column_details = false;
 
@@ -1503,9 +1505,11 @@ describeOneTableDetails(const char *schemaname,
 						  "c.relhastriggers, c.relrowsecurity, c.relforcerowsecurity, "
 						  "false AS relhasoids, %s, c.reltablespace, "
 						  "CASE WHEN c.reloftype = 0 THEN '' ELSE c.reloftype::pg_catalog.regtype::pg_catalog.text END, "
-						  "c.relpersistence, c.relreplident\n"
+						  "c.relpersistence, c.relreplident, am.amname,"
+						  "am.amname = current_setting('default_table_access_method') \n"
 						  "FROM pg_catalog.pg_class c\n "
 						  "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
+						  "LEFT JOIN pg_catalog.pg_am am ON (c.relam = am.oid)\n"
 						  "WHERE c.oid = '%s';",
 						  (verbose ?
 						   "pg_catalog.array_to_string(c.reloptions || "
@@ -1656,6 +1660,17 @@ describeOneTableDetails(const char *schemaname,
 		*(PQgetvalue(res, 0, 11)) : 0;
 	tableinfo.relreplident = (pset.sversion >= 90400) ?
 		*(PQgetvalue(res, 0, 12)) : 'd';
+	if (pset.sversion >= 120000)
+	{
+		tableinfo.relam = PQgetisnull(res, 0, 13) ?
+			(char *) NULL : pg_strdup(PQgetvalue(res, 0, 13));
+		tableinfo.relam_is_default = strcmp(PQgetvalue(res, 0, 14), "t") == 0;
+	}
+	else
+	{
+		tableinfo.relam = NULL;
+		tableinfo.relam_is_default = false;
+	}
 	PQclear(res);
 	res = NULL;
 
@@ -3141,6 +3156,14 @@ describeOneTableDetails(const char *schemaname,
 		/* Tablespace info */
 		add_tablespace_footer(&cont, tableinfo.relkind, tableinfo.tablespace,
 							  true);
+
+		/* Access method info */
+		if (verbose && tableinfo.relam != NULL &&
+		   !(pset.hide_tableam && tableinfo.relam_is_default))
+		{
+			printfPQExpBuffer(&buf, _("Access method: %s"), tableinfo.relam);
+			printTableAddFooter(&cont, buf.data);
+		}
 	}
 
 	/* reloptions, if verbose */
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 176c85afd0..058233b348 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -127,6 +127,7 @@ typedef struct _psqlSettings
 	bool		quiet;
 	bool		singleline;
 	bool		singlestep;
+	bool		hide_tableam;
 	int			fetch_count;
 	int			histsize;
 	int			ignoreeof;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index e7536a8a06..b757febcc5 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -1128,6 +1128,11 @@ show_context_hook(const char *newval)
 	return true;
 }
 
+static bool
+hide_tableam_hook(const char *newval)
+{
+	return ParseVariableBool(newval, "HIDE_TABLEAM", &pset.hide_tableam);
+}
 
 static void
 EstablishVariableSpace(void)
@@ -1191,4 +1196,7 @@ EstablishVariableSpace(void)
 	SetVariableHooks(pset.vars, "SHOW_CONTEXT",
 					 show_context_substitute_hook,
 					 show_context_hook);
+	SetVariableHooks(pset.vars, "HIDE_TABLEAM",
+					 bool_substitute_hook,
+					 hide_tableam_hook);
 }
diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out
index 775b127121..4c9a55a08a 100644
--- a/src/test/regress/expected/psql.out
+++ b/src/test/regress/expected/psql.out
@@ -2773,6 +2773,44 @@ Argument data types | numeric
 Type                | func
 
 \pset tuples_only false
+-- check conditional tableam display
+-- Create a heap2 table am handler with heapam handler
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+CREATE TABLE tbl_heap2(f1 int, f2 char(100)) using heap2;
+CREATE TABLE tbl_heap(f1 int, f2 char(100)) using heap;
+\d+ tbl_heap2
+                                     Table "public.tbl_heap2"
+ Column |      Type      | Collation | Nullable | Default | Storage  | Stats target | Description 
+--------+----------------+-----------+----------+---------+----------+--------------+-------------
+ f1     | integer        |           |          |         | plain    |              | 
+ f2     | character(100) |           |          |         | extended |              | 
+Access method: heap2
+
+\d+ tbl_heap
+                                     Table "public.tbl_heap"
+ Column |      Type      | Collation | Nullable | Default | Storage  | Stats target | Description 
+--------+----------------+-----------+----------+---------+----------+--------------+-------------
+ f1     | integer        |           |          |         | plain    |              | 
+ f2     | character(100) |           |          |         | extended |              | 
+
+\set HIDE_TABLEAM off
+\d+ tbl_heap2
+                                     Table "public.tbl_heap2"
+ Column |      Type      | Collation | Nullable | Default | Storage  | Stats target | Description 
+--------+----------------+-----------+----------+---------+----------+--------------+-------------
+ f1     | integer        |           |          |         | plain    |              | 
+ f2     | character(100) |           |          |         | extended |              | 
+Access method: heap2
+
+\d+ tbl_heap
+                                     Table "public.tbl_heap"
+ Column |      Type      | Collation | Nullable | Default | Storage  | Stats target | Description 
+--------+----------------+-----------+----------+---------+----------+--------------+-------------
+ f1     | integer        |           |          |         | plain    |              | 
+ f2     | character(100) |           |          |         | extended |              | 
+Access method: heap
+
+\set HIDE_TABLEAM on
 -- test numericlocale (as best we can without control of psql's locale)
 \pset format aligned
 \pset expanded off
diff --git a/src/test/regress/pg_regress_main.c b/src/test/regress/pg_regress_main.c
index bd613e4fda..1b4bca704b 100644
--- a/src/test/regress/pg_regress_main.c
+++ b/src/test/regress/pg_regress_main.c
@@ -74,10 +74,11 @@ psql_start_test(const char *testname,
 	}
 
 	offset += snprintf(psql_cmd + offset, sizeof(psql_cmd) - offset,
-					   "\"%s%spsql\" -X -a -q -d \"%s\" < \"%s\" > \"%s\" 2>&1",
+					   "\"%s%spsql\" -X -a -q -d \"%s\" -v %s < \"%s\" > \"%s\" 2>&1",
 					   bindir ? bindir : "",
 					   bindir ? "/" : "",
 					   dblist->str,
+					   "HIDE_TABLEAM=\"on\"",
 					   infile,
 					   outfile);
 	if (offset >= sizeof(psql_cmd))
diff --git a/src/test/regress/sql/psql.sql b/src/test/regress/sql/psql.sql
index 1bb2a6e16d..09ba7b6c14 100644
--- a/src/test/regress/sql/psql.sql
+++ b/src/test/regress/sql/psql.sql
@@ -448,6 +448,19 @@ select 1 where false;
 \df exp
 \pset tuples_only false
 
+-- check conditional tableam display
+
+-- Create a heap2 table am handler with heapam handler
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+CREATE TABLE tbl_heap2(f1 int, f2 char(100)) using heap2;
+CREATE TABLE tbl_heap(f1 int, f2 char(100)) using heap;
+\d+ tbl_heap2
+\d+ tbl_heap
+\set HIDE_TABLEAM off
+\d+ tbl_heap2
+\d+ tbl_heap
+\set HIDE_TABLEAM on
+
 -- test numericlocale (as best we can without control of psql's locale)
 
 \pset format aligned

diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index 58bd3805f4..38f24ba1bf 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -85,6 +85,7 @@ static void _becomeUser(ArchiveHandle *AH, const char *user);
 static void _becomeOwner(ArchiveHandle *AH, TocEntry *te);
 static void _selectOutputSchema(ArchiveHandle *AH, const char *schemaName);
 static void _selectTablespace(ArchiveHandle *AH, const char *tablespace);
+static void _selectTableAccessMethod(ArchiveHandle *AH, const char *tableam);
 static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te);
 static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te);
 static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te);
@@ -1072,6 +1073,7 @@ ArchiveEntry(Archive *AHX,
 			 const char *namespace,
 			 const char *tablespace,
 			 const char *owner,
+			 const char *tableam,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
@@ -1099,6 +1101,7 @@ ArchiveEntry(Archive *AHX,
 	newToc->tag = pg_strdup(tag);
 	newToc->namespace = namespace ? pg_strdup(namespace) : NULL;
 	newToc->tablespace = tablespace ? pg_strdup(tablespace) : NULL;
+	newToc->tableam = tableam ? pg_strdup(tableam) : NULL;
 	newToc->owner = pg_strdup(owner);
 	newToc->desc = pg_strdup(desc);
 	newToc->defn = pg_strdup(defn);
@@ -2367,6 +2370,7 @@ _allocAH(const char *FileSpec, const ArchiveFormat fmt,
 	AH->currUser = NULL;		/* unknown */
 	AH->currSchema = NULL;		/* ditto */
 	AH->currTablespace = NULL;	/* ditto */
+	AH->currTableAm = NULL;	/* ditto */
 
 	AH->toc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
 
@@ -2594,6 +2598,7 @@ WriteToc(ArchiveHandle *AH)
 		WriteStr(AH, te->namespace);
 		WriteStr(AH, te->tablespace);
 		WriteStr(AH, te->owner);
+		WriteStr(AH, te->tableam);
 		WriteStr(AH, "false");
 
 		/* Dump list of dependencies */
@@ -2696,6 +2701,9 @@ ReadToc(ArchiveHandle *AH)
 			te->tablespace = ReadStr(AH);
 
 		te->owner = ReadStr(AH);
+		if (AH->version >= K_VERS_1_14)
+			te->tableam = ReadStr(AH);
+
 		if (AH->version < K_VERS_1_9 || strcmp(ReadStr(AH), "true") == 0)
 			write_msg(modulename,
 					  "WARNING: restoring tables WITH OIDS is not supported anymore");
@@ -3288,6 +3296,9 @@ _reconnectToDB(ArchiveHandle *AH, const char *dbname)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 
 	/* re-establish fixed state */
 	_doSetFixedOutputState(AH);
@@ -3448,6 +3459,48 @@ _selectTablespace(ArchiveHandle *AH, const char *tablespace)
 	destroyPQExpBuffer(qry);
 }
 
+/*
+ * Set the proper default_table_access_method value for the table.
+ */
+static void
+_selectTableAccessMethod(ArchiveHandle *AH, const char *tableam)
+{
+	PQExpBuffer cmd;
+	const char *want, *have;
+
+	have = AH->currTableAm;
+	want = tableam;
+
+	if (!want)
+		return;
+
+	if (have && strcmp(want, have) == 0)
+		return;
+
+	cmd = createPQExpBuffer();
+	appendPQExpBuffer(cmd, "SET default_table_access_method = %s;", fmtId(want));
+
+	if (RestoringToDB(AH))
+	{
+		PGresult   *res;
+
+		res = PQexec(AH->connection, cmd->data);
+
+		if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
+			warn_or_exit_horribly(AH, modulename,
+								  "could not set default_table_access_method: %s",
+								  PQerrorMessage(AH->connection));
+
+		PQclear(res);
+	}
+	else
+		ahprintf(AH, "%s\n\n", cmd->data);
+
+	destroyPQExpBuffer(cmd);
+
+	AH->currTableAm = pg_strdup(want);
+}
+
 /*
  * Extract an object description for a TOC entry, and append it to buf.
  *
@@ -3547,6 +3600,7 @@ _printTocEntry(ArchiveHandle *AH, TocEntry *te, bool isData)
 	_becomeOwner(AH, te);
 	_selectOutputSchema(AH, te->namespace);
 	_selectTablespace(AH, te->tablespace);
+	_selectTableAccessMethod(AH, te->tableam);
 
 	/* Emit header comment for item */
 	if (!AH->noTocComments)
@@ -4021,6 +4075,9 @@ restore_toc_entries_prefork(ArchiveHandle *AH, TocEntry *pending_list)
 	if (AH->currTablespace)
 		free(AH->currTablespace);
 	AH->currTablespace = NULL;
+	if (AH->currTableAm)
+		free(AH->currTableAm);
+	AH->currTableAm = NULL;
 }
 
 /*
@@ -4816,6 +4873,7 @@ CloneArchive(ArchiveHandle *AH)
 	clone->currUser = NULL;
 	clone->currSchema = NULL;
 	clone->currTablespace = NULL;
+	clone->currTableAm = NULL;
 
 	/* savedPassword must be local in case we change it while connecting */
 	if (clone->savedPassword)
@@ -4906,6 +4964,8 @@ DeCloneArchive(ArchiveHandle *AH)
 		free(AH->currSchema);
 	if (AH->currTablespace)
 		free(AH->currTablespace);
+	if (AH->currTableAm)
+		free(AH->currTableAm);
 	if (AH->savedPassword)
 		free(AH->savedPassword);
 
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 306d2ceba9..c719fca0ad 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -94,10 +94,11 @@ typedef z_stream *z_streamp;
 													 * entries */
 #define K_VERS_1_13 MAKE_ARCHIVE_VERSION(1, 13, 0)	/* change search_path
 													 * behavior */
+#define K_VERS_1_14 MAKE_ARCHIVE_VERSION(1, 14, 0)	/* add tableam */
 
 /* Current archive version number (the format we can output) */
 #define K_VERS_MAJOR 1
-#define K_VERS_MINOR 13
+#define K_VERS_MINOR 14
 #define K_VERS_REV 0
 #define K_VERS_SELF MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV);
 
@@ -347,6 +348,7 @@ struct _archiveHandle
 	char	   *currUser;		/* current username, or NULL if unknown */
 	char	   *currSchema;		/* current schema, or NULL */
 	char	   *currTablespace; /* current tablespace, or NULL */
+	char	   *currTableAm; 	/* current table access method, or NULL */
 
 	void	   *lo_buf;
 	size_t		lo_buf_used;
@@ -373,6 +375,8 @@ struct _tocEntry
 	char	   *namespace;		/* null or empty string if not in a schema */
 	char	   *tablespace;		/* null if not in a tablespace; empty string
 								 * means use database default */
+	char	   *tableam;		/* table access method, only for TABLE tags */
+
 	char	   *owner;
 	char	   *desc;
 	char	   *defn;
@@ -410,7 +414,7 @@ extern TocEntry *ArchiveEntry(Archive *AHX,
 			 CatalogId catalogId, DumpId dumpId,
 			 const char *tag,
 			 const char *namespace, const char *tablespace,
-			 const char *owner,
+			 const char *owner, const char *amname,
 			 const char *desc, teSection section,
 			 const char *defn,
 			 const char *dropStmt, const char *copyStmt,
diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 637c79af48..512c486546 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -2136,7 +2136,7 @@ dumpTableData(Archive *fout, TableDataInfo *tdinfo)
 
 		te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
 						  tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
-						  NULL, tbinfo->rolname,
+						  NULL, tbinfo->rolname, NULL,
 						  "TABLE DATA", SECTION_DATA,
 						  "", "", copyStmt,
 						  &(tbinfo->dobj.dumpId), 1,
@@ -2188,6 +2188,7 @@ refreshMatViewData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name, /* Namespace */
 					 NULL,		/* Tablespace */
 					 tbinfo->rolname,	/* Owner */
+					 NULL,				/* Table access method */
 					 "MATERIALIZED VIEW DATA",	/* Desc */
 					 SECTION_POST_DATA, /* Section */
 					 q->data,	/* Create */
@@ -2726,6 +2727,7 @@ dumpDatabase(Archive *fout)
 				 NULL,			/* Namespace */
 				 NULL,			/* Tablespace */
 				 dba,			/* Owner */
+				 NULL,			/* Table access method */
 				 "DATABASE",	/* Desc */
 				 SECTION_PRE_DATA,	/* Section */
 				 creaQry->data, /* Create */
@@ -2762,7 +2764,7 @@ dumpDatabase(Archive *fout)
 			appendPQExpBufferStr(dbQry, ";\n");
 
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "COMMENT", SECTION_NONE,
 						 dbQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2789,7 +2791,7 @@ dumpDatabase(Archive *fout)
 		emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
 		if (seclabelQry->len > 0)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
-						 labelq->data, NULL, NULL, dba,
+						 labelq->data, NULL, NULL, dba, NULL,
 						 "SECURITY LABEL", SECTION_NONE,
 						 seclabelQry->data, "", NULL,
 						 &(dbDumpId), 1,
@@ -2859,7 +2861,7 @@ dumpDatabase(Archive *fout)
 
 	if (creaQry->len > 0)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 datname, NULL, NULL, dba,
+					 datname, NULL, NULL, dba, NULL,
 					 "DATABASE PROPERTIES", SECTION_PRE_DATA,
 					 creaQry->data, delQry->data, NULL,
 					 &(dbDumpId), 1,
@@ -2904,7 +2906,7 @@ dumpDatabase(Archive *fout)
 						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
 						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 "pg_largeobject", NULL, NULL, "",
+					 "pg_largeobject", NULL, NULL, "", NULL,
 					 "pg_largeobject", SECTION_PRE_DATA,
 					 loOutQry->data, "", NULL,
 					 NULL, 0,
@@ -3014,7 +3016,7 @@ dumpEncoding(Archive *AH)
 	appendPQExpBufferStr(qry, ";\n");
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "ENCODING", NULL, NULL, "",
+				 "ENCODING", NULL, NULL, "", NULL,
 				 "ENCODING", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3041,7 +3043,7 @@ dumpStdStrings(Archive *AH)
 					  stdstrings);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "STDSTRINGS", NULL, NULL, "",
+				 "STDSTRINGS", NULL, NULL, "", NULL,
 				 "STDSTRINGS", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3097,7 +3099,7 @@ dumpSearchPath(Archive *AH)
 		write_msg(NULL, "saving search_path = %s\n", path->data);
 
 	ArchiveEntry(AH, nilCatalogId, createDumpId(),
-				 "SEARCHPATH", NULL, NULL, "",
+				 "SEARCHPATH", NULL, NULL, "", NULL,
 				 "SEARCHPATH", SECTION_PRE_DATA,
 				 qry->data, "", NULL,
 				 NULL, 0,
@@ -3275,7 +3277,7 @@ dumpBlob(Archive *fout, BlobInfo *binfo)
 		ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
 					 binfo->dobj.name,
 					 NULL, NULL,
-					 binfo->rolname,
+					 binfo->rolname, NULL,
 					 "BLOB", SECTION_PRE_DATA,
 					 cquery->data, dquery->data, NULL,
 					 NULL, 0,
@@ -3581,6 +3583,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 						 polinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "ROW SECURITY", SECTION_POST_DATA,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -3637,6 +3640,7 @@ dumpPolicy(Archive *fout, PolicyInfo *polinfo)
 					 polinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "POLICY", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -3811,6 +3815,7 @@ dumpPublication(Archive *fout, PublicationInfo *pubinfo)
 				 NULL,
 				 NULL,
 				 pubinfo->rolname,
+				 NULL,
 				 "PUBLICATION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -3954,6 +3959,7 @@ dumpPublicationTable(Archive *fout, PublicationRelInfo *pubrinfo)
 				 tbinfo->dobj.namespace->dobj.name,
 				 NULL,
 				 "",
+				 NULL,
 				 "PUBLICATION TABLE", SECTION_POST_DATA,
 				 query->data, "", NULL,
 				 NULL, 0,
@@ -4147,6 +4153,7 @@ dumpSubscription(Archive *fout, SubscriptionInfo *subinfo)
 				 NULL,
 				 NULL,
 				 subinfo->rolname,
+				 NULL,
 				 "SUBSCRIPTION", SECTION_POST_DATA,
 				 query->data, delq->data, NULL,
 				 NULL, 0,
@@ -5829,6 +5836,7 @@ getTables(Archive *fout, int *numTables)
 	int			i_partkeydef;
 	int			i_ispartition;
 	int			i_partbound;
+	int			i_amname;
 
 	/*
 	 * Find all the tables and table-like objects.
@@ -5914,7 +5922,7 @@ getTables(Archive *fout, int *numTables)
 						  "tc.relfrozenxid AS tfrozenxid, "
 						  "tc.relminmxid AS tminmxid, "
 						  "c.relpersistence, c.relispopulated, "
-						  "c.relreplident, c.relpages, "
+						  "c.relreplident, c.relpages, am.amname, "
 						  "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
 						  "d.refobjid AS owning_tab, "
 						  "d.refobjsubid AS owning_col, "
@@ -5945,6 +5953,7 @@ getTables(Archive *fout, int *numTables)
 						  "d.objsubid = 0 AND "
 						  "d.refclassid = c.tableoid AND d.deptype IN ('a', 'i')) "
 						  "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+						  "LEFT JOIN pg_am am ON (c.relam = am.oid) "
 						  "LEFT JOIN pg_init_privs pip ON "
 						  "(c.oid = pip.objoid "
 						  "AND pip.classoid = 'pg_class'::regclass "
@@ -6412,6 +6421,7 @@ getTables(Archive *fout, int *numTables)
 	i_partkeydef = PQfnumber(res, "partkeydef");
 	i_ispartition = PQfnumber(res, "ispartition");
 	i_partbound = PQfnumber(res, "partbound");
+	i_amname = PQfnumber(res, "amname");
 
 	if (dopt->lockWaitTimeout)
 	{
@@ -6481,6 +6491,11 @@ getTables(Archive *fout, int *numTables)
 		else
 			tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
 		tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
+		if (PQgetisnull(res, i, i_amname))
+			tblinfo[i].amname = NULL;
+		else
+			tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
+
 
 		/* other fields were zeroed above */
 
@@ -9355,7 +9370,7 @@ dumpComment(Archive *fout, const char *type, const char *name,
 		 * post-data.
 		 */
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "COMMENT", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -9423,7 +9438,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9447,7 +9462,7 @@ dumpTableComment(Archive *fout, TableInfo *tbinfo,
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 tag->data,
 						 tbinfo->dobj.namespace->dobj.name,
-						 NULL, tbinfo->rolname,
+						 NULL, tbinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tbinfo->dobj.dumpId), 1,
@@ -9728,7 +9743,7 @@ dumpDumpableObject(Archive *fout, DumpableObject *dobj)
 				TocEntry   *te;
 
 				te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
-								  dobj->name, NULL, NULL, "",
+								  dobj->name, NULL, NULL, "", NULL,
 								  "BLOBS", SECTION_DATA,
 								  "", "", NULL,
 								  NULL, 0,
@@ -9802,7 +9817,7 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
 		ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
 					 nspinfo->dobj.name,
 					 NULL, NULL,
-					 nspinfo->rolname,
+					 nspinfo->rolname, NULL,
 					 "SCHEMA", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -9938,7 +9953,7 @@ dumpExtension(Archive *fout, ExtensionInfo *extinfo)
 		ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
 					 extinfo->dobj.name,
 					 NULL, NULL,
-					 "",
+					 "", NULL,
 					 "EXTENSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10090,6 +10105,7 @@ dumpEnumType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10217,6 +10233,7 @@ dumpRangeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10290,6 +10307,7 @@ dumpUndefinedType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10572,6 +10590,7 @@ dumpBaseType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10729,6 +10748,7 @@ dumpDomain(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "DOMAIN", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -10951,6 +10971,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
 					 tyinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tyinfo->rolname,
+					 NULL,
 					 "TYPE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -11085,7 +11106,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
 			ArchiveEntry(fout, nilCatalogId, createDumpId(),
 						 target->data,
 						 tyinfo->dobj.namespace->dobj.name,
-						 NULL, tyinfo->rolname,
+						 NULL, tyinfo->rolname, NULL,
 						 "COMMENT", SECTION_NONE,
 						 query->data, "", NULL,
 						 &(tyinfo->dobj.dumpId), 1,
@@ -11142,6 +11163,7 @@ dumpShellType(Archive *fout, ShellTypeInfo *stinfo)
 					 stinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 stinfo->baseType->rolname,
+					 NULL,
 					 "SHELL TYPE", SECTION_PRE_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -11251,7 +11273,7 @@ dumpProcLang(Archive *fout, ProcLangInfo *plang)
 	if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
 					 plang->dobj.name,
-					 NULL, NULL, plang->lanowner,
+					 NULL, NULL, plang->lanowner, NULL,
 					 "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -11924,6 +11946,7 @@ dumpFunc(Archive *fout, FuncInfo *finfo)
 					 finfo->dobj.namespace->dobj.name,
 					 NULL,
 					 finfo->rolname,
+					 NULL,
 					 keyword, SECTION_PRE_DATA,
 					 q->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12056,7 +12079,7 @@ dumpCast(Archive *fout, CastInfo *cast)
 	if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "CAST", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 NULL, 0,
@@ -12184,7 +12207,7 @@ dumpTransform(Archive *fout, TransformInfo *transform)
 	if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
 					 labelq->data,
-					 NULL, NULL, "",
+					 NULL, NULL, "", NULL,
 					 "TRANSFORM", SECTION_PRE_DATA,
 					 defqry->data, delqry->data, NULL,
 					 transform->dobj.dependencies, transform->dobj.nDeps,
@@ -12400,6 +12423,7 @@ dumpOpr(Archive *fout, OprInfo *oprinfo)
 					 oprinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 oprinfo->rolname,
+					 NULL,
 					 "OPERATOR", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12546,6 +12570,9 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 		case AMTYPE_INDEX:
 			appendPQExpBuffer(q, "TYPE INDEX ");
 			break;
+		case AMTYPE_TABLE:
+			appendPQExpBuffer(q, "TYPE TABLE ");
+			break;
 		default:
 			write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
 					  aminfo->amtype, qamname);
@@ -12570,6 +12597,7 @@ dumpAccessMethod(Archive *fout, AccessMethodInfo *aminfo)
 					 NULL,
 					 NULL,
 					 "",
+					 NULL,
 					 "ACCESS METHOD", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -12936,6 +12964,7 @@ dumpOpclass(Archive *fout, OpclassInfo *opcinfo)
 					 opcinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opcinfo->rolname,
+					 NULL,
 					 "OPERATOR CLASS", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13203,6 +13232,7 @@ dumpOpfamily(Archive *fout, OpfamilyInfo *opfinfo)
 					 opfinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 opfinfo->rolname,
+					 NULL,
 					 "OPERATOR FAMILY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13346,6 +13376,7 @@ dumpCollation(Archive *fout, CollInfo *collinfo)
 					 collinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 collinfo->rolname,
+					 NULL,
 					 "COLLATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13441,6 +13472,7 @@ dumpConversion(Archive *fout, ConvInfo *convinfo)
 					 convinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 convinfo->rolname,
+					 NULL,
 					 "CONVERSION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -13930,6 +13962,7 @@ dumpAgg(Archive *fout, AggInfo *agginfo)
 					 agginfo->aggfn.dobj.namespace->dobj.name,
 					 NULL,
 					 agginfo->aggfn.rolname,
+					 NULL,
 					 "AGGREGATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14028,6 +14061,7 @@ dumpTSParser(Archive *fout, TSParserInfo *prsinfo)
 					 prsinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH PARSER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14108,6 +14142,7 @@ dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo)
 					 dictinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 dictinfo->rolname,
+					 NULL,
 					 "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14169,6 +14204,7 @@ dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo)
 					 tmplinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14289,6 +14325,7 @@ dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo)
 					 cfginfo->dobj.namespace->dobj.name,
 					 NULL,
 					 cfginfo->rolname,
+					 NULL,
 					 "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14355,6 +14392,7 @@ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
 					 NULL,
 					 NULL,
 					 fdwinfo->rolname,
+					 NULL,
 					 "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14446,6 +14484,7 @@ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
 					 NULL,
 					 NULL,
 					 srvinfo->rolname,
+					 NULL,
 					 "SERVER", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -14564,6 +14603,7 @@ dumpUserMappings(Archive *fout,
 					 namespace,
 					 NULL,
 					 owner,
+					 NULL,
 					 "USER MAPPING", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 &dumpId, 1,
@@ -14643,6 +14683,7 @@ dumpDefaultACL(Archive *fout, DefaultACLInfo *daclinfo)
 					 daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
 					 NULL,
 					 daclinfo->defaclrole,
+					 NULL,
 					 "DEFAULT ACL", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -14741,6 +14782,7 @@ dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
 					 tag->data, nspname,
 					 NULL,
 					 owner ? owner : "",
+					 NULL,
 					 "ACL", SECTION_NONE,
 					 sql->data, "", NULL,
 					 &(objDumpId), 1,
@@ -14826,7 +14868,7 @@ dumpSecLabel(Archive *fout, const char *type, const char *name,
 
 		appendPQExpBuffer(tag, "%s %s", type, name);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
-					 tag->data, namespace, NULL, owner,
+					 tag->data, namespace, NULL, owner, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(dumpId), 1,
@@ -14908,7 +14950,7 @@ dumpTableSecLabel(Archive *fout, TableInfo *tbinfo, const char *reltypename)
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 target->data,
 					 tbinfo->dobj.namespace->dobj.name,
-					 NULL, tbinfo->rolname,
+					 NULL, tbinfo->rolname, NULL,
 					 "SECURITY LABEL", SECTION_NONE,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -15994,6 +16036,8 @@ dumpTableSchema(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
 					 tbinfo->rolname,
+					 (tbinfo->relkind == RELKIND_RELATION) ?
+					 tbinfo->amname : NULL,
 					 reltypename,
 					 tbinfo->postponed_def ?
 					 SECTION_POST_DATA : SECTION_PRE_DATA,
@@ -16074,6 +16118,7 @@ dumpAttrDef(Archive *fout, AttrDefInfo *adinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "DEFAULT", SECTION_PRE_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16190,6 +16235,7 @@ dumpIndex(Archive *fout, IndxInfo *indxinfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "INDEX", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16234,6 +16280,7 @@ dumpIndexAttach(Archive *fout, IndexAttachInfo *attachinfo)
 					 attachinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 "",
+					 NULL,
 					 "INDEX ATTACH", SECTION_POST_DATA,
 					 q->data, "", NULL,
 					 NULL, 0,
@@ -16289,6 +16336,7 @@ dumpStatisticsExt(Archive *fout, StatsExtInfo *statsextinfo)
 					 statsextinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 statsextinfo->rolname,
+					 NULL,
 					 "STATISTICS", SECTION_POST_DATA,
 					 q->data, delq->data, NULL,
 					 NULL, 0,
@@ -16450,6 +16498,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 indxinfo->tablespace,
 						 tbinfo->rolname,
+						 NULL,
 						 "CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16490,6 +16539,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 						 tbinfo->dobj.namespace->dobj.name,
 						 NULL,
 						 tbinfo->rolname,
+						 NULL,
 						 "FK CONSTRAINT", SECTION_POST_DATA,
 						 q->data, delq->data, NULL,
 						 NULL, 0,
@@ -16522,6 +16572,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16555,6 +16606,7 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
 							 tyinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tyinfo->rolname,
+							 NULL,
 							 "CHECK CONSTRAINT", SECTION_POST_DATA,
 							 q->data, delq->data, NULL,
 							 NULL, 0,
@@ -16829,6 +16881,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE", SECTION_PRE_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -16870,6 +16923,7 @@ dumpSequence(Archive *fout, TableInfo *tbinfo)
 							 tbinfo->dobj.namespace->dobj.name,
 							 NULL,
 							 tbinfo->rolname,
+							 NULL,
 							 "SEQUENCE OWNED BY", SECTION_PRE_DATA,
 							 query->data, "", NULL,
 							 &(tbinfo->dobj.dumpId), 1,
@@ -16938,6 +16992,7 @@ dumpSequenceData(Archive *fout, TableDataInfo *tdinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "SEQUENCE SET", SECTION_DATA,
 					 query->data, "", NULL,
 					 &(tbinfo->dobj.dumpId), 1,
@@ -17137,6 +17192,7 @@ dumpTrigger(Archive *fout, TriggerInfo *tginfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17223,7 +17279,7 @@ dumpEventTrigger(Archive *fout, EventTriggerInfo *evtinfo)
 	if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
 		ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
 					 evtinfo->dobj.name, NULL, NULL,
-					 evtinfo->evtowner,
+					 evtinfo->evtowner, NULL,
 					 "EVENT TRIGGER", SECTION_POST_DATA,
 					 query->data, delqry->data, NULL,
 					 NULL, 0,
@@ -17384,6 +17440,7 @@ dumpRule(Archive *fout, RuleInfo *rinfo)
 					 tbinfo->dobj.namespace->dobj.name,
 					 NULL,
 					 tbinfo->rolname,
+					 NULL,
 					 "RULE", SECTION_POST_DATA,
 					 cmd->data, delcmd->data, NULL,
 					 NULL, 0,
diff --git a/src/bin/pg_dump/pg_dump.h b/src/bin/pg_dump/pg_dump.h
index 789d6a24e2..4024d0c1e3 100644
--- a/src/bin/pg_dump/pg_dump.h
+++ b/src/bin/pg_dump/pg_dump.h
@@ -324,6 +324,7 @@ typedef struct _tableInfo
 	char	   *partkeydef;		/* partition key definition */
 	char	   *partbound;		/* partition bound definition */
 	bool		needs_override; /* has GENERATED ALWAYS AS IDENTITY */
+	char	   *amname; 		/* table access method */
 
 	/*
 	 * Stuff computed only for dumpable tables.
diff --git a/src/test/modules/test_pg_dump/t/001_base.pl b/src/test/modules/test_pg_dump/t/001_base.pl
index fb4ecf8aca..4c0bc695fc 100644
--- a/src/test/modules/test_pg_dump/t/001_base.pl
+++ b/src/test/modules/test_pg_dump/t/001_base.pl
@@ -322,6 +322,19 @@ my %tests = (
 		like => { binary_upgrade => 1, },
 	},
 
+	'CREATE ACCESS METHOD regress_test_table_am' => {
+		create_order => 11,
+        create_sql   => 'CREATE ACCESS METHOD regress_table_am TYPE TABLE HANDLER heap_tableam_handler;',
+		regexp => qr/^
+			\QCREATE ACCESS METHOD regress_table_am TYPE TABLE HANDLER heap_tableam_handler;\E
+			\n/xm,
+		like => {
+            %full_runs,
+            schema_only         => 1,
+            section_pre_data    => 1,
+        },
+	},
+
 	'COMMENT ON EXTENSION test_pg_dump' => {
 		regexp => qr/^
 			\QCOMMENT ON EXTENSION test_pg_dump \E
@@ -537,6 +550,32 @@ my %tests = (
 			schema_only      => 1,
 			section_pre_data => 1,
 		},
+	},
+
+	'SET regress_pg_dump_table_am' => {
+		create_order => 12,
+		regexp => qr/^
+			\QSET default_table_access_method = regress_table_am;\E
+			\n/xm,
+		like => {
+            %full_runs,
+            schema_only         => 1,
+            section_pre_data    => 1,
+        },
+	},
+
+	'CREATE TABLE regress_pg_dump_table_am' => {
+		create_order => 13,
+		create_sql =>
+		  'CREATE TABLE regress_pg_dump_table_am (col1 int not null, col2 int) USING regress_table_am;',
+		regexp => qr/^
+			\QCREATE TABLE public.regress_pg_dump_table_added (\E
+			\n\s+\Qcol1 integer NOT NULL,\E
+			\n\s+\Qcol2 integer\E
+			\n\);\n/xm,
+		like => {
+            binary_upgrade => 1,
+        },
 	},);
 
 #########################################

diff --git a/src/test/regress/expected/create_am.out b/src/test/regress/expected/create_am.out
index e15ba33..1a3686e 100644
--- a/src/test/regress/expected/create_am.out
+++ b/src/test/regress/expected/create_am.out
@@ -165,16 +165,98 @@ CREATE SEQUENCE test_seq USING heap2;
 ERROR:  syntax error at or near "USING"
 LINE 1: CREATE SEQUENCE test_seq USING heap2;
                                  ^
+--
+-- Test dependencies of various object types with their table access method.
+--
+set default_table_access_method = 'heap2';
+-- Partitioned tables : this should have tableam dependency.
+CREATE TABLE parted_heap2 ( a text, b int) PARTITION BY list (a) USING heap2;
+CREATE TABLE part1_heap2  PARTITION OF parted_heap2 for VALUES in ('a', 'b');
+-- Create these relation kinds so as to verify that no tableam dependency is
+-- created for them, in case of unsupported default_table_access_method.
+CREATE VIEW test_view AS SELECT * FROM tbl_heap2;
+CREATE SEQUENCE test_seq;
+-- Foreign tables.
+CREATE FOREIGN DATA WRAPPER fdw_heap2 VALIDATOR postgresql_fdw_validator;
+CREATE SERVER fs_heap2 FOREIGN DATA WRAPPER fdw_heap2 ;
+CREATE FOREIGN table ft_heap2 () SERVER fs_heap2;
+-- Toast tables: Base table should have the dependency, but it's toast table
+-- should not.
+CREATE TABLE toast_table_heap2(v varchar);
+-- Composite types.
+CREATE TYPE ct_heap2 AS (id int, v varchar);
+\set depend_query 'SELECT pg_describe_object(classid,objid,objsubid) AS obj FROM pg_depend, pg_am WHERE pg_depend.refclassid = $$pg_am$$::regclass AND pg_am.oid = pg_depend.refobjid AND pg_am.amname = $$heap2$$ ORDER BY 1'
+-- Show all the dependencies
+:depend_query;
+            obj             
+----------------------------
+ materialized view mv_heap2
+ table part1_heap2
+ table parted_heap2
+ table tblas_heap2
+ table tbl_heap2
+ table toast_table_heap2
+(6 rows)
+
 -- Drop table access method, but fails as objects depends on it
 DROP ACCESS METHOD heap2;
 ERROR:  cannot drop access method heap2 because other objects depend on it
 DETAIL:  table tbl_heap2 depends on access method heap2
+view test_view depends on table tbl_heap2
+table tblas_heap2 depends on access method heap2
+materialized view mv_heap2 depends on access method heap2
+table parted_heap2 depends on access method heap2
+table toast_table_heap2 depends on access method heap2
+HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+-- Drop the dependent objects one by one, and verify the effect on dependencies.
+DROP TABLE parted_heap2;
+:depend_query;
+            obj             
+----------------------------
+ materialized view mv_heap2
+ table tblas_heap2
+ table tbl_heap2
+ table toast_table_heap2
+(4 rows)
+
+DROP ACCESS METHOD heap2;
+ERROR:  cannot drop access method heap2 because other objects depend on it
+DETAIL:  table tbl_heap2 depends on access method heap2
+view test_view depends on table tbl_heap2
 table tblas_heap2 depends on access method heap2
 materialized view mv_heap2 depends on access method heap2
+table toast_table_heap2 depends on access method heap2
+HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+DROP MATERIALIZED VIEW mv_heap2;
+:depend_query;
+           obj           
+-------------------------
+ table tblas_heap2
+ table tbl_heap2
+ table toast_table_heap2
+(3 rows)
+
+DROP ACCESS METHOD heap2;
+ERROR:  cannot drop access method heap2 because other objects depend on it
+DETAIL:  table tbl_heap2 depends on access method heap2
+view test_view depends on table tbl_heap2
+table tblas_heap2 depends on access method heap2
+table toast_table_heap2 depends on access method heap2
 HINT:  Use DROP ... CASCADE to drop the dependent objects too.
--- Drop table access method with cascade
-DROP ACCESS METHOD heap2 CASCADE;
-NOTICE:  drop cascades to 3 other objects
-DETAIL:  drop cascades to table tbl_heap2
-drop cascades to table tblas_heap2
-drop cascades to materialized view mv_heap2
+DROP VIEW test_view;
+DROP TABLE tbl_heap2;
+DROP TABLE tblas_heap2;
+DROP TABLE toast_table_heap2;
+:depend_query;
+ obj 
+-----
+(0 rows)
+
+DROP ACCESS METHOD heap2;
+-- cleanup
+reset default_table_access_method;
+DROP FOREIGN TABLE ft_heap2;
+DROP SERVER fs_heap2;
+DROP FOREIGN DATA WRAPPER fdw_heap2;
+DROP SEQUENCE test_seq;
+DROP TYPE ct_heap2;
diff --git a/src/test/regress/sql/create_am.sql b/src/test/regress/sql/create_am.sql
index 2c7b481..75cb512 100644
--- a/src/test/regress/sql/create_am.sql
+++ b/src/test/regress/sql/create_am.sql
@@ -108,8 +108,58 @@ CREATE VIEW test_view USING heap2 AS SELECT * FROM tbl_heap2;
 CREATE SEQUENCE test_seq USING heap2;
 
 
+--
+-- Test dependencies of various object types with their table access method.
+--
+
+set default_table_access_method = 'heap2';
+
+-- Partitioned tables : this should have tableam dependency.
+CREATE TABLE parted_heap2 ( a text, b int) PARTITION BY list (a) USING heap2;
+CREATE TABLE part1_heap2  PARTITION OF parted_heap2 for VALUES in ('a', 'b');
+
+-- Create these relation kinds so as to verify that no tableam dependency is
+-- created for them, in case of unsupported default_table_access_method.
+CREATE VIEW test_view AS SELECT * FROM tbl_heap2;
+CREATE SEQUENCE test_seq;
+-- Foreign tables.
+CREATE FOREIGN DATA WRAPPER fdw_heap2 VALIDATOR postgresql_fdw_validator;
+CREATE SERVER fs_heap2 FOREIGN DATA WRAPPER fdw_heap2 ;
+CREATE FOREIGN table ft_heap2 () SERVER fs_heap2;
+-- Toast tables: Base table should have the dependency, but it's toast table
+-- should not.
+CREATE TABLE toast_table_heap2(v varchar);
+-- Composite types.
+CREATE TYPE ct_heap2 AS (id int, v varchar);
+
+\set depend_query 'SELECT pg_describe_object(classid,objid,objsubid) AS obj FROM pg_depend, pg_am WHERE pg_depend.refclassid = $$pg_am$$::regclass AND pg_am.oid = pg_depend.refobjid AND pg_am.amname = $$heap2$$ ORDER BY 1'
+
+-- Show all the dependencies
+:depend_query;
+
 -- Drop table access method, but fails as objects depends on it
 DROP ACCESS METHOD heap2;
 
--- Drop table access method with cascade
-DROP ACCESS METHOD heap2 CASCADE;
+-- Drop the dependent objects one by one, and verify the effect on dependencies.
+DROP TABLE parted_heap2;
+:depend_query;
+DROP ACCESS METHOD heap2;
+
+DROP MATERIALIZED VIEW mv_heap2;
+:depend_query;
+DROP ACCESS METHOD heap2;
+
+DROP VIEW test_view;
+DROP TABLE tbl_heap2;
+DROP TABLE tblas_heap2;
+DROP TABLE toast_table_heap2;
+:depend_query;
+DROP ACCESS METHOD heap2;
+
+-- cleanup
+reset default_table_access_method;
+DROP FOREIGN TABLE ft_heap2;
+DROP SERVER fs_heap2;
+DROP FOREIGN DATA WRAPPER fdw_heap2;
+DROP SEQUENCE test_seq;
+DROP TYPE ct_heap2;

From 3023a9c77892af520c392c8b6fc944ad0ff75096 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Fri, 25 Jan 2019 15:04:50 +1100
Subject: [PATCH] Doc and comments update

---
 doc/src/sgml/{indexam.sgml => am.sgml}        | 506 +++++++++++++++++-
 doc/src/sgml/catalogs.sgml                    |   5 +-
 doc/src/sgml/config.sgml                      |  24 +
 doc/src/sgml/filelist.sgml                    |   2 +-
 doc/src/sgml/postgres.sgml                    |   2 +-
 doc/src/sgml/ref/create_access_method.sgml    |  12 +-
 .../sgml/ref/create_materialized_view.sgml    |  14 +
 doc/src/sgml/ref/create_table.sgml            |  18 +-
 doc/src/sgml/ref/create_table_as.sgml         |  14 +
 doc/src/sgml/release-9.6.sgml                 |   2 +-
 doc/src/sgml/xindex.sgml                      |   2 +-
 src/backend/access/heap/heapam.c              |   8 +-
 src/backend/access/heap/heapam_handler.c      |  29 +-
 src/backend/access/table/tableam.c            |  10 +
 src/include/access/tableam.h                  | 165 ++++++
 15 files changed, 779 insertions(+), 34 deletions(-)
 rename doc/src/sgml/{indexam.sgml => am.sgml} (79%)

diff --git a/doc/src/sgml/indexam.sgml b/doc/src/sgml/am.sgml
similarity index 79%
rename from doc/src/sgml/indexam.sgml
rename to doc/src/sgml/am.sgml
index 05102724ea..118df57a1c 100644
--- a/doc/src/sgml/indexam.sgml
+++ b/doc/src/sgml/am.sgml
@@ -1,16 +1,480 @@
-<!-- doc/src/sgml/indexam.sgml -->
+<!-- doc/src/sgml/am.sgml -->
 
-<chapter id="indexam">
- <title>Index Access Method Interface Definition</title>
+<chapter id="am">
+ <title>Access Method Interface Definition</title>
 
   <para>
    This chapter defines the interface between the core
-   <productname>PostgreSQL</productname> system and <firstterm>index access
-   methods</firstterm>, which manage individual index types.  The core system
-   knows nothing about indexes beyond what is specified here, so it is
-   possible to develop entirely new index types by writing add-on code.
+   <productname>PostgreSQL</productname> system and <firstterm>access
+   methods</firstterm>, which manage individual <literal>INDEX</literal> 
+   and <literal>TABLE</literal> types.  The core system knows nothing
+   about these access methods beyond what is specified here, so it is
+   possible to develop entirely new access method types by writing add-on code.
+  </para>
+ 
+ <sect1 id="table-access-methods">
+  <title>Overview of Table access methods </title>
+  
+  <para>
+   All Tables in <productname>PostgreSQL</productname> are the primary
+   data store. Each table is stored as its own physical <firstterm>relation</firstterm>
+   and so is described by an entry in the <structname>pg_class</structname>
+   catalog. The contents of an table are entirely under the control of its
+   access method. (All the access methods furthermore use the standard page
+   layout described in <xref linkend="storage-page-layout"/>.)
+  </para>
+  
+ <sect2 id="table-api">
+  <title>Table access method API</title>
+  
+  <para>
+   Each table access method is described by a row in the
+   <link linkend="catalog-pg-am"><structname>pg_am</structname></link> system
+   catalog. The <structname>pg_am</structname> entry specifies a <firstterm>type</firstterm>
+   of the access method and a <firstterm>handler function</firstterm> for the
+   access method. These entries can be created and deleted using the <xref linkend="sql-create-access-method"/>
+   and <xref linkend="sql-drop-access-method"/> SQL commands.
+  </para>
+
+  <para>
+   A table access method handler function must be declared to accept a
+   single argument of type <type>internal</type> and to return the
+   pseudo-type <type>table_am_handler</type>.  The argument is a dummy value that
+   simply serves to prevent handler functions from being called directly from
+   SQL commands.  The result of the function must be a palloc'd struct of
+   type <structname>TableAmRoutine</structname>, which contains everything
+   that the core code needs to know to make use of the table access method.
+   The <structname>TableAmRoutine</structname> struct, also called the access
+   method's <firstterm>API struct</firstterm>, includes fields specifying assorted
+   fixed properties of the access method, such as whether it can support
+   bitmap scans.  More importantly, it contains pointers to support
+   functions for the access method, which do all of the real work to access
+   tables.  These support functions are plain C functions and are not
+   visible or callable at the SQL level.  The support functions are described
+   below.
+  </para>
+
+  <para>
+   The structure <structname>TableAmRoutine</structname> is defined thus:
+<programlisting>
+/*
+ * API struct for a table AM.  Note this must be allocated in a
+ * server-lifetime manner, typically as a static const struct, which then gets
+ * returned by FormData_pg_am.amhandler.
+ */
+typedef struct TableAmRoutine
+{
+	NodeTag		type;
+
+	/*
+	 * Return slot implementation suitable for storing a tuple of this AM.
+	 */
+	const TupleTableSlotOps *(*slot_callbacks) (Relation rel);
+
+
+	/* ------------------------------------------------------------------------
+	 * Table scan callbacks.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Returns scan descriptor that is opened on the provided relation based
+	 * on the provided keys.
+	 */
+	TableScanDesc (*scan_begin) (Relation rel,
+								 Snapshot snapshot,
+								 int nkeys, struct ScanKeyData *key,
+								 ParallelTableScanDesc parallel_scan,
+								 bool allow_strat,
+								 bool allow_sync,
+								 bool allow_pagemode,
+								 bool is_bitmapscan,
+								 bool is_samplescan,
+								 bool temp_snap);
+
+	/* API to end scan that is started */
+	void		(*scan_end) (TableScanDesc scan);
+
+	/* Restart the scan that is already started on the corresponding relation */
+	void		(*scan_rescan) (TableScanDesc scan, struct ScanKeyData *key, bool set_params,
+								bool allow_strat, bool allow_sync, bool allow_pagemode);
+
+	/* Returns the next satisfied tuple from the scan */
+	TupleTableSlot *(*scan_getnextslot) (TableScanDesc scan,
+										 ScanDirection direction, TupleTableSlot *slot);
+
+
+	/* ------------------------------------------------------------------------
+	 * Parallel table scan related functions.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Returns the total size that is required for the relation to perform
+	 * parallel sequential scan on the relation
+	 */
+	Size		(*parallelscan_estimate) (Relation rel);
+
+	/*
+	 * Initialize the parallel scan of the relation that is necessary and also
+	 * return the total size that is required for storing the parallel scan
+	 */
+	Size		(*parallelscan_initialize) (Relation rel, ParallelTableScanDesc parallel_scan);
+
+	/*
+	 * Reinitialize the parallel scan structure parameters that are necessary to
+	 * restart the parallel scan again.
+	 */
+	void		(*parallelscan_reinitialize) (Relation rel, ParallelTableScanDesc parallel_scan);
+
+
+	/* ------------------------------------------------------------------------
+	 * Index Scan Callbacks
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Returns the allocated prepared the IndexFetchTableData structure
+	 * for the relation.
+	 */
+	struct IndexFetchTableData *(*begin_index_fetch) (Relation rel);
+
+	/* Resets the internal members of the IndexFetchTableData structure */
+	void		(*reset_index_fetch) (struct IndexFetchTableData *data);
+
+	/* Frees the IndexFetchTableData that is allocated */
+	void		(*end_index_fetch) (struct IndexFetchTableData *data);
+
+	/*
+	 * Compute the newest xid among the tuples pointed to by items. This is
+	 * used to compute what snapshots to conflict with when replaying WAL
+	 * records for page-level index vacuums.
+	 */
+	TransactionId (*compute_xid_horizon_for_tuples) (Relation rel,
+													 ItemPointerData *items,
+													 int nitems);
+
+
+	/* ------------------------------------------------------------------------
+	 * Manipulations of physical tuples.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Insert the tuple into the relation specified and provide the location
+	 * of the tuple in the form of ItemPointerData and also use the
+	 * BulkInsertStateData if available.
+	 */
+	void		(*tuple_insert) (Relation rel, TupleTableSlot *slot, CommandId cid,
+								 int options, struct BulkInsertStateData *bistate);
+
+	/*
+	 * It is similar like tuple_insert API, but it inserts the tuple with
+	 * speculative token, to confirm the success of the operation.
+	 */
+	void		(*tuple_insert_speculative) (Relation rel,
+											 TupleTableSlot *slot,
+											 CommandId cid,
+											 int options,
+											 struct BulkInsertStateData *bistate,
+											 uint32 specToken);
+
+	/*
+	 * API to complete the speculative insert that is done by the
+	 * tuple_insert_speculative, returns the result based on the
+	 * success of the operation.
+	 */
+	void		(*tuple_complete_speculative) (Relation rel,
+											   TupleTableSlot *slot,
+											   uint32 specToken,
+											   bool succeeded);
+
+	/*
+	 * Deletes the tuple of a relation pointed by the ItemPointer
+	 * and returns the result of the operation. In case of any failure
+	 * updates the hufd.
+	 */
+	HTSU_Result (*tuple_delete) (Relation rel,
+								 ItemPointer tid,
+								 CommandId cid,
+								 Snapshot snapshot,
+								 Snapshot crosscheck,
+								 bool wait,
+								 HeapUpdateFailureData *hufd,
+								 bool changingPart);
+
+	/*
+	 * Update a tuple with the new tuple pointed by the ItemPointer and
+	 * returns the result of the operation and also updates the flag to
+	 * indicate whether the index needs an update or not? In case of any
+	 * failure, it update the hufd flag.
+	 */
+	HTSU_Result (*tuple_update) (Relation rel,
+								 ItemPointer otid,
+								 TupleTableSlot *slot,
+								 CommandId cid,
+								 Snapshot snapshot,
+								 Snapshot crosscheck,
+								 bool wait,
+								 HeapUpdateFailureData *hufd,
+								 LockTupleMode *lockmode,
+								 bool *update_indexes);
+
+	/*
+	 * Insert multiple tuples into the relation for faster data insertion.
+	 * It can use the BulkInsertStateData if available.
+	 */
+	void		(*multi_insert) (Relation rel, TupleTableSlot **slots, int nslots,
+								 CommandId cid, int options, struct BulkInsertStateData *bistate);
+
+	/*
+	 * Locks the tuple record specified by the ItemPointer after getting the
+	 * latest record and returns the result of the operation. In case of
+	 * failure updates the hufd.
+	 */
+	HTSU_Result (*tuple_lock) (Relation rel,
+							   ItemPointer tid,
+							   Snapshot snapshot,
+							   TupleTableSlot *slot,
+							   CommandId cid,
+							   LockTupleMode mode,
+							   LockWaitPolicy wait_policy,
+							   uint8 flags,
+							   HeapUpdateFailureData *hufd);
+
+	/*
+	 * Perform operations necessary to complete insertions made via
+	 * tuple_insert and multi_insert with a BulkInsertState specified. This
+	 * e.g. may e.g. used to flush the relation when inserting with skipping
+	 * WAL.
+	 *
+	 * May be NULL.
+	 */
+	void		(*finish_bulk_insert) (Relation rel, int options);
+
+
+	/* ------------------------------------------------------------------------
+	 * Non-modifying operations on individual tuples.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Fetches the latest tuple specified by the ItemPointer and store it
+	 * in the slot.
+	 */
+	bool		(*tuple_fetch_row_version) (Relation rel,
+											ItemPointer tid,
+											Snapshot snapshot,
+											TupleTableSlot *slot,
+											Relation stats_relation);
+
+	/*
+	 * Gets the latest ItemPointer of the tuple based on the specified
+	 * ItemPointer.
+	 *
+	 * For example, in the case of Heap AM, the update chains are created
+	 * whenever any tuple is updated. This API is useful to find out
+	 * latest ItemPointer.
+	 */
+	void		(*tuple_get_latest_tid) (Relation rel,
+										 Snapshot snapshot,
+										 ItemPointer tid);
+
+	/*
+	 * Fetches the tuple pointed by the ItemPointer based on the
+	 * IndexFetchTableData and store it in the specified slot and
+	 * also updates the flags.
+	 */
+	bool		(*tuple_fetch_follow) (struct IndexFetchTableData *scan,
+									   ItemPointer tid,
+									   Snapshot snapshot,
+									   TupleTableSlot *slot,
+									   bool *call_again, bool *all_dead);
+
+	/*
+	 * Performs the tuple visibility according to the snapshot and returns
+	 * "true" if is visible otherwise "false"
+	 */
+	bool		(*tuple_satisfies_snapshot) (Relation rel,
+											 TupleTableSlot *slot,
+											 Snapshot snapshot);
+
+
+	/* ------------------------------------------------------------------------
+	 * DDL related functionality.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Creates the storage that is necessary to store the tuples of the
+	 * relation and also updates the minimum XID that is possible to insert
+	 * the tuples.
+	 */
+	void		(*relation_set_new_filenode) (Relation rel,
+											  char persistence,
+											  TransactionId *freezeXid,
+											  MultiXactId *minmulti);
+
+	/*
+	 * Truncate the specified relation, this operation is not non-reversible.
+	 */
+	void		(*relation_nontransactional_truncate) (Relation rel);
+
+	/*
+	 * Performs copy of the relation existing data to the new filenodes
+	 * specified by the newrnode and removes the existing filenodes.
+	 */
+	void		(*relation_copy_data) (Relation rel, RelFileNode newrnode);
+
+	/*
+	 * Performs vacuuming of the relation based on the specified params.
+	 * It Gathers all the dead tuples of the relation and clean them including
+	 * the indexes.
+	 */
+	void		(*relation_vacuum) (Relation onerel, int options,
+									struct VacuumParams *params, BufferAccessStrategy bstrategy);
+
+	/*
+	 * Prepares the block of the relation specified for the analysis of tuples that
+	 * are present in the block.
+	 */
+	void		(*scan_analyze_next_block) (TableScanDesc scan, BlockNumber blockno,
+											BufferAccessStrategy bstrategy);
+
+	/*
+	 * Scans all the tuples in the page based on the snapshot and return the
+	 * visible tuple, and also update the stats related to the page.
+	 */
+	bool		(*scan_analyze_next_tuple) (TableScanDesc scan, TransactionId OldestXmin,
+											double *liverows, double *deadrows, TupleTableSlot *slot);
+
+	/*
+	 * Reorganizes the relation data in the new filenode according to the
+	 * specified index. All the tuples the new file node are ordered similar like
+	 * index and also removes some of the dead tuples.
+	 */
+	void		(*relation_copy_for_cluster) (Relation NewHeap, Relation OldHeap, Relation OldIndex,
+											  bool use_sort,
+											  TransactionId OldestXmin, TransactionId FreezeXid, MultiXactId MultiXactCutoff,
+											  double *num_tuples, double *tups_vacuumed, double *tups_recently_dead);
+
+	/*
+	 * Performs the range scan of the relation instead of performing the full scan.
+	 * Range scan can be specified by start and end block numbers. In case if there
+	 * is no range, specify the InvalidBlockNumber for end block.
+	 */
+	double		(*index_build_range_scan) (Relation heap_rel,
+										   Relation index_rel,
+										   IndexInfo *index_nfo,
+										   bool allow_sync,
+										   bool anyvisible,
+										   BlockNumber start_blockno,
+										   BlockNumber end_blockno,
+										   IndexBuildCallback callback,
+										   void *callback_state,
+										   TableScanDesc scan);
+
+	/*
+	 * Performs the table scan and insert the satisfied records into the index.
+	 * This API is similar like index_build_range_scan, but this is used for
+	 * the scenario where the index is getting build concurrently.
+	 */
+	void		(*index_validate_scan) (Relation heap_rel,
+										Relation index_rel,
+										IndexInfo *index_info,
+										Snapshot snapshot,
+										struct ValidateIndexState *state);
+
+
+	/* ------------------------------------------------------------------------
+	 * Planner related functions.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Estimates the total size of the relation and also returns the number of
+	 * pages, tuples and etc related to the corresponding relation.
+	 */
+	void		(*relation_estimate_size) (Relation rel, int32 *attr_widths,
+										   BlockNumber *pages, double *tuples, double *allvisfrac);
+
+
+	/* ------------------------------------------------------------------------
+	 * Executor related functions.
+	 * ------------------------------------------------------------------------
+	 */
+
+	/*
+	 * Scans the page for all the tuples and store all of their ItemPointers
+	 * based on the visibility.
+	 */
+	bool		(*scan_bitmap_pagescan) (TableScanDesc scan,
+										 TBMIterateResult *tbmres);
+
+	/* Returns the next tuple of the scan */
+	bool		(*scan_bitmap_pagescan_next) (TableScanDesc scan,
+											  TupleTableSlot *slot);
+
+	/*
+	 * Get the next block for sampling based on the sampling method that is
+	 * available or sequentially to get the next from the scan.
+	 */
+	bool		(*scan_sample_next_block) (TableScanDesc scan,
+										   struct SampleScanState *scanstate);
+
+	/*
+	 * Get the next tuple to sample from the current sampling block based on
+	 * the sampling method, otherwise get the next visible tuple of the block.
+	 */
+	bool		(*scan_sample_next_tuple) (TableScanDesc scan,
+										   struct SampleScanState *scanstate,
+										   TupleTableSlot *slot);
+} TableAmRoutine;
+
+</programlisting>
+  </para>
+ </sect2> 
+  
+ <sect2>
+  <title>Table scanning</title>
+  
+  <para>
   </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table insert/update/delete</title>
 
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table locking</title>
+
+  <para>
+  </para>
+  </sect2>
+ 
+ <sect2>
+  <title>Table vacuum</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ <sect2>
+  <title>Table fetch</title>
+
+  <para>
+  </para>
+ </sect2>
+ 
+ </sect1> 
+ 
+ <sect1 id="index-access-methods">
+  <title>Overview of Index access methods</title>
+  
   <para>
    All indexes in <productname>PostgreSQL</productname> are what are known
    technically as <firstterm>secondary indexes</firstterm>; that is, the index is
@@ -42,8 +506,8 @@
    dead tuples are reclaimed (by vacuuming) when the dead tuples themselves
    are reclaimed.
   </para>
-
- <sect1 id="index-api">
+  
+ <sect2 id="index-api">
   <title>Basic API Structure for Indexes</title>
 
   <para>
@@ -217,9 +681,9 @@ typedef struct IndexAmRoutine
    conditions.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-functions">
+ <sect2 id="index-functions">
   <title>Index Access Method Functions</title>
 
   <para>
@@ -710,9 +1174,11 @@ amparallelrescan (IndexScanDesc scan);
    the beginning.
   </para>
 
- </sect1>
+ </sect2>
+ 
+ 
 
- <sect1 id="index-scanning">
+ <sect2 id="index-scanning">
   <title>Index Scanning</title>
 
   <para>
@@ -865,9 +1331,9 @@ amparallelrescan (IndexScanDesc scan);
    if its internal implementation is unsuited to one API or the other.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-locking">
+ <sect2 id="index-locking">
   <title>Index Locking Considerations</title>
 
   <para>
@@ -979,9 +1445,9 @@ amparallelrescan (IndexScanDesc scan);
    reduce the frequency of such transaction cancellations.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-unique-checks">
+ <sect2 id="index-unique-checks">
   <title>Index Uniqueness Checks</title>
 
   <para>
@@ -1128,9 +1594,9 @@ amparallelrescan (IndexScanDesc scan);
     </itemizedlist>
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-cost-estimation">
+ <sect2 id="index-cost-estimation">
   <title>Index Cost Estimation Functions</title>
 
   <para>
@@ -1377,5 +1843,7 @@ cost_qual_eval(&amp;index_qual_cost, path-&gt;indexquals, root);
    Examples of cost estimator functions can be found in
    <filename>src/backend/utils/adt/selfuncs.c</filename>.
   </para>
+ </sect2>
  </sect1>
+ 
 </chapter>
diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index af4d0625ea..35122035e5 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -587,8 +587,9 @@
    The catalog <structname>pg_am</structname> stores information about
    relation access methods.  There is one row for each access method supported
    by the system.
-   Currently, only indexes have access methods.  The requirements for index
-   access methods are discussed in detail in <xref linkend="indexam"/>.
+   Currently, only <literal>INDEX</literal> and <literal>TABLE</literal> have
+   access methods.  The requirements for access methods are discussed in detail
+   in <xref linkend="am"/>.
   </para>
 
   <table>
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index b6f5822b84..0f62270cee 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7168,6 +7168,30 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-default-table-access-method" xreflabel="default_table_access_method">
+      <term><varname>default_table_access_method</varname> (<type>string</type>)
+      <indexterm>
+       <primary><varname>default_table_access_method</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        This variable specifies the default table access method using which to create
+        objects (tables and materialized views) when a <command>CREATE</command> command does
+        not explicitly specify an access method.
+       </para>
+
+       <para>
+        The value is either the name of a table access method, or an empty string
+        to specify using the default table access method of the current database.
+        If the value does not match the name of any existing table access methods,
+        <productname>PostgreSQL</productname> will automatically use the default
+        table access method of the current database.
+       </para>
+
+      </listitem>
+     </varlistentry>
+     
      <varlistentry id="guc-default-tablespace" xreflabel="default_tablespace">
       <term><varname>default_tablespace</varname> (<type>string</type>)
       <indexterm>
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 5dfdf54815..fed460b7c3 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -89,7 +89,7 @@
 <!ENTITY gin        SYSTEM "gin.sgml">
 <!ENTITY brin       SYSTEM "brin.sgml">
 <!ENTITY planstats    SYSTEM "planstats.sgml">
-<!ENTITY indexam    SYSTEM "indexam.sgml">
+<!ENTITY am         SYSTEM "am.sgml">
 <!ENTITY nls        SYSTEM "nls.sgml">
 <!ENTITY plhandler  SYSTEM "plhandler.sgml">
 <!ENTITY fdwhandler SYSTEM "fdwhandler.sgml">
diff --git a/doc/src/sgml/postgres.sgml b/doc/src/sgml/postgres.sgml
index 96d196d229..9dce0c5f81 100644
--- a/doc/src/sgml/postgres.sgml
+++ b/doc/src/sgml/postgres.sgml
@@ -250,7 +250,7 @@
   &tablesample-method;
   &custom-scan;
   &geqo;
-  &indexam;
+  &am;
   &generic-wal;
   &btree;
   &gist;
diff --git a/doc/src/sgml/ref/create_access_method.sgml b/doc/src/sgml/ref/create_access_method.sgml
index 851c5e63be..256914022a 100644
--- a/doc/src/sgml/ref/create_access_method.sgml
+++ b/doc/src/sgml/ref/create_access_method.sgml
@@ -61,7 +61,8 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
     <listitem>
      <para>
       This clause specifies the type of access method to define.
-      Only <literal>INDEX</literal> is supported at present.
+      Only <literal>INDEX</literal> and <literal>TABLE</literal>
+      are supported at present.
      </para>
     </listitem>
    </varlistentry>
@@ -76,9 +77,12 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
       declared to take a single argument of type <type>internal</type>,
       and its return type depends on the type of access method;
       for <literal>INDEX</literal> access methods, it must
-      be <type>index_am_handler</type>.  The C-level API that the handler
-      function must implement varies depending on the type of access method.
-      The index access method API is described in <xref linkend="indexam"/>.
+      be <type>index_am_handler</type> and for <literal>TABLE</literal>
+      access methods, it must be <type>table_am_handler</type>.
+      The C-level API that the handler function must implement varies
+      depending on the type of access method. The index access method API
+      is described in <xref linkend="index-access-methods"/> and the table access method
+      API is described in <xref linkend="table-access-methods"/>.
      </para>
     </listitem>
    </varlistentry>
diff --git a/doc/src/sgml/ref/create_materialized_view.sgml b/doc/src/sgml/ref/create_materialized_view.sgml
index 7f31ab4d26..3a052ee6a4 100644
--- a/doc/src/sgml/ref/create_materialized_view.sgml
+++ b/doc/src/sgml/ref/create_materialized_view.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
     AS <replaceable>query</replaceable>
@@ -85,6 +86,19 @@ CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new materialize view;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new materialized view. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml
index 857515ec8f..72a1a785e7 100644
--- a/doc/src/sgml/ref/create_table.sgml
+++ b/doc/src/sgml/ref/create_table.sgml
@@ -29,6 +29,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
 ] )
 [ INHERITS ( <replaceable>parent_table</replaceable> [, ... ] ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -40,6 +41,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -51,6 +53,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ] { FOR VALUES <replaceable class="parameter">partition_bound_spec</replaceable> | DEFAULT }
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -953,7 +956,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
 
      <para>
       The access method must support <literal>amgettuple</literal> (see <xref
-      linkend="indexam"/>); at present this means <acronym>GIN</acronym>
+      linkend="index-access-methods"/>); at present this means <acronym>GIN</acronym>
       cannot be used.  Although it's allowed, there is little point in using
       B-tree or hash indexes with an exclusion constraint, because this
       does nothing that an ordinary unique constraint doesn't do better.
@@ -1136,6 +1139,19 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/ref/create_table_as.sgml b/doc/src/sgml/ref/create_table_as.sgml
index 679e8f521e..90c9dbdaa5 100644
--- a/doc/src/sgml/ref/create_table_as.sgml
+++ b/doc/src/sgml/ref/create_table_as.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
     [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -120,6 +121,19 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml
index acebcc6249..c0a96c2cce 100644
--- a/doc/src/sgml/release-9.6.sgml
+++ b/doc/src/sgml/release-9.6.sgml
@@ -10763,7 +10763,7 @@ This commit is also listed under libpq and PL/pgSQL
 2016-08-13 [ed0097e4f] Add SQL-accessible functions for inspecting index AM pro
 -->
        <para>
-        Restructure <link linkend="indexam">index access
+        Restructure <link linkend="index-access-methods">index access
         method <acronym>API</acronym></link> to hide most of it at
         the <application>C</application> level (Alexander Korotkov, Andrew Gierth)
        </para>
diff --git a/doc/src/sgml/xindex.sgml b/doc/src/sgml/xindex.sgml
index 9446f8b836..4fa821160c 100644
--- a/doc/src/sgml/xindex.sgml
+++ b/doc/src/sgml/xindex.sgml
@@ -36,7 +36,7 @@
    described in <classname>pg_am</classname>.  It is possible to add a
    new index access method by writing the necessary code and
    then creating an entry in <classname>pg_am</classname> &mdash; but that is
-   beyond the scope of this chapter (see <xref linkend="indexam"/>).
+   beyond the scope of this chapter (see <xref linkend="am"/>).
   </para>
 
   <para>
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 6655a95433..328626d633 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -1098,7 +1098,10 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
  * ----------------------------------------------------------------
  */
 
-
+/*
+ * Returns the prepared Heap scan descriptor that is opened on the provided
+ * relation using the other members.
+ */
 TableScanDesc
 heap_beginscan(Relation relation, Snapshot snapshot,
 			   int nkeys, ScanKey key,
@@ -1332,6 +1335,9 @@ heap_getnext(TableScanDesc sscan, ScanDirection direction)
 #define HEAPAMSLOTDEBUG_3
 #endif
 
+/*
+ * Retrieve slot with next tuple in scan
+ */
 TupleTableSlot *
 heap_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 {
diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 3dc1444739..5f7b39360c 100644
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -63,13 +63,18 @@ reform_and_rewrite_tuple(HeapTuple tuple,
  * ----------------------------------------------------------------
  */
 
+/*
+ * Return slot implementation suitable for storing a tuple.
+ */
 static const TupleTableSlotOps *
 heapam_slot_callbacks(Relation relation)
 {
 	return &TTSOpsBufferHeapTuple;
 }
 
-
+/*
+ *
+ */
 static IndexFetchTableData *
 heapam_begin_index_fetch(Relation rel)
 {
@@ -107,8 +112,7 @@ heapam_end_index_fetch(IndexFetchTableData *scan)
 
 
 /*
- * Insert a heap tuple from a slot, which may contain an OID and speculative
- * insertion token.
+ * Insert a heap tuple from a slot, which may contain an OID
  */
 static void
 heapam_heap_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
@@ -128,6 +132,10 @@ heapam_heap_insert(Relation relation, TupleTableSlot *slot, CommandId cid,
 		pfree(tuple);
 }
 
+/*
+ * Insert a heap tuple from a slot, which may contain an OID and speculative
+ * insertion token.
+ */
 static void
 heapam_heap_insert_speculative(Relation relation, TupleTableSlot *slot, CommandId cid,
 							   int options, BulkInsertState bistate, uint32 specToken)
@@ -148,6 +156,9 @@ heapam_heap_insert_speculative(Relation relation, TupleTableSlot *slot, CommandI
 		pfree(tuple);
 }
 
+/*
+ * Complete the speculative insert based on the succeeded flag.
+ */
 static void
 heapam_heap_complete_speculative(Relation relation, TupleTableSlot *slot, uint32 spekToken,
 								 bool succeeded)
@@ -179,6 +190,11 @@ heapam_heap_delete(Relation relation, ItemPointer tid, CommandId cid,
 }
 
 
+/*
+ * Updates the heaptuple pointed by the Otid with the new tuple from slot
+ * and returns the flag to indicate whether the update affects indexes
+ * also.
+ */
 static HTSU_Result
 heapam_heap_update(Relation relation, ItemPointer otid, TupleTableSlot *slot,
 				   CommandId cid, Snapshot snapshot, Snapshot crosscheck,
@@ -448,6 +464,10 @@ retry:
 	return result;
 }
 
+/*
+ * Finish the bulk insert operation by syncing the relation
+ * to the disk filenodes in case if the bulk insert skip the WAL.
+ */
 static void
 heapam_finish_bulk_insert(Relation relation, int options)
 {
@@ -460,6 +480,9 @@ heapam_finish_bulk_insert(Relation relation, int options)
 }
 
 
+/*
+ *
+ */
 static bool
 heapam_fetch_row_version(Relation relation,
 						 ItemPointer tid,
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index a2da7b7809..8fed8a0e00 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -266,12 +266,19 @@ simple_table_delete(Relation rel, ItemPointer tid, Snapshot snapshot)
 }
 
 
+/*
+ * Returns the size required to perform Parallel Block table scan.
+ */
 Size
 table_block_parallelscan_estimate(Relation rel)
 {
 	return sizeof(ParallelBlockTableScanDescData);
 }
 
+/*
+ * Initializes the table block parallel scan with the relation specific
+ * information.
+ */
 Size
 table_block_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan)
 {
@@ -290,6 +297,9 @@ table_block_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan)
 	return sizeof(ParallelBlockTableScanDescData);
 }
 
+/*
+ * Reinitialize the table block parallel scan information
+ */
 void
 table_block_parallelscan_reinitialize(Relation rel, ParallelTableScanDesc pscan)
 {
diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index 4aa4369366..b997552fdb 100644
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -76,6 +76,10 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Returns scan descriptor that is opened on the provided relation based
+	 * on the provided keys.
+	 */
 	TableScanDesc (*scan_begin) (Relation rel,
 								 Snapshot snapshot,
 								 int nkeys, struct ScanKeyData *key,
@@ -86,9 +90,15 @@ typedef struct TableAmRoutine
 								 bool is_bitmapscan,
 								 bool is_samplescan,
 								 bool temp_snap);
+
+	/* API to end scan that is started */
 	void		(*scan_end) (TableScanDesc scan);
+
+	/* Restart the scan that is already started on the corresponding relation */
 	void		(*scan_rescan) (TableScanDesc scan, struct ScanKeyData *key, bool set_params,
 								bool allow_strat, bool allow_sync, bool allow_pagemode);
+
+	/* Returns the next satisfied tuple from the scan */
 	TupleTableSlot *(*scan_getnextslot) (TableScanDesc scan,
 										 ScanDirection direction, TupleTableSlot *slot);
 
@@ -97,8 +107,23 @@ typedef struct TableAmRoutine
 	 * Parallel table scan related functions.
 	 * ------------------------------------------------------------------------
 	 */
+
+	/*
+	 * Returns the total size that is required for the relation to perform
+	 * parallel sequential scan on the relation
+	 */
 	Size		(*parallelscan_estimate) (Relation rel);
+
+	/*
+	 * Initialize the parallel scan of the relation that is necessary and also
+	 * return the total size that is required for storing the parallel scan
+	 */
 	Size		(*parallelscan_initialize) (Relation rel, ParallelTableScanDesc parallel_scan);
+
+	/*
+	 * Reinitialize the parallel scan structure parameters that are necessary to
+	 * restart the parallel scan again.
+	 */
 	void		(*parallelscan_reinitialize) (Relation rel, ParallelTableScanDesc parallel_scan);
 
 
@@ -107,8 +132,16 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Returns the allocated prepared the IndexFetchTableData structure
+	 * for the relation.
+	 */
 	struct IndexFetchTableData *(*begin_index_fetch) (Relation rel);
+
+	/* Resets the internal members of the IndexFetchTableData structure */
 	void		(*reset_index_fetch) (struct IndexFetchTableData *data);
+
+	/* Frees the IndexFetchTableData that is allocated */
 	void		(*end_index_fetch) (struct IndexFetchTableData *data);
 
 	/*
@@ -126,18 +159,40 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Insert the tuple into the relation specified and provide the location
+	 * of the tuple in the form of ItemPointerData and also use the
+	 * BulkInsertStateData if available.
+	 */
 	void		(*tuple_insert) (Relation rel, TupleTableSlot *slot, CommandId cid,
 								 int options, struct BulkInsertStateData *bistate);
+
+	/*
+	 * It is similar like tuple_insert API, but it inserts the tuple with
+	 * speculative token, to confirm the success of the operation.
+	 */
 	void		(*tuple_insert_speculative) (Relation rel,
 											 TupleTableSlot *slot,
 											 CommandId cid,
 											 int options,
 											 struct BulkInsertStateData *bistate,
 											 uint32 specToken);
+
+	/*
+	 * API to complete the speculative insert that is done by the
+	 * tuple_insert_speculative, returns the result based on the
+	 * success of the operation.
+	 */
 	void		(*tuple_complete_speculative) (Relation rel,
 											   TupleTableSlot *slot,
 											   uint32 specToken,
 											   bool succeeded);
+
+	/*
+	 * Deletes the tuple of a relation pointed by the ItemPointer
+	 * and returns the result of the operation. In case of any failure
+	 * updates the hufd.
+	 */
 	HTSU_Result (*tuple_delete) (Relation rel,
 								 ItemPointer tid,
 								 CommandId cid,
@@ -146,6 +201,13 @@ typedef struct TableAmRoutine
 								 bool wait,
 								 HeapUpdateFailureData *hufd,
 								 bool changingPart);
+
+	/*
+	 * Update a tuple with the new tuple pointed by the ItemPointer and
+	 * returns the result of the operation and also updates the flag to
+	 * indicate whether the index needs an update or not? In case of any
+	 * failure, it update the hufd flag.
+	 */
 	HTSU_Result (*tuple_update) (Relation rel,
 								 ItemPointer otid,
 								 TupleTableSlot *slot,
@@ -156,8 +218,19 @@ typedef struct TableAmRoutine
 								 HeapUpdateFailureData *hufd,
 								 LockTupleMode *lockmode,
 								 bool *update_indexes);
+
+	/*
+	 * Insert multiple tuples into the relation for faster data insertion.
+	 * It can use the BulkInsertStateData if available.
+	 */
 	void		(*multi_insert) (Relation rel, TupleTableSlot **slots, int nslots,
 								 CommandId cid, int options, struct BulkInsertStateData *bistate);
+
+	/*
+	 * Locks the tuple record specified by the ItemPointer after getting the
+	 * latest record and returns the result of the operation. In case of
+	 * failure updates the hufd.
+	 */
 	HTSU_Result (*tuple_lock) (Relation rel,
 							   ItemPointer tid,
 							   Snapshot snapshot,
@@ -184,19 +257,43 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Fetches the latest tuple specified by the ItemPointer and store it
+	 * in the slot.
+	 */
 	bool		(*tuple_fetch_row_version) (Relation rel,
 											ItemPointer tid,
 											Snapshot snapshot,
 											TupleTableSlot *slot,
 											Relation stats_relation);
+
+	/*
+	 * Gets the latest ItemPointer of the tuple based on the specified
+	 * ItemPointer.
+	 *
+	 * For example, in the case of Heap AM, the update chains are created
+	 * whenever any tuple is updated. This API is useful to find out
+	 * latest ItemPointer.
+	 */
 	void		(*tuple_get_latest_tid) (Relation rel,
 										 Snapshot snapshot,
 										 ItemPointer tid);
+
+	/*
+	 * Fetches the tuple pointed by the ItemPointer based on the
+	 * IndexFetchTableData and store it in the specified slot and
+	 * also updates the flags.
+	 */
 	bool		(*tuple_fetch_follow) (struct IndexFetchTableData *scan,
 									   ItemPointer tid,
 									   Snapshot snapshot,
 									   TupleTableSlot *slot,
 									   bool *call_again, bool *all_dead);
+
+	/*
+	 * Performs the tuple visibility according to the snapshot and returns
+	 * "true" if is visible otherwise "false"
+	 */
 	bool		(*tuple_satisfies_snapshot) (Relation rel,
 											 TupleTableSlot *slot,
 											 Snapshot snapshot);
@@ -207,22 +304,64 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Creates the storage that is necessary to store the tuples of the
+	 * relation and also updates the minimum XID that is possible to insert
+	 * the tuples.
+	 */
 	void		(*relation_set_new_filenode) (Relation rel,
 											  char persistence,
 											  TransactionId *freezeXid,
 											  MultiXactId *minmulti);
+
+	/*
+	 * Truncate the specified relation, this operation is not non-reversible.
+	 */
 	void		(*relation_nontransactional_truncate) (Relation rel);
+
+	/*
+	 * Performs copy of the relation existing data to the new filenodes
+	 * specified by the newrnode and removes the existing filenodes.
+	 */
 	void		(*relation_copy_data) (Relation rel, RelFileNode newrnode);
+
+	/*
+	 * Performs vacuuming of the relation based on the specified params.
+	 * It Gathers all the dead tuples of the relation and clean them including
+	 * the indexes.
+	 */
 	void		(*relation_vacuum) (Relation onerel, int options,
 									struct VacuumParams *params, BufferAccessStrategy bstrategy);
+
+	/*
+	 * Prepares the block of the relation specified for the analysis of tuples that
+	 * are present in the block.
+	 */
 	void		(*scan_analyze_next_block) (TableScanDesc scan, BlockNumber blockno,
 											BufferAccessStrategy bstrategy);
+
+	/*
+	 * Scans all the tuples in the page based on the snapshot and return the
+	 * visible tuple, and also update the stats related to the page.
+	 */
 	bool		(*scan_analyze_next_tuple) (TableScanDesc scan, TransactionId OldestXmin,
 											double *liverows, double *deadrows, TupleTableSlot *slot);
+
+	/*
+	 * Reorganizes the relation data in the new filenode according to the
+	 * specified index. All the tuples the new file node are ordered similar like
+	 * index and also removes some of the dead tuples.
+	 */
 	void		(*relation_copy_for_cluster) (Relation NewHeap, Relation OldHeap, Relation OldIndex,
 											  bool use_sort,
 											  TransactionId OldestXmin, TransactionId FreezeXid, MultiXactId MultiXactCutoff,
 											  double *num_tuples, double *tups_vacuumed, double *tups_recently_dead);
+
+	/*
+	 * Performs the range scan of the relation instead of performing the full scan.
+	 * Range scan can be specified by start and end block numbers. In case if there
+	 * is no range, specify the InvalidBlockNumber for end block.
+	 */
 	double		(*index_build_range_scan) (Relation heap_rel,
 										   Relation index_rel,
 										   IndexInfo *index_nfo,
@@ -233,6 +372,12 @@ typedef struct TableAmRoutine
 										   IndexBuildCallback callback,
 										   void *callback_state,
 										   TableScanDesc scan);
+
+	/*
+	 * Performs the table scan and insert the satisfied records into the index.
+	 * This API is similar like index_build_range_scan, but this is used for
+	 * the scenario where the index is getting build concurrently.
+	 */
 	void		(*index_validate_scan) (Relation heap_rel,
 										Relation index_rel,
 										IndexInfo *index_info,
@@ -245,6 +390,10 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Estimates the total size of the relation and also returns the number of
+	 * pages, tuples and etc related to the corresponding relation.
+	 */
 	void		(*relation_estimate_size) (Relation rel, int32 *attr_widths,
 										   BlockNumber *pages, double *tuples, double *allvisfrac);
 
@@ -254,12 +403,28 @@ typedef struct TableAmRoutine
 	 * ------------------------------------------------------------------------
 	 */
 
+	/*
+	 * Scans the page for all the tuples and store all of their ItemPointers
+	 * based on the visibility.
+	 */
 	bool		(*scan_bitmap_pagescan) (TableScanDesc scan,
 										 TBMIterateResult *tbmres);
+
+	/* Returns the next tuple of the scan */
 	bool		(*scan_bitmap_pagescan_next) (TableScanDesc scan,
 											  TupleTableSlot *slot);
+
+	/*
+	 * Get the next block for sampling based on the sampling method that is
+	 * available or sequentially to get the next from the scan.
+	 */
 	bool		(*scan_sample_next_block) (TableScanDesc scan,
 										   struct SampleScanState *scanstate);
+
+	/*
+	 * Get the next tuple to sample from the current sampling block based on
+	 * the sampling method, otherwise get the next visible tuple of the block.
+	 */
 	bool		(*scan_sample_next_tuple) (TableScanDesc scan,
 										   struct SampleScanState *scanstate,
 										   TupleTableSlot *slot);
-- 
2.20.1.windows.1

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 8837f83..c87fd47 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -162,6 +162,14 @@ static const struct
 #define ConditionalLockTupleTuplock(rel, tup, mode) \
 	ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
 
+#ifdef USE_PREFETCH
+typedef struct
+{
+	int		next_item;
+	BlockNumber		cur_hblkno;
+} PrefetchState;
+#endif
+
 /*
  * This table maps tuple lock strength values for each particular
  * MultiXactStatus value.
@@ -6990,6 +6998,45 @@ HeapTupleHeaderAdvanceLatestRemovedXid(HeapTupleHeader tuple,
 	/* *latestRemovedXid may still be invalid at end */
 }
 
+#ifdef USE_PREFETCH
+/*
+ * prefetch_buffer
+ *
+ * Pre-fetch 'prefetch_count' numnber of buffers.
+ * Continues to scan the tids array from the last position that was scanned
+ * for previous pre-fetching.
+ */
+static void
+prefetch_buffer(Relation rel, PrefetchState *prefetch_state,
+				ItemPointerData *tids, int nitems, int prefetch_count)
+{
+	int		count = 0;
+	BlockNumber		hblkno = prefetch_state->cur_hblkno;
+	int		i;
+
+	for (i = prefetch_state->next_item; i < nitems && count < prefetch_count; i++)
+	{
+		ItemPointer htid = &tids[i];
+
+		if (hblkno == InvalidBlockNumber ||
+			ItemPointerGetBlockNumber(htid) != hblkno)
+		{
+			hblkno = ItemPointerGetBlockNumber(htid);
+
+			count++;
+			PrefetchBuffer(rel, MAIN_FORKNUM, hblkno);
+		}
+	}
+
+	/*
+	 * Keep track of the item pointer array position, so that next time we can
+	 * continue from this position.
+	 */
+	prefetch_state->next_item = i;
+	prefetch_state->cur_hblkno = hblkno;
+}
+#endif
+
 /*
  * Get the latestRemovedXid from the heap pages pointed at by the index
  * tuples being deleted.
@@ -7011,6 +7058,7 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 	BlockNumber hblkno;
 	Buffer		buf = InvalidBuffer;
 	Page		hpage;
+	PrefetchState prefetch_state;
 
 	/*
 	 * Sort to avoid repeated lookups for the same page, and to make it more
@@ -7023,19 +7071,10 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 
 	/* prefetch all pages */
 #ifdef USE_PREFETCH
-	hblkno = InvalidBlockNumber;
-	for (int i = 0; i < nitems; i++)
-	{
-		ItemPointer htid = &tids[i];
-
-		if (hblkno == InvalidBlockNumber ||
-			ItemPointerGetBlockNumber(htid) != hblkno)
-		{
-			hblkno = ItemPointerGetBlockNumber(htid);
-
-			PrefetchBuffer(rel, MAIN_FORKNUM, hblkno);
-		}
-	}
+	prefetch_state.next_item = 0;
+	prefetch_state.cur_hblkno = InvalidBlockNumber;
+	prefetch_buffer(rel, &prefetch_state, tids, nitems,
+					5 /* prefetch distance ; TODO: use effective_io_concurrency */);
 #endif
 
 	/* Iterate over all tids, and check their horizon */
@@ -7063,6 +7102,13 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 			hblkno = ItemPointerGetBlockNumber(htid);
 
 			buf = ReadBuffer(rel, hblkno);
+
+			/*
+			 * Need to maintain the prefetch distance, so prefetch a page each
+			 * time we read a new page.
+			 */
+			prefetch_buffer(rel, &prefetch_state, tids, nitems, 1);
+
 			hpage = BufferGetPage(buf);
 
 			LockBuffer(buf, BUFFER_LOCK_SHARE);

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 8837f83..d0463c7 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -67,6 +67,7 @@
 #include "utils/lsyscache.h"
 #include "utils/relcache.h"
 #include "utils/snapmgr.h"
+#include "utils/spccache.h"
 
 
 static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup,
@@ -162,6 +163,26 @@ static const struct
 #define ConditionalLockTupleTuplock(rel, tup, mode) \
 	ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
 
+#ifdef USE_PREFETCH
+/*
+ * Maintains the current prefetch state so as to keep it ahead of buffer reads.
+ * Used to prefetch tid buffers.
+ */
+typedef struct
+{
+	int		next_item;
+	BlockNumber cur_hblkno;
+} PrefetchState;
+
+/*
+ * An arbitrary way to come up with a pre-fetch distance that grows with io
+ * concurrency, but is at least 10 and not more than the max effective io
+ * concurrency.
+ */
+#define PREFETCH_DISTANCE(io_concurrency) Min((io_concurrency) + 10, MAX_IO_CONCURRENCY)
+
+#endif
+
 /*
  * This table maps tuple lock strength values for each particular
  * MultiXactStatus value.
@@ -6990,6 +7011,44 @@ HeapTupleHeaderAdvanceLatestRemovedXid(HeapTupleHeader tuple,
 	/* *latestRemovedXid may still be invalid at end */
 }
 
+#ifdef USE_PREFETCH
+/*
+ * prefetch_buffer
+ *
+ * Pre-fetch 'prefetch_count' number of buffers.
+ * Continues to scan the tids array from the last position that was scanned
+ * for previous pre-fetching.
+ */
+static void
+prefetch_buffer(Relation rel, PrefetchState *prefetch_state,
+				ItemPointerData *tids, int nitems, int prefetch_count)
+{
+	BlockNumber cur_hblkno = prefetch_state->cur_hblkno;
+	int		count = 0;
+	int		i;
+
+	for (i = prefetch_state->next_item; i < nitems && count < prefetch_count; i++)
+	{
+		ItemPointer htid = &tids[i];
+
+		if (cur_hblkno == InvalidBlockNumber ||
+			ItemPointerGetBlockNumber(htid) != cur_hblkno)
+		{
+			cur_hblkno = ItemPointerGetBlockNumber(htid);
+			PrefetchBuffer(rel, MAIN_FORKNUM, cur_hblkno);
+			count++;
+		}
+	}
+
+	/*
+	 * Save the prefetch position so that next time we can continue from that
+	 * position.
+	 */
+	prefetch_state->next_item = i;
+	prefetch_state->cur_hblkno = cur_hblkno;
+}
+#endif
+
 /*
  * Get the latestRemovedXid from the heap pages pointed at by the index
  * tuples being deleted.
@@ -7011,6 +7070,10 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 	BlockNumber hblkno;
 	Buffer		buf = InvalidBuffer;
 	Page		hpage;
+#ifdef USE_PREFETCH
+	PrefetchState prefetch_state;
+	int			io_concurrency;
+#endif
 
 	/*
 	 * Sort to avoid repeated lookups for the same page, and to make it more
@@ -7021,21 +7084,13 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 	qsort((void *) tids, nitems, sizeof(ItemPointerData),
 		  (int (*) (const void *, const void *)) ItemPointerCompare);
 
-	/* prefetch all pages */
+	/* prefetch a fixed number of pages beforehand. */
 #ifdef USE_PREFETCH
-	hblkno = InvalidBlockNumber;
-	for (int i = 0; i < nitems; i++)
-	{
-		ItemPointer htid = &tids[i];
-
-		if (hblkno == InvalidBlockNumber ||
-			ItemPointerGetBlockNumber(htid) != hblkno)
-		{
-			hblkno = ItemPointerGetBlockNumber(htid);
-
-			PrefetchBuffer(rel, MAIN_FORKNUM, hblkno);
-		}
-	}
+	prefetch_state.next_item = 0;
+	prefetch_state.cur_hblkno = InvalidBlockNumber;
+	io_concurrency = get_tablespace_io_concurrency(rel->rd_rel->reltablespace);
+	prefetch_buffer(rel, &prefetch_state, tids, nitems,
+					PREFETCH_DISTANCE(io_concurrency));
 #endif
 
 	/* Iterate over all tids, and check their horizon */
@@ -7063,6 +7118,15 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
 			hblkno = ItemPointerGetBlockNumber(htid);
 
 			buf = ReadBuffer(rel, hblkno);
+
+#ifdef USE_PREFETCH
+			/*
+			 * Need to maintain the prefetch distance, so prefetch a page each
+			 * time we read a new page.
+			 */
+			prefetch_buffer(rel, &prefetch_state, tids, nitems, 1);
+#endif
+
 			hpage = BufferGetPage(buf);
 
 			LockBuffer(buf, BUFFER_LOCK_SHARE);

From d573ef256a13cc803b1422b49c13581a4c6cc0d1 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:22:42 +1100
Subject: [PATCH 04/17] Doc update of Create access method type table

Create access method has added the support to create
table access methods also.
---
 doc/src/sgml/catalogs.sgml                 |  4 ++--
 doc/src/sgml/ref/create_access_method.sgml | 12 ++++++++----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/doc/src/sgml/catalogs.sgml b/doc/src/sgml/catalogs.sgml
index af4d0625ea..9fd0668db3 100644
--- a/doc/src/sgml/catalogs.sgml
+++ b/doc/src/sgml/catalogs.sgml
@@ -587,8 +587,8 @@
    The catalog <structname>pg_am</structname> stores information about
    relation access methods.  There is one row for each access method supported
    by the system.
-   Currently, only indexes have access methods.  The requirements for index
-   access methods are discussed in detail in <xref linkend="indexam"/>.
+   Currently, only tables, index and materialized views have access methods.
+   The requirements for access methods are discussed in detail in <xref linkend="am"/>.
   </para>
 
   <table>
diff --git a/doc/src/sgml/ref/create_access_method.sgml b/doc/src/sgml/ref/create_access_method.sgml
index 851c5e63be..256914022a 100644
--- a/doc/src/sgml/ref/create_access_method.sgml
+++ b/doc/src/sgml/ref/create_access_method.sgml
@@ -61,7 +61,8 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
     <listitem>
      <para>
       This clause specifies the type of access method to define.
-      Only <literal>INDEX</literal> is supported at present.
+      Only <literal>INDEX</literal> and <literal>TABLE</literal>
+      are supported at present.
      </para>
     </listitem>
    </varlistentry>
@@ -76,9 +77,12 @@ CREATE ACCESS METHOD <replaceable class="parameter">name</replaceable>
       declared to take a single argument of type <type>internal</type>,
       and its return type depends on the type of access method;
       for <literal>INDEX</literal> access methods, it must
-      be <type>index_am_handler</type>.  The C-level API that the handler
-      function must implement varies depending on the type of access method.
-      The index access method API is described in <xref linkend="indexam"/>.
+      be <type>index_am_handler</type> and for <literal>TABLE</literal>
+      access methods, it must be <type>table_am_handler</type>.
+      The C-level API that the handler function must implement varies
+      depending on the type of access method. The index access method API
+      is described in <xref linkend="index-access-methods"/> and the table access method
+      API is described in <xref linkend="table-access-methods"/>.
      </para>
     </listitem>
    </varlistentry>
-- 
2.20.1.windows.1

From 171f435c364529a15f8028a8e4c7648acaa89d9a Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:24:24 +1100
Subject: [PATCH 05/17] Doc update of create materialized view ... USING syntax

CREATE MATERIALIZED VIEW has added the support of USING
syntax to specify its own table access method.
---
 doc/src/sgml/ref/create_materialized_view.sgml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/doc/src/sgml/ref/create_materialized_view.sgml b/doc/src/sgml/ref/create_materialized_view.sgml
index 7f31ab4d26..3a052ee6a4 100644
--- a/doc/src/sgml/ref/create_materialized_view.sgml
+++ b/doc/src/sgml/ref/create_materialized_view.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
     AS <replaceable>query</replaceable>
@@ -85,6 +86,19 @@ CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new materialize view;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new materialized view. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
-- 
2.20.1.windows.1

From 07919bf42387073d1ef9855a0174e56bbed78afd Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:25:49 +1100
Subject: [PATCH 06/17] Doc update of CREATE TABLE ... USING syntax

CREATE TABLE has added the support of USING syntax
to specify the table access method.
---
 doc/src/sgml/ref/create_table.sgml | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/doc/src/sgml/ref/create_table.sgml b/doc/src/sgml/ref/create_table.sgml
index 857515ec8f..72a1a785e7 100644
--- a/doc/src/sgml/ref/create_table.sgml
+++ b/doc/src/sgml/ref/create_table.sgml
@@ -29,6 +29,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
 ] )
 [ INHERITS ( <replaceable>parent_table</replaceable> [, ... ] ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -40,6 +41,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ]
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -51,6 +53,7 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     [, ... ]
 ) ] { FOR VALUES <replaceable class="parameter">partition_bound_spec</replaceable> | DEFAULT }
 [ PARTITION BY { RANGE | LIST | HASH } ( { <replaceable class="parameter">column_name</replaceable> | ( <replaceable class="parameter">expression</replaceable> ) } [ COLLATE <replaceable class="parameter">collation</replaceable> ] [ <replaceable class="parameter">opclass</replaceable> ] [, ... ] ) ]
+[ USING <replaceable class="parameter">method</replaceable> ]
 [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
 [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -953,7 +956,7 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
 
      <para>
       The access method must support <literal>amgettuple</literal> (see <xref
-      linkend="indexam"/>); at present this means <acronym>GIN</acronym>
+      linkend="index-access-methods"/>); at present this means <acronym>GIN</acronym>
       cannot be used.  Although it's allowed, there is little point in using
       B-tree or hash indexes with an exclusion constraint, because this
       does nothing that an ordinary unique constraint doesn't do better.
@@ -1136,6 +1139,19 @@ WITH ( MODULUS <replaceable class="parameter">numeric_literal</replaceable>, REM
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
-- 
2.20.1.windows.1

From fb2080aa10c6d9f32f2c3567575ce05723fad751 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:27:20 +1100
Subject: [PATCH 07/17] Doc of CREATE TABLE AS ... USING syntax

CREATE TABLE AS has added USING syntax to specify table
access method during the table creation
---
 doc/src/sgml/ref/create_table_as.sgml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/doc/src/sgml/ref/create_table_as.sgml b/doc/src/sgml/ref/create_table_as.sgml
index 679e8f521e..90c9dbdaa5 100644
--- a/doc/src/sgml/ref/create_table_as.sgml
+++ b/doc/src/sgml/ref/create_table_as.sgml
@@ -23,6 +23,7 @@ PostgreSQL documentation
 <synopsis>
 CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] <replaceable>table_name</replaceable>
     [ (<replaceable>column_name</replaceable> [, ...] ) ]
+    [ USING <replaceable class="parameter">method</replaceable> ]
     [ WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] ) | WITHOUT OIDS ]
     [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
     [ TABLESPACE <replaceable class="parameter">tablespace_name</replaceable> ]
@@ -120,6 +121,19 @@ CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXI
     </listitem>
    </varlistentry>
 
+   <varlistentry>
+    <term><literal>USING <replaceable class="parameter">method</replaceable></literal></term>
+    <listitem>
+     <para>
+      This clause specifies optional access method for the new table;
+      see <xref linkend="table-access-methods"/> for more information.
+      If this option is not specified, then the default table access method
+      is chosen for the new table. see <xref linkend="guc-default-table-access-method"/>
+      for more information.
+     </para>
+    </listitem>
+   </varlistentry>
+   
    <varlistentry>
     <term><literal>WITH ( <replaceable class="parameter">storage_parameter</replaceable> [= <replaceable class="parameter">value</replaceable>] [, ... ] )</literal></term>
     <listitem>
-- 
2.20.1.windows.1

From 9cc966c261c1a9164128507ecca21b75d6fef191 Mon Sep 17 00:00:00 2001
From: Kommi <haribabuk@fast.au.fujitsu.com>
Date: Mon, 18 Feb 2019 12:41:34 +1100
Subject: [PATCH] Table access method API explanation

All the table access method API's and their details are explained.
---
 doc/src/sgml/am.sgml          | 551 +++++++++++++++++++++++++++++++++-
 doc/src/sgml/release-9.6.sgml |   2 +-
 2 files changed, 548 insertions(+), 5 deletions(-)

diff --git a/doc/src/sgml/am.sgml b/doc/src/sgml/am.sgml
index 579187ed1b..7cbe00fdbe 100644
--- a/doc/src/sgml/am.sgml
+++ b/doc/src/sgml/am.sgml
@@ -18,12 +18,555 @@
   <para>
    All Tables in <productname>PostgreSQL</productname> are the primary
    data store. Each table is stored as its own physical <firstterm>relation</firstterm>
-   and so is described by an entry in the <structname>pg_class</structname>
-   catalog. The contents of an table are entirely under the control of its
-   access method. (All the access methods furthermore use the standard page
-   layout described in <xref linkend="storage-page-layout"/>.)
+   and is described by an entry in the <structname>pg_class</structname>
+   catalog. A table's content is entirely controlled by its access method, although
+   all access methods use the same standard page layout described in <xref linkend="storage-page-layout"/>.
   </para>
+  
+  <sect2 id="table-access-methods-api">
+   <title>Table access method API</title>
+   
+   <para>
+    Each table access method is described by a row in the
+    <link linkend="catalog-pg-am"><structname>pg_am</structname></link> system
+    catalog. The <structname>pg_am</structname> entry specifies a <firstterm>type</firstterm>
+    of the access method and a <firstterm>handler function</firstterm> for the
+    access method. These entries can be created and deleted using the <xref linkend="sql-create-access-method"/>
+    and <xref linkend="sql-drop-access-method"/> SQL commands.
+   </para>
+  
+   <para>
+    A table access method handler function must be declared to accept a
+    single argument of type <type>internal</type> and to return the
+    pseudo-type <type>table_am_handler</type>.  The argument is a dummy value that
+    simply serves to prevent handler functions from being called directly from
+    SQL commands.  The result of the function must be a palloc'd struct of
+    type <structname>TableAmRoutine</structname>, which contains everything
+    that the core code needs to know to make use of the table access method.
+    The <structname>TableAmRoutine</structname> struct, also called the access
+    method's <firstterm>API struct</firstterm>, includes fields specifying assorted
+    fixed properties of the access method, such as whether it can support
+    bitmap scans.  More importantly, it contains pointers to support
+    functions for the access method, which do all of the real work to access
+    tables.  These support functions are plain C functions and are not
+    visible or callable at the SQL level.  The support functions are described
+    in <structname>TableAmRoutine</structname> structure. For more details, please
+    refer the file <filename>src/include/access/tableam.h</filename>.
+   </para>
+   
+   <para>
+    Any new <literal>TABLE ACCSESS METHOD</literal> developers can refer the exisitng <literal>HEAP</literal>
+    implementation present in the <filename>src/backend/heap/heapam_handler.c</filename> for more details of
+    how it is implemented for HEAP access method.
+   </para>
+   
+   <para>
+    There are differnt type of API's that are defined and those details are below.
+   </para>
+  
+   <sect3 id="slot-implementation-function">
+    <title>Slot implementation functions</title>
+     
+   <para>
+<programlisting>
+const TupleTableSlotOps *(*slot_callbacks) (Relation rel);
+</programlisting>
+  
+    This API expects the function should return the slot implementation that is specific to the AM.
+    Following are the predefined types of slot implementations that are available,
+    <literal>TTSOpsVirtual</literal>, <literal>TTSOpsHeapTuple</literal>,
+    <literal>TTSOpsMinimalTuple</literal> and <literal>TTSOpsBufferHeapTuple</literal>.
+    The AM implementations can use any one of them. For more details of these slot 
+    specific implementations, you can refer <filename>src/include/executor/tuptable.h</filename>.
+   </para>
+   </sect3>
+   
+   <sect3 id="table-scan-functions">
+    <title>Table scan functions</title>
+     
+    <para>
+     The following API's are used for scanning of a table.
+    </para>
+   
+    <para>
+<programlisting>
+TableScanDesc (*scan_begin) (Relation rel,
+                             Snapshot snapshot,
+                             int nkeys, struct ScanKeyData *key,
+                             ParallelTableScanDesc parallel_scan,
+                             bool allow_strat,
+                             bool allow_sync,
+                             bool allow_pagemode,
+                             bool is_bitmapscan,
+                             bool is_samplescan,
+                             bool temp_snap);
+</programlisting>
+  
+     This API to start a scan of a relation pointed by <literal>rel</literal> using specified options
+     and returns the <structname>TableScanDesc</structname>. <literal>parallel_scan</literal> can be used
+     by the AM, in case if it support parallel scan.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*scan_end) (TableScanDesc scan);
+</programlisting>
+  
+     This API expects the function to end the scan that is started by the API
+     <literal>scan_begin</literal>.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*scan_rescan) (TableScanDesc scan, struct ScanKeyData *key, bool set_params,
+                            bool allow_strat, bool allow_sync, bool allow_pagemode);
+</programlisting>
+  
+     This API to restart the given scan that is already started by the
+     API <literal>scan_begin</literal> using the provided options, releasing
+     any resources (such as buffer pins) that are held by the scan.
+    </para>
+   
+    <para>
+<programlisting>
+TupleTableSlot *(*scan_getnextslot) (TableScanDesc scan,
+                                     ScanDirection direction, TupleTableSlot *slot);
+</programlisting>
+  
+     This API expects the function to return the next satisified tuple from the scan
+     started by the API <literal>scan_begin</literal>.
+    </para>
+    
+   </sect3>
+  
+   <sect3 id="parallel-table-scan-function">
+    <title>parallel table scan functions</title>
+   
+    <para>
+     The following API's are used to perform the parallel scan. 
+    </para>  
+   
+    <para>
+<programlisting>
+Size        (*parallelscan_estimate) (Relation rel);
+</programlisting>
+  
+     This API expects the function to return the total size that is required for the AM
+     to perform the parallel table scan. The minimum size that is required is 
+     <structname>ParallelBlockTableScanDescData</structname>.
+    </para>
+    
+    <para>
+<programlisting>
+Size        (*parallelscan_initialize) (Relation rel, ParallelTableScanDesc parallel_scan);
+</programlisting>
+  
+     This API expects the function to perform the initialization of the <literal>parallel_scan</literal>
+     that is required for the parallel scan to be performed by the AM and also return
+     the total size that is required for the AM to perform the parallel table scan.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*parallelscan_reinitialize) (Relation rel, ParallelTableScanDesc parallel_scan);
+</programlisting>
+  
+     This API expects the function to reinitalize the parallel scan structure pointed by the
+     <literal>parallel_scan</literal>.
+    </para>
+    
+   </sect3>
+ 
+   <sect3 id="index-scan-functions">
+    <title>Index scan functions</title>
+     
+    <para>
+<programlisting>
+struct IndexFetchTableData *(*begin_index_fetch) (Relation rel);
+</programlisting>
+  
+     This API to return the allocated and initialized <structname>IndexFetchTableData</structname>
+     strutucture that is used to perform the table scan from the index.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*reset_index_fetch) (struct IndexFetchTableData *data);
+</programlisting>
+  
+     This API to release the AM specific resources that are held by <structname>IndexFetchTableData</structname>
+     of a index scan.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*end_index_fetch) (struct IndexFetchTableData *data);
+</programlisting>
+  
+     This API to release AM-specific resources held by the <structname>IndexFetchTableData</structname>
+     of a given index scan and free the memory of <structname>IndexFetchTableData</structname> itself.
+    </para>
+    
+    <para>
+<programlisting>
+TransactionId (*compute_xid_horizon_for_tuples) (Relation rel,
+                                                 ItemPointerData *items,
+                                                 int nitems);
+</programlisting>
+  
+     This API to get the newest xid among the provided tuples by <literal>items</literal>. This is used
+     to compute what snapshots to conflict with the <literal>items</literal> when replaying WAL records
+     for page-level index vacuums.
+    </para>
+    
+   </sect3>
 
+   <sect3 id="manipulation-of-physical-tuples-functions">
+    <title>Manipulation of physical tuples functions</title>
+     
+    <para>
+<programlisting>
+void        (*tuple_insert) (Relation rel, TupleTableSlot *slot, CommandId cid,
+                             int options, struct BulkInsertStateData *bistate);
+</programlisting>
+  
+     This API expects the function to insert the tuple contained in the provided slot and returns the 
+     the unique identifier of the tuple <literal>ItemPointerData</literal>, use the BulkInsertStateData if available.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*tuple_insert_speculative) (Relation rel,
+                                         TupleTableSlot *slot,
+                                         CommandId cid,
+                                         int options,
+                                         struct BulkInsertStateData *bistate,
+                                         uint32 specToken);
+</programlisting>
+  
+     This API is similar like <literal>tuple_insert</literal> API, but it inserts the tuple
+     with addtional information that is necessray for speculative insertion, the insertion will be confirmed
+     later based on its successful insertion to the index.
+    </para>
+    
+    <para>
+<programlisting>
+void        (*tuple_complete_speculative) (Relation rel,
+                                           TupleTableSlot *slot,
+                                           uint32 specToken,
+                                           bool succeeded);
+</programlisting>
+  
+     This API to complete the speculative insertion of a tuple started by <literal>tuple_insert_speculative</literal>,
+     invoked after finishing the index insert and returns whether the operation is successfule or not?
+    </para>
+   
+    <para>
+<programlisting>
+HTSU_Result (*tuple_delete) (Relation rel,
+                             ItemPointer tid,
+                             CommandId cid,
+                             Snapshot snapshot,
+                             Snapshot crosscheck,
+                             bool wait,
+                             HeapUpdateFailureData *hufd,
+                             bool changingPart);
+</programlisting>
+  
+     This API expects the function to delete a tuple of the relation pointed by the ItemPointer
+     and returns the result of the operation. In case of any failure updates the hufd.
+    </para>
+   
+    <para>
+<programlisting>
+HTSU_Result (*tuple_update) (Relation rel,
+                             ItemPointer otid,
+                             TupleTableSlot *slot,
+                             CommandId cid,
+                             Snapshot snapshot,
+                             Snapshot crosscheck,
+                             bool wait,
+                             HeapUpdateFailureData *hufd,
+                             LockTupleMode *lockmode,
+                             bool *update_indexes);
+</programlisting>
+  
+     This API is expected the function to perform updating a tuple with the new tuple pointed by the ItemPointer
+     and returns the result of the operation and also updates the flag whether the index needs an update or not?
+     In case of any failure it should update the hufd flag.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*multi_insert) (Relation rel, TupleTableSlot **slots, int nslots,
+                             CommandId cid, int options, struct BulkInsertStateData *bistate);
+</programlisting>
+  
+     This API is expected the function to perform insertion of multiple tuples into the relation for faster data insertion.
+     use the BulkInsertStateData if available.
+    </para>
+   
+    <para>
+<programlisting>
+HTSU_Result (*tuple_lock) (Relation rel,
+                           ItemPointer tid,
+                           Snapshot snapshot,
+                           TupleTableSlot *slot,
+                           CommandId cid,
+                           LockTupleMode mode,
+                           LockWaitPolicy wait_policy,
+                           uint8 flags,
+                           HeapUpdateFailureData *hufd);
+</programlisting>
+  
+     This API is expected the function to lock the specified tuple pointed by the ItemPointer <literal>tid</literal>
+     of its newest version and returns the result of the operation. In case of failure updates the hufd.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*finish_bulk_insert) (Relation rel, int options);
+</programlisting>
+  
+     This API expects the function to perform the operations necessary to complete insertions made
+     via <literal>tuple_insert</literal> and <literal>multi_insert</literal> with a
+     BulkInsertState specified. This e.g. may e.g. used to flush the relation when
+     inserting with skipping WAL or may be no operation.
+    </para>
+   
+   </sect3>
+  
+   <sect3 id="non-modifying-tuple-functions">
+    <title>Non modifying tuple functions</title>
+     
+    <para>
+<programlisting>
+bool        (*tuple_fetch_row_version) (Relation rel,
+                                        ItemPointer tid,
+                                        Snapshot snapshot,
+                                        TupleTableSlot *slot,
+                                        Relation stats_relation);
+</programlisting>
+  
+     This API expects the function to fetches the latest tuple specified by the
+     ItemPointer <literal>tid</literal> and store it in the slot. For e.g, in the
+     case if Heap AM, the update chains are created whenever the tuple is updated,
+     so the function should fetch the latest tuple.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*tuple_get_latest_tid) (Relation rel,
+                                     Snapshot snapshot,
+                                     ItemPointer tid);
+</programlisting>
+  
+     This API to get the TID of the latest version of the tuple based on the specified
+     ItemPointer. For e.g, in the case of Heap AM, the update chains are created whenever
+     any tuple is updated. This API is useful to find out latest ItemPointer.
+    </para>
+   
+    <para>
+<programlisting>
+bool        (*tuple_fetch_follow) (struct IndexFetchTableData *scan,
+                                   ItemPointer tid,
+                                   Snapshot snapshot,
+                                   TupleTableSlot *slot,
+                                   bool *call_again, bool *all_dead);
+</programlisting>
+  
+     This API is used to fetch the tuple pointed by the ItemPointer based on the
+     IndexFetchTableData and store it in the specified slot and also updates the flags.
+     This API is called from the index scan operation.
+    </para>
+   
+    <para>
+<programlisting>
+bool        (*tuple_satisfies_snapshot) (Relation rel,
+                                         TupleTableSlot *slot,
+                                         Snapshot snapshot);
+</programlisting>
+  
+     This API performs the tuple visibility based on provided snapshot and returns
+     "true" if the current tuple is visible, otherwise "false".
+    </para>
+    
+   </sect3>
+   
+   <sect3 id="ddl-related-functions">
+    <title>DDL related functions</title>
+     
+    <para>
+<programlisting>
+void        (*relation_set_new_filenode) (Relation rel,
+                                          char persistence,
+                                          TransactionId *freezeXid,
+                                          MultiXactId *minmulti);
+</programlisting>
+  
+     This API expects the function to create the storage that is necessary to store the tuples of the
+     relation and also updates the minimum XID that is possible to insert the tuples. For e.g, the Heap AM,
+     should create the relfilenode that is necessary to store the heap tuples.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*relation_nontransactional_truncate) (Relation rel);
+</programlisting>
+  
+     This API is used to truncate the specified relation, this operation is not non-reversible.
+    </para>
+  
+    <para>
+<programlisting>
+void        (*relation_copy_data) (Relation rel, RelFileNode newrnode);
+</programlisting>
+  
+     This API expects the function to perform the copy of the relation from existing filenode to the new filenode
+     specified by the <literal>newrnode</literal> and removes the existing filenode.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*relation_vacuum) (Relation onerel, int options,
+                                struct VacuumParams *params, BufferAccessStrategy bstrategy);
+</programlisting>
+  
+     This API performs vacuuming of the relation based on the specified params.
+     It Gathers all the dead tuples of the relation and clean them including
+     the indexes.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*scan_analyze_next_block) (TableScanDesc scan, BlockNumber blockno,
+                                        BufferAccessStrategy bstrategy);
+</programlisting>
+  
+     This API expects the function to return a relation block, required to perform tuple analysis.
+     Analysis of this information is used by the planner to optimize the query planning on this
+     relation.
+    </para>
+   
+    <para>
+<programlisting>
+bool        (*scan_analyze_next_tuple) (TableScanDesc scan, TransactionId OldestXmin,
+                                        double *liverows, double *deadrows, TupleTableSlot *slot);
+</programlisting>
+  
+     This API expects the function to get the next visible tuple from the block being scanned based on the snapshot
+     and also updates the number of live and dead tuples encountered.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*relation_copy_for_cluster) (Relation NewHeap, Relation OldHeap, Relation OldIndex,
+                                          bool use_sort,
+                                          TransactionId OldestXmin, TransactionId FreezeXid, MultiXactId MultiXactCutoff,
+                                          double *num_tuples, double *tups_vacuumed, double *tups_recently_dead);
+</programlisting>
+  
+     This API to make a copy of the content of a relation, optionally sorted using either the specified index or by sorting
+     explicitly. It also removes the dead tuples.
+    </para>
+   
+    <para>
+<programlisting>
+double      (*index_build_range_scan) (Relation heap_rel,
+                                       Relation index_rel,
+                                       IndexInfo *index_nfo,
+                                       bool allow_sync,
+                                       bool anyvisible,
+                                       BlockNumber start_blockno,
+                                       BlockNumber end_blockno,
+                                       IndexBuildCallback callback,
+                                       void *callback_state,
+                                       TableScanDesc scan);
+</programlisting>
+  
+     This API to scan the specified blocks of a given relation and insert them into the specified index
+     using the provided the callback function.
+    </para>
+   
+    <para>
+<programlisting>
+void        (*index_validate_scan) (Relation heap_rel,
+                                    Relation index_rel,
+                                    IndexInfo *index_info,
+                                    Snapshot snapshot,
+                                    struct ValidateIndexState *state);
+</programlisting>
+  
+     This API to scan the table according to the given snapshot and insert tuples
+     satisfying the snapshot into the specified index, provided their TIDs are
+     also present in the <structname>ValidateIndexState</structname> struct;
+     this API is used as the last phase of a concurrent index build.
+    </para>
+   
+   </sect3>
+   
+   <sect3 id="planner-functions">
+    <title>planner functions</title>
+     
+    <para>
+<programlisting>
+void        (*relation_estimate_size) (Relation rel, int32 *attr_widths,
+                                       BlockNumber *pages, double *tuples, double *allvisfrac);
+</programlisting>
+  
+     This API estimates the total size of the relation and also returns the number of
+     pages, tuples and etc related to the corresponding relation.
+    </para>
+    
+   </sect3>
+   
+   <sect3 id="executor-functions">
+    <title>executor functions</title>
+     
+    <para>
+<programlisting>
+bool        (*scan_bitmap_pagescan) (TableScanDesc scan,
+                                     TBMIterateResult *tbmres);
+</programlisting>
+  
+     This API to scan the relation block specified in the scan descriptor to collect and return the
+     tuples requested by the <structname>tbmres</structname> based on the visibility.
+    </para>
+  
+    <para>
+<programlisting>
+bool        (*scan_bitmap_pagescan_next) (TableScanDesc scan,
+                                          TupleTableSlot *slot);
+</programlisting>
+  
+     This API to get the next tuple from the set of tuples of a given page specified in the scan descriptor
+     and return the provided slot; returns false in case if there are no more tuples. 
+    </para>
+   
+    <para>
+<programlisting>
+bool        (*scan_sample_next_block) (TableScanDesc scan,
+                                       struct SampleScanState *scanstate);
+</programlisting>
+  
+     This API to select the next block of a relation using the given sampling method or sequentially and
+     set its information in the scan descriptor.
+    </para>
+   
+    <para>
+<programlisting>
+bool        (*scan_sample_next_tuple) (TableScanDesc scan,
+                                       struct SampleScanState *scanstate,
+                                       TupleTableSlot *slot);
+</programlisting>
+  
+     This API get the next tuple to sample from the current sampling block based on
+     the sampling method, otherwise get the next visible tuple of the block that is 
+     choosen from the <literal>scan_sample_next_block</literal>.
+    </para>
+    
+  </sect3>	
+  </sect2>
  </sect1> 
  
  <sect1 id="index-access-methods">
diff --git a/doc/src/sgml/release-9.6.sgml b/doc/src/sgml/release-9.6.sgml
index acebcc6249..c0a96c2cce 100644
--- a/doc/src/sgml/release-9.6.sgml
+++ b/doc/src/sgml/release-9.6.sgml
@@ -10763,7 +10763,7 @@ This commit is also listed under libpq and PL/pgSQL
 2016-08-13 [ed0097e4f] Add SQL-accessible functions for inspecting index AM pro
 -->
        <para>
-        Restructure <link linkend="indexam">index access
+        Restructure <link linkend="index-access-methods">index access
         method <acronym>API</acronym></link> to hide most of it at
         the <application>C</application> level (Alexander Korotkov, Andrew Gierth)
        </para>
-- 
2.20.1.windows.1

From ff53bfe787c187aa1a682239cbf98e270518dc3b Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 15:59:48 +1100
Subject: [PATCH 01/17] Docs of default_table_access_method GUC

This GUC can be set to use the default table access methods
for the tables that are created when table is not specified
it's own access method
---
 doc/src/sgml/config.sgml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index b6f5822b84..0183c439ab 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7168,6 +7168,30 @@ COPY postgres_log FROM '/full/path/to/logfile.csv' WITH csv;
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-default-table-access-method" xreflabel="default_table_access_method">
+      <term><varname>default_table_access_method</varname> (<type>string</type>)
+      <indexterm>
+       <primary><varname>default_table_access_method</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        This parameter specifies the default table access method to use when creating
+        tables or materialized views if the <command>CREATE</command> command does
+        not explicitly specify an access method.
+       </para>
+
+       <para>
+        The value is either the name of a table access method, or an empty string
+        to specify using the default table access method of the current database.
+        If the value does not match the name of any existing table access method,
+        <productname>PostgreSQL</productname> will automatically use the default
+        table access method of the current database.
+       </para>
+
+      </listitem>
+     </varlistentry>
+     
      <varlistentry id="guc-default-tablespace" xreflabel="default_tablespace">
       <term><varname>default_tablespace</varname> (<type>string</type>)
       <indexterm>
-- 
2.20.1.windows.1

From a50d4c45c48985d70d2396ccd8e20beddbeec017 Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:13:56 +1100
Subject: [PATCH 02/17] Rename indexam.sgml to am.sgml

It is just a rename and necessry updates
---
 doc/src/sgml/{indexam.sgml => am.sgml} | 2 +-
 doc/src/sgml/filelist.sgml             | 2 +-
 doc/src/sgml/postgres.sgml             | 2 +-
 doc/src/sgml/xindex.sgml               | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename doc/src/sgml/{indexam.sgml => am.sgml} (99%)

diff --git a/doc/src/sgml/indexam.sgml b/doc/src/sgml/am.sgml
similarity index 99%
rename from doc/src/sgml/indexam.sgml
rename to doc/src/sgml/am.sgml
index 05102724ea..a9f0838ee5 100644
--- a/doc/src/sgml/indexam.sgml
+++ b/doc/src/sgml/am.sgml
@@ -1,4 +1,4 @@
-<!-- doc/src/sgml/indexam.sgml -->
+<!-- doc/src/sgml/am.sgml -->
 
 <chapter id="indexam">
  <title>Index Access Method Interface Definition</title>
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 5dfdf54815..fed460b7c3 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -89,7 +89,7 @@
 <!ENTITY gin        SYSTEM "gin.sgml">
 <!ENTITY brin       SYSTEM "brin.sgml">
 <!ENTITY planstats    SYSTEM "planstats.sgml">
-<!ENTITY indexam    SYSTEM "indexam.sgml">
+<!ENTITY am         SYSTEM "am.sgml">
 <!ENTITY nls        SYSTEM "nls.sgml">
 <!ENTITY plhandler  SYSTEM "plhandler.sgml">
 <!ENTITY fdwhandler SYSTEM "fdwhandler.sgml">
diff --git a/doc/src/sgml/postgres.sgml b/doc/src/sgml/postgres.sgml
index 96d196d229..9dce0c5f81 100644
--- a/doc/src/sgml/postgres.sgml
+++ b/doc/src/sgml/postgres.sgml
@@ -250,7 +250,7 @@
   &tablesample-method;
   &custom-scan;
   &geqo;
-  &indexam;
+  &am;
   &generic-wal;
   &btree;
   &gist;
diff --git a/doc/src/sgml/xindex.sgml b/doc/src/sgml/xindex.sgml
index 9446f8b836..4fa821160c 100644
--- a/doc/src/sgml/xindex.sgml
+++ b/doc/src/sgml/xindex.sgml
@@ -36,7 +36,7 @@
    described in <classname>pg_am</classname>.  It is possible to add a
    new index access method by writing the necessary code and
    then creating an entry in <classname>pg_am</classname> &mdash; but that is
-   beyond the scope of this chapter (see <xref linkend="indexam"/>).
+   beyond the scope of this chapter (see <xref linkend="am"/>).
   </para>
 
   <para>
-- 
2.20.1.windows.1

From 4c685d4990dbf641914175628db1ba74ac3cabfa Mon Sep 17 00:00:00 2001
From: kommih <haribabuk@fast.au.fujitsu.com>
Date: Thu, 7 Feb 2019 16:21:40 +1100
Subject: [PATCH 03/17] Reorganize am as both table and index

There is not much table access methods info.
---
 doc/src/sgml/am.sgml | 61 +++++++++++++++++++++++++++++---------------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/doc/src/sgml/am.sgml b/doc/src/sgml/am.sgml
index a9f0838ee5..579187ed1b 100644
--- a/doc/src/sgml/am.sgml
+++ b/doc/src/sgml/am.sgml
@@ -1,16 +1,34 @@
 <!-- doc/src/sgml/am.sgml -->
 
-<chapter id="indexam">
- <title>Index Access Method Interface Definition</title>
+<chapter id="am">
+ <title>Access Method Interface Definition</title>
 
   <para>
    This chapter defines the interface between the core
-   <productname>PostgreSQL</productname> system and <firstterm>index access
-   methods</firstterm>, which manage individual index types.  The core system
-   knows nothing about indexes beyond what is specified here, so it is
-   possible to develop entirely new index types by writing add-on code.
-  </para>
-
+   <productname>PostgreSQL</productname> system and <firstterm>access
+   methods</firstterm>, which manage individual <literal>INDEX</literal> 
+   and <literal>TABLE</literal> types.  The core system knows nothing
+   about these access methods beyond what is specified here, so it is
+   possible to develop entirely new access method types by writing add-on code.
+  </para>
+ 
+ <sect1 id="table-access-methods">
+  <title>Overview of Table access methods </title>
+  
+  <para>
+   All Tables in <productname>PostgreSQL</productname> are the primary
+   data store. Each table is stored as its own physical <firstterm>relation</firstterm>
+   and so is described by an entry in the <structname>pg_class</structname>
+   catalog. The contents of an table are entirely under the control of its
+   access method. (All the access methods furthermore use the standard page
+   layout described in <xref linkend="storage-page-layout"/>.)
+  </para>
+
+ </sect1> 
+ 
+ <sect1 id="index-access-methods">
+  <title>Overview of Index access methods</title>
+  
   <para>
    All indexes in <productname>PostgreSQL</productname> are what are known
    technically as <firstterm>secondary indexes</firstterm>; that is, the index is
@@ -42,8 +60,8 @@
    dead tuples are reclaimed (by vacuuming) when the dead tuples themselves
    are reclaimed.
   </para>
-
- <sect1 id="index-api">
+  
+ <sect2 id="index-api">
   <title>Basic API Structure for Indexes</title>
 
   <para>
@@ -217,9 +235,9 @@ typedef struct IndexAmRoutine
    conditions.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-functions">
+ <sect2 id="index-functions">
   <title>Index Access Method Functions</title>
 
   <para>
@@ -710,9 +728,11 @@ amparallelrescan (IndexScanDesc scan);
    the beginning.
   </para>
 
- </sect1>
+ </sect2>
+ 
+ 
 
- <sect1 id="index-scanning">
+ <sect2 id="index-scanning">
   <title>Index Scanning</title>
 
   <para>
@@ -865,9 +885,9 @@ amparallelrescan (IndexScanDesc scan);
    if its internal implementation is unsuited to one API or the other.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-locking">
+ <sect2 id="index-locking">
   <title>Index Locking Considerations</title>
 
   <para>
@@ -979,9 +999,9 @@ amparallelrescan (IndexScanDesc scan);
    reduce the frequency of such transaction cancellations.
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-unique-checks">
+ <sect2 id="index-unique-checks">
   <title>Index Uniqueness Checks</title>
 
   <para>
@@ -1128,9 +1148,9 @@ amparallelrescan (IndexScanDesc scan);
     </itemizedlist>
   </para>
 
- </sect1>
+ </sect2>
 
- <sect1 id="index-cost-estimation">
+ <sect2 id="index-cost-estimation">
   <title>Index Cost Estimation Functions</title>
 
   <para>
@@ -1377,5 +1397,6 @@ cost_qual_eval(&amp;index_qual_cost, path-&gt;indexquals, root);
    Examples of cost estimator functions can be found in
    <filename>src/backend/utils/adt/selfuncs.c</filename>.
   </para>
+ </sect2>
  </sect1>
 </chapter>
-- 
2.20.1.windows.1