Merge branch 'master' into anyelement

Author: feodor

doc/src/sgml/postgres-fdw.sgml

@@ -309,8 +309,8 @@
     using <xref linkend="sql-importforeignschema">.  This command creates
     foreign table definitions on the local server that match tables or
     views present on the remote server.  If the remote tables to be imported
-    have columns of user-defined data types, the local server must have types
-    of the same names.
+    have columns of user-defined data types, the local server must have
+    compatible types of the same names.
    </para>
 
    <para>
@@ -361,9 +361,16 @@
 
    <para>
     Note that constraints other than <literal>NOT NULL</> will never be
-    imported from the remote tables, since <productname>PostgreSQL</>
-    does not support any other type of constraint on a foreign table.
-    Checking other types of constraints is always left to the remote server.
+    imported from the remote tables.  Although <productname>PostgreSQL</>
+    does support <literal>CHECK</> constraints on foreign tables, there is no
+    provision for importing them automatically, because of the risk that a
+    constraint expression could evaluate differently on the local and remote
+    servers.  Any such inconsistency in the behavior of a <literal>CHECK</>
+    constraint could lead to hard-to-detect errors in query optimization.
+    So if you wish to import <literal>CHECK</> constraints, you must do so
+    manually, and you should verify the semantics of each one carefully.
+    For more detail about the treatment of <literal>CHECK</> constraints on
+    foreign tables, see <xref linkend="sql-createforeigntable">.
    </para>
   </sect3>
  </sect2>

src/backend/access/brin/brin_pageops.c

