Merge remote-tracking branch 'pg/master' into fast2pc

Author: kelvich

contrib/bloom/blinsert.c

@@ -49,7 +49,7 @@ flushCachedPage(Relation index, BloomBuildState *buildstate)
 	GenericXLogState *state;
 
 	state = GenericXLogStart(index);
-	page = GenericXLogRegister(state, buffer, true);
+	page = GenericXLogRegisterBuffer(state, buffer, GENERIC_XLOG_FULL_IMAGE);
 	memcpy(page, buildstate->data, BLCKSZ);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buffer);
@@ -221,7 +221,7 @@ blinsert(Relation index, Datum *values, bool *isnull,
 		LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
 		state = GenericXLogStart(index);
-		page = GenericXLogRegister(state, buffer, false);
+		page = GenericXLogRegisterBuffer(state, buffer, 0);
 
 		if (BloomPageAddItem(&blstate, page, itup))
 		{
@@ -268,7 +268,7 @@ blinsert(Relation index, Datum *values, bool *isnull,
 		state = GenericXLogStart(index);
 
 		/* get modifiable copy of metapage */
-		metaPage = GenericXLogRegister(state, metaBuffer, false);
+		metaPage = GenericXLogRegisterBuffer(state, metaBuffer, 0);
 		metaData = BloomPageGetMeta(metaPage);
 
 		if (nStart >= metaData->nEnd)
@@ -279,7 +279,7 @@ blinsert(Relation index, Datum *values, bool *isnull,
 
 		buffer = ReadBuffer(index, blkno);
 		LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
-		page = GenericXLogRegister(state, buffer, false);
+		page = GenericXLogRegisterBuffer(state, buffer, 0);
 
 		if (BloomPageAddItem(&blstate, page, itup))
 		{
@@ -305,7 +305,7 @@ blinsert(Relation index, Datum *values, bool *isnull,
 	 */
 	buffer = BloomNewBuffer(index);
 
-	page = GenericXLogRegister(state, buffer, true);
+	page = GenericXLogRegisterBuffer(state, buffer, GENERIC_XLOG_FULL_IMAGE);
 	BloomInitPage(page, 0);
 
 	if (!BloomPageAddItem(&blstate, page, itup))

contrib/bloom/bloom.h

@@ -31,8 +31,13 @@
 /* Opaque for bloom pages */
 typedef struct BloomPageOpaqueData
 {
-	OffsetNumber maxoff;
-	uint16		flags;
+	OffsetNumber	maxoff;			/* number of index tuples on page */
+	uint16			flags;			/* see bit definitions below */
+	uint16			unused;			/* placeholder to force maxaligning of size
+									 * of BloomPageOpaqueData and to place
+									 * bloom_page_id exactly at the end of page
+									 */
+	uint16			bloom_page_id;	/* for identification of BLOOM indexes */
 }	BloomPageOpaqueData;
 
 typedef BloomPageOpaqueData *BloomPageOpaque;
@@ -41,6 +46,16 @@ typedef BloomPageOpaqueData *BloomPageOpaque;
 #define BLOOM_META		(1<<0)
 #define BLOOM_DELETED	(2<<0)
 
+/*
+ * The page ID is for the convenience of pg_filedump and similar utilities,
+ * which otherwise would have a hard time telling pages of different index
+ * types apart.  It should be the last 2 bytes on the page.  This is more or
+ * less "free" due to alignment considerations.
+ *
+ * See comments above GinPageOpaqueData.
+ */
+#define BLOOM_PAGE_ID		0xFF83
+
 /* Macros for accessing bloom page structures */
 #define BloomPageGetOpaque(page) ((BloomPageOpaque) PageGetSpecialPointer(page))
 #define BloomPageGetMaxOffset(page) (BloomPageGetOpaque(page)->maxoff)

contrib/bloom/blutils.c

@@ -39,7 +39,7 @@ PG_FUNCTION_INFO_V1(blhandler);
 /* Kind of relation optioms for bloom index */
 static relopt_kind bl_relopt_kind;
 
-static int32 myRand();
+static int32 myRand(void);
 static void mySrand(uint32 seed);
 
 /*
@@ -173,15 +173,16 @@ initBloomState(BloomState *state, Relation index)
 static int32 next;
 
 static int32
-myRand()
+myRand(void)
 {
-	/*
+	/*----------
 	 * Compute x = (7^5 * x) mod (2^31 - 1)
 	 * without overflowing 31 bits:
 	 *		(2^31 - 1) = 127773 * (7^5) + 2836
 	 * From "Random number generators: good ones are hard to find",
 	 * Park and Miller, Communications of the ACM, vol. 31, no. 10,
 	 * October 1988, p. 1195.
+	 *----------
 	 */
 	int32 hi, lo, x;
 
@@ -359,6 +360,7 @@ BloomInitPage(Page page, uint16 flags)
 	opaque = BloomPageGetOpaque(page);
 	memset(opaque, 0, sizeof(BloomPageOpaqueData));
 	opaque->flags = flags;
+	opaque->bloom_page_id = BLOOM_PAGE_ID;
 }
 
 /*
@@ -417,7 +419,7 @@ BloomInitMetapage(Relation index)
 
 	/* Initialize contents of meta page */
 	state = GenericXLogStart(index);
-	metaPage = GenericXLogRegister(state, metaBuffer, true);
+	metaPage = GenericXLogRegisterBuffer(state, metaBuffer, GENERIC_XLOG_FULL_IMAGE);
 
 	BloomInitPage(metaPage, BLOOM_META);
 	metadata = BloomPageGetMeta(metaPage);

contrib/bloom/blvacuum.c

@@ -65,7 +65,7 @@ blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 
 		LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 		gxlogState = GenericXLogStart(index);
-		page = GenericXLogRegister(gxlogState, buffer, false);
+		page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
 		if (BloomPageIsDeleted(page))
 		{
@@ -145,7 +145,7 @@ blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 		LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
 		gxlogState = GenericXLogStart(index);
-		page = GenericXLogRegister(gxlogState, buffer, false);
+		page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
 		metaData = BloomPageGetMeta(page);
 		memcpy(metaData->notFullPage, notFullPage, sizeof(BlockNumber) * countPage);

doc/src/sgml/generic-wal.sgml

@@ -31,15 +31,18 @@
 
     <listitem>
      <para>
-      <function>page = GenericXLogRegister(state, buffer, isNew)</> &mdash;
-      register a buffer to be modified within the current generic WAL
+      <function>page = GenericXLogRegisterBuffer(state, buffer, flags)</>
+      &mdash; register a buffer to be modified within the current generic WAL
       record.  This function returns a pointer to a temporary copy of the
       buffer's page, where modifications should be made.  (Do not modify the
-      buffer's contents directly.)  The third argument indicates if the page
-      is new; if true, this will result in a full-page image rather than a
-      delta update being included in the WAL record.
-      <function>GenericXLogRegister</> can be repeated if the WAL-logged
-      action needs to modify multiple pages.
+      buffer's contents directly.)  The third argument is a bitmask of flags
+      applicable to the operation.  Currently the only such flag is
+      <literal>GENERIC_XLOG_FULL_IMAGE</>, which indicates that a full-page
+      image rather than a delta update should be included in the WAL record.
+      Typically this flag would be set if the page is new or has been
+      rewritten completely.
+      <function>GenericXLogRegisterBuffer</> can be repeated if the
+      WAL-logged action needs to modify multiple pages.
      </para>
     </listitem>
 
@@ -71,13 +74,13 @@
    <itemizedlist>
     <listitem>
      <para>
-      No direct modifications of buffers are allowed!  All modifications
-      must be done in copies acquired from <function>GenericXLogRegister()</>.
+      No direct modifications of buffers are allowed!  All modifications must
+      be done in copies acquired from <function>GenericXLogRegisterBuffer()</>.
       In other words, code that makes generic WAL records should never call
       <function>BufferGetPage()</> for itself.  However, it remains the
       caller's responsibility to pin/unpin and lock/unlock the buffers at
       appropriate times.  Exclusive lock must be held on each target buffer
-      from before <function>GenericXLogRegister()</> until after
+      from before <function>GenericXLogRegisterBuffer()</> until after
       <function>GenericXLogFinish()</>.
      </para>
     </listitem>
@@ -145,10 +148,11 @@
 
     <listitem>
      <para>
-      If a registered buffer is not new, the generic WAL record contains
-      a delta between the old and the new page images.  This delta is based
-      on byte-by-byte comparison.  This is not very compact for the case of
-      moving data within a page, and might be improved in the future.
+      If <literal>GENERIC_XLOG_FULL_IMAGE</> is not specified for a
+      registered buffer, the generic WAL record contains a delta between
+      the old and the new page images.  This delta is based on byte-by-byte
+      comparison.  This is not very compact for the case of moving data
+      within a page, and might be improved in the future.
      </para>
     </listitem>
    </itemizedlist>

src/backend/access/rmgrdesc/genericdesc.c

@@ -4,7 +4,7 @@
  *	  rmgr descriptor routines for access/transam/generic_xlog.c
  *
  *
- * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/backend/access/rmgrdesc/genericdesc.c

src/backend/access/transam/generic_xlog.c

@@ -50,7 +50,7 @@
 typedef struct
 {
 	Buffer		buffer;			/* registered buffer */
-	bool		fullImage;		/* are we taking a full image of this page? */
+	int			flags;			/* flags for this buffer */
 	int			deltaLen;		/* space consumed in delta field */
 	char		image[BLCKSZ];	/* copy of page image for modification */
 	char		delta[MAX_DELTA_SIZE];	/* delta between page images */
@@ -280,9 +280,11 @@ GenericXLogStart(Relation relation)
  * is what the caller should modify.
  *
  * If the buffer is already registered, just return its existing entry.
+ * (It's not very clear what to do with the flags in such a case, but
+ * for now we stay with the original flags.)
  */
 Page
-GenericXLogRegister(GenericXLogState *state, Buffer buffer, bool isNew)
+GenericXLogRegisterBuffer(GenericXLogState *state, Buffer buffer, int flags)
 {
 	int			block_id;
 
@@ -295,7 +297,7 @@ GenericXLogRegister(GenericXLogState *state, Buffer buffer, bool isNew)
 		{
 			/* Empty slot, so use it (there cannot be a match later) */
 			page->buffer = buffer;
-			page->fullImage = isNew;
+			page->flags = flags;
 			memcpy(page->image,
 				   BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
 				   BLCKSZ);
@@ -338,17 +340,31 @@ GenericXLogFinish(GenericXLogState *state)
 		{
 			PageData   *pageData = &state->pages[i];
 			Page		page;
+			PageHeader	pageHeader;
 
 			if (BufferIsInvalid(pageData->buffer))
 				continue;
 
 			page = BufferGetPage(pageData->buffer, NULL, NULL,
 								 BGP_NO_SNAPSHOT_TEST);
+			pageHeader = (PageHeader) pageData->image;
 
-			if (pageData->fullImage)
+			if (pageData->flags & GENERIC_XLOG_FULL_IMAGE)
 			{
-				/* A full page image does not require anything special */
-				memcpy(page, pageData->image, BLCKSZ);
+				/*
+				 * A full-page image does not require us to supply any xlog
+				 * data.  Just apply the image, being careful to zero the
+				 * "hole" between pd_lower and pd_upper in order to avoid
+				 * divergence between actual page state and what replay would
+				 * produce.
+				 */
+				memcpy(page, pageData->image, pageHeader->pd_lower);
+				memset(page + pageHeader->pd_lower, 0,
+					   pageHeader->pd_upper - pageHeader->pd_lower);
+				memcpy(page + pageHeader->pd_upper,
+					   pageData->image + pageHeader->pd_upper,
+					   BLCKSZ - pageHeader->pd_upper);
+
 				XLogRegisterBuffer(i, pageData->buffer,
 								   REGBUF_FORCE_IMAGE | REGBUF_STANDARD);
 			}
@@ -359,7 +375,15 @@ GenericXLogFinish(GenericXLogState *state)
 				 * associated with this page.
 				 */
 				computeDelta(pageData, page, (Page) pageData->image);
-				memcpy(page, pageData->image, BLCKSZ);
+
+				/* Apply the image, with zeroed "hole" as above */
+				memcpy(page, pageData->image, pageHeader->pd_lower);
+				memset(page + pageHeader->pd_lower, 0,
+					   pageHeader->pd_upper - pageHeader->pd_lower);
+				memcpy(page + pageHeader->pd_upper,
+					   pageData->image + pageHeader->pd_upper,
+					   BLCKSZ - pageHeader->pd_upper);
+
 				XLogRegisterBuffer(i, pageData->buffer, REGBUF_STANDARD);
 				XLogRegisterBufData(i, pageData->delta, pageData->deltaLen);
 			}
@@ -395,6 +419,7 @@ GenericXLogFinish(GenericXLogState *state)
 								 BGP_NO_SNAPSHOT_TEST),
 				   pageData->image,
 				   BLCKSZ);
+			/* We don't worry about zeroing the "hole" in this case */
 			MarkBufferDirty(pageData->buffer);
 		}
 		END_CRIT_SECTION();
@@ -473,6 +498,7 @@ generic_redo(XLogReaderState *record)
 		if (action == BLK_NEEDS_REDO)
 		{
 			Page		page;
+			PageHeader	pageHeader;
 			char	   *blockDelta;
 			Size		blockDeltaSize;
 
@@ -481,6 +507,16 @@ generic_redo(XLogReaderState *record)
 			blockDelta = XLogRecGetBlockData(record, block_id, &blockDeltaSize);
 			applyPageRedo(page, blockDelta, blockDeltaSize);
 
+			/*
+			 * Since the delta contains no information about what's in the
+			 * "hole" between pd_lower and pd_upper, set that to zero to
+			 * ensure we produce the same page state that application of the
+			 * logged action by GenericXLogFinish did.
+			 */
+			pageHeader = (PageHeader) page;
+			memset(page + pageHeader->pd_lower, 0,
+				   pageHeader->pd_upper - pageHeader->pd_lower);
+
 			PageSetLSN(page, lsn);
 			MarkBufferDirty(buffers[block_id]);
 		}

src/backend/executor/spi.c

@@ -2217,15 +2217,23 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
 				 */
 				if (IsA(stmt, CreateTableAsStmt))
 				{
-					Assert(strncmp(completionTag, "SELECT ", 7) == 0);
-					_SPI_current->processed = pg_strtouint64(completionTag + 7,
-															 NULL, 10);
+					CreateTableAsStmt *ctastmt = (CreateTableAsStmt *) stmt;
+
+					if (strncmp(completionTag, "SELECT ", 7) == 0)
+						_SPI_current->processed =
+							pg_strtouint64(completionTag + 7, NULL, 10);
+					else
+					{
+						/* Must be an IF NOT EXISTS that did nothing */
+						Assert(ctastmt->if_not_exists);
+						_SPI_current->processed = 0;
+					}
 
 					/*
 					 * For historical reasons, if CREATE TABLE AS was spelled
 					 * as SELECT INTO, return a special return code.
 					 */
-					if (((CreateTableAsStmt *) stmt)->is_select_into)
+					if (ctastmt->is_select_into)
 						res = SPI_OK_SELINTO;
 				}
 				else if (IsA(stmt, CopyStmt))

src/backend/foreign/foreign.c

@@ -253,7 +253,7 @@ GetUserMapping(Oid userid, Oid serverid)
  *
  * If missing_ok is true, the function returns InvalidOid when it does not find
  * required user mapping. Otherwise, find_user_mapping() throws error if it
- * does not find required user mapping. 
+ * does not find required user mapping.
  */
 Oid
 GetUserMappingId(Oid userid, Oid serverid, bool missing_ok)

src/backend/nodes/extensible.c

@@ -33,7 +33,7 @@ typedef struct
 } ExtensibleNodeEntry;
 
 /*
- * An internal function to register a new callback structure 
+ * An internal function to register a new callback structure
  */
 static void
 RegisterExtensibleNodeEntry(HTAB **p_htable, const char *htable_label,