@@ -55,7 +55,7 @@ brin_doupdate(Relation idxrel, BlockNumber pagesPerRange,
 	Buffer		newbuf;
 	bool		extended = false;
 
-	newsz = MAXALIGN(newsz);
+	Assert(newsz == MAXALIGN(newsz));
 
 	/* make sure the revmap is long enough to contain the entry we need */
 	brinRevmapExtend(revmap, heapBlk);
@@ -273,7 +273,7 @@ brin_doinsert(Relation idxrel, BlockNumber pagesPerRange,
 	ItemPointerData tid;
 	bool		extended = false;
 
-	itemsz = MAXALIGN(itemsz);
+	Assert(itemsz == MAXALIGN(itemsz));
 
 	/* Make sure the revmap is long enough to contain the entry we need */
 	brinRevmapExtend(revmap, heapBlk);

src/backend/access/brin/brin_tuple.c

@@ -103,9 +103,10 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple,
 
 	Assert(brdesc->bd_totalstored > 0);
 
-	values = palloc(sizeof(Datum) * brdesc->bd_totalstored);
-	nulls = palloc0(sizeof(bool) * brdesc->bd_totalstored);
-	phony_nullbitmap = palloc(sizeof(bits8) * BITMAPLEN(brdesc->bd_totalstored));
+	values = (Datum *) palloc(sizeof(Datum) * brdesc->bd_totalstored);
+	nulls = (bool *) palloc0(sizeof(bool) * brdesc->bd_totalstored);
+	phony_nullbitmap = (bits8 *)
+		palloc(sizeof(bits8) * BITMAPLEN(brdesc->bd_totalstored));
 
 	/*
 	 * Set up the values/nulls arrays for heap_fill_tuple
@@ -144,6 +145,9 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple,
 			values[idxattno++] = tuple->bt_columns[keyno].bv_values[datumno];
 	}
 
+	/* Assert we did not overrun temp arrays */
+	Assert(idxattno <= brdesc->bd_totalstored);
+
 	/* compute total space needed */
 	len = SizeOfBrinTuple;
 	if (anynulls)
@@ -160,12 +164,15 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple,
 
 	data_len = heap_compute_data_size(brtuple_disk_tupdesc(brdesc),
 									  values, nulls);
-
 	len += data_len;
 
+	len = MAXALIGN(len);
+
 	rettuple = palloc0(len);
 	rettuple->bt_blkno = blkno;
 	rettuple->bt_info = hoff;
+
+	/* Assert that hoff fits in the space available */
 	Assert((rettuple->bt_info & BRIN_OFFSET_MASK) == hoff);
 
 	/*

src/backend/access/heap/README.tuplock

@@ -100,11 +100,12 @@ that pg_multixact needs to retain pages of its data until we're certain that
 the MultiXacts in them are no longer of interest.
 
 VACUUM is in charge of removing old MultiXacts at the time of tuple freezing.
-This works in the same way that pg_clog segments are removed: we have a
-pg_class column that stores the earliest multixact that could possibly be
-stored in the table; the minimum of all such values is stored in a pg_database
-column.  VACUUM computes the minimum across all pg_database values, and
-removes pg_multixact segments older than the minimum.
+The lower bound used by vacuum (that is, the value below which all multixacts
+are removed) is stored as pg_class.relminmxid for each table; the minimum of
+all such values is stored in pg_database.datminmxid.  The minimum across
+all databases, in turn, is recorded in checkpoint records, and CHECKPOINT
+removes pg_multixact/ segments older than that value once the checkpoint
+record has been flushed.
 
 Infomask Bits
 -------------
@@ -124,14 +125,15 @@ The following infomask bits are applicable:
   the XMAX is a plain Xid that locked the tuple, as well.
 
 - HEAP_XMAX_KEYSHR_LOCK
+- HEAP_XMAX_SHR_LOCK
 - HEAP_XMAX_EXCL_LOCK
   These bits indicate the strength of the lock acquired; they are useful when
   the XMAX is not a MultiXactId.  If it's a multi, the info is to be found in
   the member flags.  If HEAP_XMAX_IS_MULTI is not set and HEAP_XMAX_LOCK_ONLY
   is set, then one of these *must* be set as well.
-  Note there is no infomask bit for a SELECT FOR SHARE lock.  Also there is no
-  separate bit for a SELECT FOR NO KEY UPDATE lock; this is implemented by the
-  HEAP_KEYS_UPDATED bit.
+
+  Note that HEAP_XMAX_EXCL_LOCK does not distinguish FOR NO KEY UPDATE from
+  FOR UPDATE; this is implemented by the HEAP_KEYS_UPDATED bit.
 
 - HEAP_KEYS_UPDATED
   This bit lives in t_infomask2.  If set, indicates that the XMAX updated

src/backend/executor/nodeIndexscan.c

@@ -532,10 +532,18 @@ ExecReScanIndexScan(IndexScanState *node)
 	}
 	node->iss_RuntimeKeysReady = true;
 
+	/* flush the reorder queue */
+	if (node->iss_ReorderQueue)
+	{
+		while (!pairingheap_is_empty(node->iss_ReorderQueue))
+			reorderqueue_pop(node);
+	}
+
 	/* reset index scan */
 	index_rescan(node->iss_ScanDesc,
 				 node->iss_ScanKeys, node->iss_NumScanKeys,
 				 node->iss_OrderByKeys, node->iss_NumOrderByKeys);
+	node->iss_ReachedEnd = false;
 
 	ExecScanReScan(&node->ss);
 }

src/backend/utils/adt/jsonb_util.c

@@ -509,8 +509,8 @@ fillJsonbValue(JsonbContainer *container, int index,
  * "raw scalar" pseudo array to append it - the actual scalar should be passed
  * next and it will be added as the only member of the array.
  *
- * Values of type jvbBinary, which are rolled up arrays and objects,
- * are unpacked before being added to the result.
+ * All non-scalar types (jvbBinary, jbvArray and jbvObject) passed as
+ * elements or values are unpacked before being added to the result.
  */
 JsonbValue *
 pushJsonbValue(JsonbParseState **pstate, JsonbIteratorToken seq,
@@ -522,14 +522,18 @@ pushJsonbValue(JsonbParseState **pstate, JsonbIteratorToken seq,
 	JsonbIteratorToken tok;
 
 	if (!jbval || (seq != WJB_ELEM && seq != WJB_VALUE) ||
-		jbval->type != jbvBinary)
+		IsAJsonbScalar(jbval))
 	{
 		/* drop through */
 		return pushJsonbValueScalar(pstate, seq, jbval);
 	}
 
-	/* unpack the binary and add each piece to the pstate */
-	it = JsonbIteratorInit(jbval->val.binary.data);
+	/* unpack the data and add each piece to the pstate */
+	if (jbval->type == jbvBinary)
+		it = JsonbIteratorInit(jbval->val.binary.data);
+	else
+		it = JsonbIteratorInit(jbval);
+
 	while ((tok = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
 		res = pushJsonbValueScalar(pstate, tok,
 								   tok < WJB_BEGIN_ARRAY ? &v : NULL);