Wanted: jsonb on-disk representation documentation

diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c
index cf5d6f2..8413da7 100644
--- a/src/backend/utils/adt/jsonb.c
+++ b/src/backend/utils/adt/jsonb.c
@@ -65,7 +65,7 @@ jsonb_recv(PG_FUNCTION_ARGS)
 	if (version == 1)
 		str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
 	else
-		elog(ERROR, "Unsupported jsonb version number %d", version);
+		elog(ERROR, "unsupported jsonb version number %d", version);
 
 	return jsonb_from_cstring(str, nbytes);
 }
@@ -249,7 +249,6 @@ jsonb_in_object_field_start(void *pstate, char *fname, bool isnull)
 	v.type = jbvString;
 	v.val.string.len = checkStringLen(strlen(fname));
 	v.val.string.val = pnstrdup(fname, v.val.string.len);
-	v.estSize = sizeof(JEntry) + v.val.string.len;
 
 	_state->res = pushJsonbValue(&_state->parseState, WJB_KEY, &v);
 }
@@ -290,8 +289,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 	JsonbInState *_state = (JsonbInState *) pstate;
 	JsonbValue	v;
 
-	v.estSize = sizeof(JEntry);
-
 	switch (tokentype)
 	{
 
@@ -300,7 +297,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 			v.type = jbvString;
 			v.val.string.len = checkStringLen(strlen(token));
 			v.val.string.val = pnstrdup(token, v.val.string.len);
-			v.estSize += v.val.string.len;
 			break;
 		case JSON_TOKEN_NUMBER:
 
@@ -312,7 +308,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 			v.type = jbvNumeric;
 			v.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(token), 0, -1));
 
-			v.estSize += VARSIZE_ANY(v.val.numeric) +sizeof(JEntry) /* alignment */ ;
 			break;
 		case JSON_TOKEN_TRUE:
 			v.type = jbvBool;
diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 1caaa4a..49a1d4d 100644
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -37,49 +37,16 @@
 #define JSONB_MAX_PAIRS (Min(MaxAllocSize / sizeof(JsonbPair), \
 							 JENTRY_POSMASK))
 
-/*
- * State used while converting an arbitrary JsonbValue into a Jsonb value
- * (4-byte varlena uncompressed representation of a Jsonb)
- *
- * ConvertLevel:  Bookkeeping around particular level when converting.
- */
-typedef struct convertLevel
-{
-	uint32		i;				/* Iterates once per element, or once per pair */
-	uint32	   *header;			/* Pointer to current container header */
-	JEntry	   *meta;			/* This level's metadata */
-	char	   *begin;			/* Pointer into convertState.buffer */
-} convertLevel;
-
-/*
- * convertState:  Overall bookkeeping state for conversion
- */
-typedef struct convertState
-{
-	/* Preallocated buffer in which to form varlena/Jsonb value */
-	Jsonb	   *buffer;
-	/* Pointer into buffer */
-	char	   *ptr;
-
-	/* State for  */
-	convertLevel *allState,		/* Overall state array */
-			   *contPtr;		/* Cur container pointer (in allState) */
-
-	/* Current size of buffer containing allState array */
-	Size		levelSz;
-
-} convertState;
-
 static int	compareJsonbScalarValue(JsonbValue *a, JsonbValue *b);
 static int	lexicalCompareJsonbStringValue(const void *a, const void *b);
-static Size convertJsonb(JsonbValue *val, Jsonb *buffer);
-static inline short addPaddingInt(convertState *cstate);
-static void walkJsonbValueConversion(JsonbValue *val, convertState *cstate,
-						 uint32 nestlevel);
-static void putJsonbValueConversion(convertState *cstate, JsonbValue *val,
-						uint32 flags, uint32 level);
-static void putScalarConversion(convertState *cstate, JsonbValue *scalarVal,
-					uint32 level, uint32 i);
+static Jsonb *convertJsonb(JsonbValue *val);
+static inline short addPaddingInt(StringInfo buffer);
+static void walkJsonbValueConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void walkJsonbArrayConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void walkJsonbObjectConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void putScalarConversion(StringInfo buffer, JsonbValue *scalarVal,
+								JEntry *header);
+static int reserveStringInfo(StringInfo str, int datalen);
 static void iteratorFromContainerBuf(JsonbIterator *it, char *buffer);
 static bool formIterIsContainer(JsonbIterator **it, JsonbValue *val,
 					JEntry *ent, bool skipNested);
@@ -110,7 +77,6 @@ Jsonb *
 JsonbValueToJsonb(JsonbValue *val)
 {
 	Jsonb	   *out;
-	Size		sz;
 
 	if (IsAJsonbScalar(val))
 	{
@@ -127,17 +93,11 @@ JsonbValueToJsonb(JsonbValue *val)
 		pushJsonbValue(&pstate, WJB_ELEM, val);
 		res = pushJsonbValue(&pstate, WJB_END_ARRAY, NULL);
 
-		out = palloc(VARHDRSZ + res->estSize);
-		sz = convertJsonb(res, out);
-		Assert(sz <= res->estSize);
-		SET_VARSIZE(out, sz + VARHDRSZ);
+		out = convertJsonb(res);
 	}
 	else if (val->type == jbvObject || val->type == jbvArray)
 	{
-		out = palloc(VARHDRSZ + val->estSize);
-		sz = convertJsonb(val, out);
-		Assert(sz <= val->estSize);
-		SET_VARSIZE(out, VARHDRSZ + sz);
+		out = convertJsonb(val);
 	}
 	else
 	{
@@ -337,28 +297,22 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 			if (JBE_ISNULL(*e) && key->type == jbvNull)
 			{
 				result->type = jbvNull;
-				result->estSize = sizeof(JEntry);
 			}
 			else if (JBE_ISSTRING(*e) && key->type == jbvString)
 			{
 				result->type = jbvString;
 				result->val.string.val = data + JBE_OFF(*e);
 				result->val.string.len = JBE_LEN(*e);
-				result->estSize = sizeof(JEntry) + result->val.string.len;
 			}
 			else if (JBE_ISNUMERIC(*e) && key->type == jbvNumeric)
 			{
 				result->type = jbvNumeric;
 				result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
-
-				result->estSize = 2 * sizeof(JEntry) +
-					VARSIZE_ANY(result->val.numeric);
 			}
 			else if (JBE_ISBOOL(*e) && key->type == jbvBool)
 			{
 				result->type = jbvBool;
 				result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
-				result->estSize = sizeof(JEntry);
 			}
 			else
 				continue;
@@ -395,7 +349,6 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 			candidate.type = jbvString;
 			candidate.val.string.val = data + JBE_OFF(*entry);
 			candidate.val.string.len = JBE_LEN(*entry);
-			candidate.estSize = sizeof(JEntry) + candidate.val.string.len;
 
 			difference = lengthCompareJsonbStringValue(&candidate, key, NULL);
 
@@ -410,28 +363,22 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 				if (JBE_ISNULL(*v))
 				{
 					result->type = jbvNull;
-					result->estSize = sizeof(JEntry);
 				}
 				else if (JBE_ISSTRING(*v))
 				{
 					result->type = jbvString;
 					result->val.string.val = data + JBE_OFF(*v);
 					result->val.string.len = JBE_LEN(*v);
-					result->estSize = sizeof(JEntry) + result->val.string.len;
 				}
 				else if (JBE_ISNUMERIC(*v))
 				{
 					result->type = jbvNumeric;
 					result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*v)));
-
-					result->estSize = 2 * sizeof(JEntry) +
-						VARSIZE_ANY(result->val.numeric);
 				}
 				else if (JBE_ISBOOL(*v))
 				{
 					result->type = jbvBool;
 					result->val.boolean = JBE_ISBOOL_TRUE(*v) != 0;
-					result->estSize = sizeof(JEntry);
 				}
 				else
 				{
@@ -443,7 +390,6 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 					result->val.binary.data = data + INTALIGN(JBE_OFF(*v));
 					result->val.binary.len = JBE_LEN(*v) -
 						(INTALIGN(JBE_OFF(*v)) - JBE_OFF(*v));
-					result->estSize = 2 * sizeof(JEntry) + result->val.binary.len;
 				}
 
 				return result;
@@ -500,34 +446,28 @@ getIthJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 i)
 	if (JBE_ISNULL(*e))
 	{
 		result->type = jbvNull;
-		result->estSize = sizeof(JEntry);
 	}
 	else if (JBE_ISSTRING(*e))
 	{
 		result->type = jbvString;
 		result->val.string.val = data + JBE_OFF(*e);
 		result->val.string.len = JBE_LEN(*e);
-		result->estSize = sizeof(JEntry) + result->val.string.len;
 	}
 	else if (JBE_ISNUMERIC(*e))
 	{
 		result->type = jbvNumeric;
 		result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
-
-		result->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(result->val.numeric);
 	}
 	else if (JBE_ISBOOL(*e))
 	{
 		result->type = jbvBool;
 		result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
-		result->estSize = sizeof(JEntry);
 	}
 	else
 	{
 		result->type = jbvBinary;
 		result->val.binary.data = data + INTALIGN(JBE_OFF(*e));
 		result->val.binary.len = JBE_LEN(*e) - (INTALIGN(JBE_OFF(*e)) - JBE_OFF(*e));
-		result->estSize = result->val.binary.len + 2 * sizeof(JEntry);
 	}
 
 	return result;
@@ -558,7 +498,6 @@ pushJsonbValue(JsonbParseState **pstate, int seq, JsonbValue *scalarVal)
 			*pstate = pushState(pstate);
 			result = &(*pstate)->contVal;
 			(*pstate)->contVal.type = jbvArray;
-			(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
 			(*pstate)->contVal.val.array.nElems = 0;
 			(*pstate)->contVal.val.array.rawScalar = (scalarVal &&
 											 scalarVal->val.array.rawScalar);
@@ -580,7 +519,6 @@ pushJsonbValue(JsonbParseState **pstate, int seq, JsonbValue *scalarVal)
 			*pstate = pushState(pstate);
 			result = &(*pstate)->contVal;
 			(*pstate)->contVal.type = jbvObject;
-			(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
 			(*pstate)->contVal.val.object.nPairs = 0;
 			(*pstate)->size = 4;
 			(*pstate)->contVal.val.object.pairs = palloc(sizeof(JsonbPair) *
@@ -1209,244 +1147,209 @@ lexicalCompareJsonbStringValue(const void *a, const void *b)
 					  vb->val.string.len, DEFAULT_COLLATION_OID);
 }
 
+
 /*
- * Given a JsonbValue, convert to Jsonb and store in preallocated Jsonb buffer
- * sufficiently large to fit the value
+ * Reserve 'datalen' bytes at the end of StringInfo, enlarging the underlying
+ * buffer if necessary. Returns the offset to the reserved area.
  */
-static Size
-convertJsonb(JsonbValue *val, Jsonb *buffer)
+static int
+reserveStringInfo(StringInfo str, int datalen)
 {
-	convertState state;
-	Size		len;
+	int		offset;
 
-	/* Should not already have binary representation */
-	Assert(val->type != jbvBinary);
+	/* Make more room if needed */
+	enlargeStringInfo(str, datalen);
 
-	state.buffer = buffer;
-	/* Start from superheader */
-	state.ptr = VARDATA(state.buffer);
-	state.levelSz = 8;
-	state.allState = palloc(sizeof(convertLevel) * state.levelSz);
+	/* remember current offset */
+	offset = str->len;
 
-	walkJsonbValueConversion(val, &state, 0);
+	/* reserve the space */
+	str->len += datalen;
 
-	len = state.ptr - VARDATA(state.buffer);
+	/* XXX: we don't bother with the trailing null that normal StringInfo
+	 * functions append */
 
-	Assert(len <= val->estSize);
-	return len;
+	return offset;
 }
 
 /*
- * Walk the tree representation of Jsonb, as part of the process of converting
- * a JsonbValue to a Jsonb.
- *
- * This high-level function takes care of recursion into sub-containers, but at
- * the top level calls putJsonbValueConversion once per sequential processing
- * token (in a manner similar to generic iteration).
+ * Given a JsonbValue, convert to Jsonb. The result is palloc'd.
  */
-static void
-walkJsonbValueConversion(JsonbValue *val, convertState *cstate,
-						 uint32 nestlevel)
+static Jsonb *
+convertJsonb(JsonbValue *val)
 {
-	int			i;
+	StringInfoData buffer;
+	JEntry		header;
+	Jsonb	   *res;
 
-	check_stack_depth();
+	initStringInfo(&buffer);
 
-	if (!val)
-		return;
+	/* Should not already have binary representation */
+	Assert(val->type != jbvBinary);
 
-	switch (val->type)
-	{
-		case jbvArray:
+	/* Reserve the Jsonb header */
+	reserveStringInfo(&buffer, sizeof(VARHDRSZ));
 
-			putJsonbValueConversion(cstate, val, WJB_BEGIN_ARRAY, nestlevel);
-			for (i = 0; i < val->val.array.nElems; i++)
-			{
-				if (IsAJsonbScalar(&val->val.array.elems[i]) ||
-					val->val.array.elems[i].type == jbvBinary)
-					putJsonbValueConversion(cstate, val->val.array.elems + i,
-											WJB_ELEM, nestlevel);
-				else
-					walkJsonbValueConversion(val->val.array.elems + i, cstate,
-											 nestlevel + 1);
-			}
-			putJsonbValueConversion(cstate, val, WJB_END_ARRAY, nestlevel);
+	walkJsonbValueConversion(val, &buffer, &header, 0);
 
-			break;
-		case jbvObject:
+	res = (Jsonb *) buffer.data;
 
-			putJsonbValueConversion(cstate, val, WJB_BEGIN_OBJECT, nestlevel);
-			for (i = 0; i < val->val.object.nPairs; i++)
-			{
-				putJsonbValueConversion(cstate, &val->val.object.pairs[i].key,
-										WJB_KEY, nestlevel);
-
-				if (IsAJsonbScalar(&val->val.object.pairs[i].value) ||
-					val->val.object.pairs[i].value.type == jbvBinary)
-					putJsonbValueConversion(cstate,
-											&val->val.object.pairs[i].value,
-											WJB_VALUE, nestlevel);
-				else
-					walkJsonbValueConversion(&val->val.object.pairs[i].value,
-											 cstate, nestlevel + 1);
-			}
-			putJsonbValueConversion(cstate, val, WJB_END_OBJECT, nestlevel);
+	SET_VARSIZE(res, buffer.len);
 
-			break;
-		default:
-			elog(ERROR, "unknown type of jsonb container");
-	}
+	return res;
 }
 
 /*
- * walkJsonbValueConversion() worker.  Add padding sufficient to int-align our
- * access to conversion buffer.
+ * Convert a single JsonbValue to a Jsonb node. 
+ *
+ * The value is written out to 'buffer'. The JEntry header for this node is
+ * returned in *header. It is filled in with the length of this value, but if
+ * it is stored in an array or an object (which is always, except for the root
+ * node), it is the caller's responsibility to adjust it with the offset
+ * within the container.
+ *
+ * If the value is an array or an object, this recurses. 'level' is only used
+ * for debugging purposes.
  */
-static inline
-short
-addPaddingInt(convertState *cstate)
+static void
+walkJsonbValueConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level)
 {
-	short		padlen,
-				p;
-
-	padlen = INTALIGN(cstate->ptr - VARDATA(cstate->buffer)) -
-		(cstate->ptr - VARDATA(cstate->buffer));
+	check_stack_depth();
 
-	for (p = padlen; p > 0; p--)
-	{
-		*cstate->ptr = '\0';
-		cstate->ptr++;
-	}
+	if (!val)
+		return;
 
-	return padlen;
+	if (IsAJsonbScalar(val) || val->type == jbvBinary)
+		putScalarConversion(buffer, val, header);
+	else if (val->type == jbvArray)
+		walkJsonbArrayConversion(val, buffer, header, level);
+	else if (val->type == jbvObject)
+		walkJsonbObjectConversion(val, buffer, header, level);
+	else
+		elog(ERROR, "unknown type of jsonb container");
 }
 
-/*
- * walkJsonbValueConversion() worker.
- *
- * As part of the process of converting an arbitrary JsonbValue to a Jsonb,
- * copy over an arbitrary individual JsonbValue.  This function may copy any
- * type of value, even containers (Objects/arrays).  However, it is not
- * responsible for recursive aspects of walking the tree (so only top-level
- * Object/array details are handled).
- *
- * No details about their keys/values/elements are handled recursively -
- * rather, the function is called as required for the start of an Object/Array,
- * and the end (i.e.  there is one call per sequential processing WJB_* token).
- */
 static void
-putJsonbValueConversion(convertState *cstate, JsonbValue *val, uint32 flags,
-						uint32 level)
+walkJsonbArrayConversion(JsonbValue *val, StringInfo buffer, JEntry *pheader, int level)
 {
-	if (level == cstate->levelSz)
+	int			offset;
+	int			metaoffset;
+	int			i;
+	int			totallen;
+	JEntry		header;
+
+	/* Initialize pointer into conversion buffer at this level */
+	offset = buffer->len;
+
+	addPaddingInt(buffer);
+
+	/*
+	 * Construct the header Jentry, stored in the beginning of the variable-
+	 * length payload.
+	 */
+	header.header = val->val.array.nElems | JB_FARRAY;
+	if (val->val.array.rawScalar)
 	{
-		cstate->levelSz *= 2;
-		cstate->allState = repalloc(cstate->allState,
-									sizeof(convertLevel) * cstate->levelSz);
+		Assert(val->val.array.nElems == 1);
+		Assert(level == 0);
+		header.header |= JB_FSCALAR;
 	}
 
-	cstate->contPtr = cstate->allState + level;
+	appendBinaryStringInfo(buffer, (char *) &header, sizeof(uint32));
+	/* reserve space for the JEntries of the elements. */
+	metaoffset = reserveStringInfo(buffer, sizeof(JEntry) * val->val.array.nElems);
 
-	if (flags & (WJB_BEGIN_ARRAY | WJB_BEGIN_OBJECT))
+	totallen = 0;
+	for (i = 0; i < val->val.array.nElems; i++)
 	{
-		Assert(((flags & WJB_BEGIN_ARRAY) && val->type == jbvArray) ||
-			   ((flags & WJB_BEGIN_OBJECT) && val->type == jbvObject));
+		JsonbValue *elem = &val->val.array.elems[i];
+		int len;
+		JEntry meta;
+
+		walkJsonbValueConversion(elem, buffer, &meta, level + 1);
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
+		if (i == 0)
+			meta.header |= JENTRY_ISFIRST;
+		else
+			meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * i], &meta, sizeof(JEntry));
+	}
 
-		/* Initialize pointer into conversion buffer at this level */
-		cstate->contPtr->begin = cstate->ptr;
+	totallen = buffer->len - offset;
 
-		addPaddingInt(cstate);
+	/* Initialize the header of this node, in the container's JEntry array */
+	pheader->header = JENTRY_ISNEST | totallen;
+}
 
-		/* Initialize everything else at this level */
-		cstate->contPtr->header = (uint32 *) cstate->ptr;
-		/* Advance past header */
-		cstate->ptr += sizeof(uint32);
-		cstate->contPtr->meta = (JEntry *) cstate->ptr;
-		cstate->contPtr->i = 0;
+static void
+walkJsonbObjectConversion(JsonbValue *val, StringInfo buffer, JEntry *pheader, int level)
+{
+	JEntry		header;
+	int			offset;
+	int			metaoffset;
+	int			i;
+	int			totallen;
 
-		if (val->type == jbvArray)
-		{
-			*cstate->contPtr->header = val->val.array.nElems | JB_FARRAY;
-			cstate->ptr += sizeof(JEntry) * val->val.array.nElems;
+	/* Initialize pointer into conversion buffer at this level */
+	offset = buffer->len;
 
-			if (val->val.array.rawScalar)
-			{
-				Assert(val->val.array.nElems == 1);
-				Assert(level == 0);
-				*cstate->contPtr->header |= JB_FSCALAR;
-			}
-		}
-		else
-		{
-			*cstate->contPtr->header = val->val.object.nPairs | JB_FOBJECT;
-			cstate->ptr += sizeof(JEntry) * val->val.object.nPairs * 2;
-		}
-	}
-	else if (flags & WJB_ELEM)
-	{
-		putScalarConversion(cstate, val, level, cstate->contPtr->i);
-		cstate->contPtr->i++;
-	}
-	else if (flags & WJB_KEY)
-	{
-		Assert(val->type == jbvString);
+	addPaddingInt(buffer);
 
-		putScalarConversion(cstate, val, level, cstate->contPtr->i * 2);
-	}
-	else if (flags & WJB_VALUE)
-	{
-		putScalarConversion(cstate, val, level, cstate->contPtr->i * 2 + 1);
-		cstate->contPtr->i++;
-	}
-	else if (flags & (WJB_END_ARRAY | WJB_END_OBJECT))
-	{
-		convertLevel *prevPtr;	/* Prev container pointer */
-		uint32		len,
-					i;
+	/* Initialize header */
+	header.header = val->val.object.nPairs | JB_FOBJECT;
+	appendBinaryStringInfo(buffer, (char *) &header, sizeof(uint32));
 
-		Assert(((flags & WJB_END_ARRAY) && val->type == jbvArray) ||
-			   ((flags & WJB_END_OBJECT) && val->type == jbvObject));
+	/* reserve space for the JEntries of the keys and values */
+	metaoffset = reserveStringInfo(buffer, sizeof(JEntry) * val->val.object.nPairs * 2);
 
-		if (level == 0)
-			return;
+	totallen = 0;
+	for (i = 0; i < val->val.object.nPairs; i++)
+	{
+		JsonbPair *pair = &val->val.object.pairs[i];
+		int len;
+		JEntry meta;
 
-		len = cstate->ptr - (char *) cstate->contPtr->begin;
+		/* put key */
+		putScalarConversion(buffer, &pair->key, &meta);
 
-		prevPtr = cstate->contPtr - 1;
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
+		if (i == 0)
+			meta.header |= JENTRY_ISFIRST;
+		else
+			meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * (i * 2)], &meta, sizeof(JEntry));
+
+		walkJsonbValueConversion(&pair->value, buffer, &meta, level);
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
+		meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * (i * 2 + 1)], &meta, sizeof(JEntry));
+	}
 
-		if (*prevPtr->header & JB_FARRAY)
-		{
-			i = prevPtr->i;
+	totallen = buffer->len - offset;
 
-			prevPtr->meta[i].header = JENTRY_ISNEST;
+	pheader->header = JENTRY_ISNEST | totallen;
+}
 
-			if (i == 0)
-				prevPtr->meta[0].header |= JENTRY_ISFIRST | len;
-			else
-				prevPtr->meta[i].header |=
-					(prevPtr->meta[i - 1].header & JENTRY_POSMASK) + len;
-		}
-		else if (*prevPtr->header & JB_FOBJECT)
-		{
-			i = 2 * prevPtr->i + 1;		/* Value, not key */
+/*
+ * Append padding, so that the length of the StringInfo is int-aligned.
+ * Returns the number of padding bytes appended.
+ */
+static inline
+short
+addPaddingInt(StringInfo buffer)
+{
+	short		padlen,
+				p;
 
-			prevPtr->meta[i].header = JENTRY_ISNEST;
+	padlen = INTALIGN(buffer->len) - buffer->len;
 
-			prevPtr->meta[i].header |=
-				(prevPtr->meta[i - 1].header & JENTRY_POSMASK) + len;
-		}
-		else
-		{
-			elog(ERROR, "invalid jsonb container type");
-		}
+	for (p = 0; p < padlen; p++)
+		appendStringInfoChar(buffer, '\0');
 
-		Assert(cstate->ptr - cstate->contPtr->begin <= val->estSize);
-		prevPtr->i++;
-	}
-	else
-	{
-		elog(ERROR, "unknown flag encountered during jsonb tree walk");
-	}
+	return padlen;
 }
 
 /*
@@ -1456,64 +1359,42 @@ putJsonbValueConversion(convertState *cstate, JsonbValue *val, uint32 flags,
  * This is a worker function for putJsonbValueConversion() (itself a worker for
  * walkJsonbValueConversion()).  It handles the details with regard to Jentry
  * metadata peculiar to each scalar type.
+ *
+ * It is the callers responsibility to shift the offset if this is stored
+ * in an array or object.
  */
 static void
-putScalarConversion(convertState *cstate, JsonbValue *scalarVal, uint32 level,
-					uint32 i)
+putScalarConversion(StringInfo buffer, JsonbValue *scalarVal, JEntry *header)
 {
 	int			numlen;
 	short		padlen;
 
-	cstate->contPtr = cstate->allState + level;
-
-	if (i == 0)
-		cstate->contPtr->meta[0].header = JENTRY_ISFIRST;
-	else
-		cstate->contPtr->meta[i].header = 0;
-
 	switch (scalarVal->type)
 	{
 		case jbvNull:
-			cstate->contPtr->meta[i].header |= JENTRY_ISNULL;
-
-			if (i > 0)
-				cstate->contPtr->meta[i].header |=
-					cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK;
+			header->header = JENTRY_ISNULL;
 			break;
+
 		case jbvString:
-			memcpy(cstate->ptr, scalarVal->val.string.val, scalarVal->val.string.len);
-			cstate->ptr += scalarVal->val.string.len;
+			appendBinaryStringInfo(buffer, scalarVal->val.string.val, scalarVal->val.string.len);
 
-			if (i == 0)
-				cstate->contPtr->meta[0].header |= scalarVal->val.string.len;
-			else
-				cstate->contPtr->meta[i].header |=
-					(cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK) +
-					scalarVal->val.string.len;
+			header->header = scalarVal->val.string.len;
 			break;
+
 		case jbvNumeric:
 			numlen = VARSIZE_ANY(scalarVal->val.numeric);
-			padlen = addPaddingInt(cstate);
+			padlen = addPaddingInt(buffer);
 
-			memcpy(cstate->ptr, scalarVal->val.numeric, numlen);
-			cstate->ptr += numlen;
+			appendBinaryStringInfo(buffer, (char *) scalarVal->val.numeric, numlen);
 
-			cstate->contPtr->meta[i].header |= JENTRY_ISNUMERIC;
-			if (i == 0)
-				cstate->contPtr->meta[0].header |= padlen + numlen;
-			else
-				cstate->contPtr->meta[i].header |=
-					(cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK)
-					+ padlen + numlen;
+			header->header = JENTRY_ISNUMERIC | (padlen + numlen);
 			break;
+
 		case jbvBool:
-			cstate->contPtr->meta[i].header |= (scalarVal->val.boolean) ?
+			header->header = (scalarVal->val.boolean) ?
 				JENTRY_ISTRUE : JENTRY_ISFALSE;
-
-			if (i > 0)
-				cstate->contPtr->meta[i].header |=
-					cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK;
 			break;
+
 		default:
 			elog(ERROR, "invalid jsonb scalar type");
 	}
@@ -1584,7 +1465,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 	if (JBE_ISNULL(*ent))
 	{
 		val->type = jbvNull;
-		val->estSize = sizeof(JEntry);
 
 		return false;
 	}
@@ -1593,7 +1473,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvString;
 		val->val.string.val = (*it)->dataProper + JBE_OFF(*ent);
 		val->val.string.len = JBE_LEN(*ent);
-		val->estSize = sizeof(JEntry) + val->val.string.len;
 
 		return false;
 	}
@@ -1602,15 +1481,12 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvNumeric;
 		val->val.numeric = (Numeric) ((*it)->dataProper + INTALIGN(JBE_OFF(*ent)));
 
-		val->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(val->val.numeric);
-
 		return false;
 	}
 	else if (JBE_ISBOOL(*ent))
 	{
 		val->type = jbvBool;
 		val->val.boolean = JBE_ISBOOL_TRUE(*ent) != 0;
-		val->estSize = sizeof(JEntry);
 
 		return false;
 	}
@@ -1619,7 +1495,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvBinary;
 		val->val.binary.data = (*it)->dataProper + INTALIGN(JBE_OFF(*ent));
 		val->val.binary.len = JBE_LEN(*ent) - (INTALIGN(JBE_OFF(*ent)) - JBE_OFF(*ent));
-		val->estSize = val->val.binary.len + 2 * sizeof(JEntry);
 
 		return false;
 	}
@@ -1694,8 +1569,6 @@ appendKey(JsonbParseState *pstate, JsonbValue *string)
 
 	object->val.object.pairs[object->val.object.nPairs].key = *string;
 	object->val.object.pairs[object->val.object.nPairs].order = object->val.object.nPairs;
-
-	object->estSize += string->estSize;
 }
 
 /*
@@ -1710,7 +1583,6 @@ appendValue(JsonbParseState *pstate, JsonbValue *scalarVal)
 	Assert(object->type == jbvObject);
 
 	object->val.object.pairs[object->val.object.nPairs++].value = *scalarVal;
-	object->estSize += scalarVal->estSize;
 }
 
 /*
@@ -1737,7 +1609,6 @@ appendElement(JsonbParseState *pstate, JsonbValue *scalarVal)
 	}
 
 	array->val.array.elems[array->val.array.nElems++] = *scalarVal;
-	array->estSize += scalarVal->estSize;
 }
 
 /*
@@ -1832,11 +1703,7 @@ uniqueifyJsonbObject(JsonbValue *object)
 		while (ptr - object->val.object.pairs < object->val.object.nPairs)
 		{
 			/* Avoid copying over duplicate */
-			if (lengthCompareJsonbStringValue(ptr, res, NULL) == 0)
-			{
-				object->estSize -= ptr->key.estSize + ptr->value.estSize;
-			}
-			else
+			if (lengthCompareJsonbStringValue(ptr, res, NULL) != 0)
 			{
 				res++;
 				if (ptr != res)
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index 6b1ce9b..a9fedcb 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -1477,7 +1477,7 @@ each_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 						StringInfo	jtext = makeStringInfo();
 						Jsonb	   *jb = JsonbValueToJsonb(&v);
 
-						(void) JsonbToCString(jtext, VARDATA(jb), 2 * v.estSize);
+						(void) JsonbToCString(jtext, VARDATA(jb), 0);
 						sv = cstring_to_text_with_len(jtext->data, jtext->len);
 					}
 
@@ -1797,7 +1797,7 @@ elements_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 						StringInfo	jtext = makeStringInfo();
 						Jsonb	   *jb = JsonbValueToJsonb(&v);
 
-						(void) JsonbToCString(jtext, VARDATA(jb), 2 * v.estSize);
+						(void) JsonbToCString(jtext, VARDATA(jb), 0);
 						sv = cstring_to_text_with_len(jtext->data, jtext->len);
 					}
 
diff --git a/src/include/utils/jsonb.h b/src/include/utils/jsonb.h
index dea64ad..2e62c25 100644
--- a/src/include/utils/jsonb.h
+++ b/src/include/utils/jsonb.h
@@ -16,17 +16,6 @@
 #include "utils/array.h"
 #include "utils/numeric.h"
 
-/*
- * JB_CMASK is used to extract count of items
- *
- * It's not possible to get more than 2^28 items into an Jsonb.
- */
-#define JB_CMASK				0x0FFFFFFF
-
-#define JB_FSCALAR				0x10000000
-#define JB_FOBJECT				0x20000000
-#define JB_FARRAY				0x40000000
-
 /* Get information on varlena Jsonb */
 #define JB_ROOT_COUNT(jbp_)		( *(uint32*) VARDATA(jbp_) & JB_CMASK)
 #define JB_ROOT_IS_SCALAR(jbp_) ( *(uint32*) VARDATA(jbp_) & JB_FSCALAR)
@@ -109,35 +98,88 @@ typedef char *JsonbSuperHeader;
  * representation.  Often, JsonbValues are just shims through which a Jsonb
  * buffer is accessed, but they can also be deep copied and passed around.
  *
- * We have an abstraction called a "superheader".  This is a pointer that
- * conventionally points to the first item after our 4-byte uncompressed
- * varlena header, from which we can read flags using bitwise operations.
+ * Jsonb is a tree structure. Each node in the tree consists of a JEntry
+ * header, and a variable-length content.  The JEntry header indicates what
+ * kind of a node it is, e.g. a string or an array (see JENTRY_IS* macros),
+ * and the offset and length of its variable-length portion within the
+ * container.
+ *
+ * The header and the content of a node are not stored physically together.
+ * Instead, the array or object containing the node has an array that holds
+ * the JEntry headers of all the child nodes, followed by their variable-length
+ * portions.
  *
+ * The root node is an exception; it has no parent array or object that could
+ * hold its JEntry. Hence, there is no Jentry header for the root node.
+ * It is implicitly known that the the root node must be an array or an
+ * object. The content of both an array and an object begins with a uint32
+ * header field containing the number of elements, and an JB_FOBJECT or
+ * JB_FARRAY flag. By peeking into that header, we can determine which it is.
+ * When a naked scalar value needs to be stored as a Jsonb value, what we
+ * actually store is an array with one element, with the flags in the array's
+ * header field set to JB_FSCALAR | JB_FARRAY.
+ *
+ * The variable-length data of a container node, an array or an object,
+ * begins with a uint32 header. It contains the number of child nodes,
+ * and a flag indicating if it's an array or an object (JB_* macros).
+ * An array has one child node for each element, and an object has two
+ * child nodes for each  key-value pair. After the uint32 header, there is
+ * an array of JEntry structs, one for each child node, followed by the
+ * variable-length data of each child.
+ *
+ * To encode the length and offset of the variable-length portion of each
+ * node in a compact way, the JEntry stores only the end offset within the
+ * variable-length portion of the container node. For the first JEntry in the
+ * container's JEntry array, that equals to the length of the node data. For
+ * convenience, the JENTRY_ISFIRST flag is set. The begin offset and length
+ * of the rest of the entries can be calculated using the end offset of the
+ * previous JEntry in the array.
+ *
+ *
+ * Alignment
+ * ---------
+ *
+ * Overall, the Jsonb struct requires 4-bytes alignment. Within the struct,
+ * the variable-length portion of some node types is aligned to a 4-byte
+ * boundary, while others are not. When alignment is needed, the padding is
+ * in the beginning of the node that requires it. For example, if a numeric
+ * node is stored after a string node, so that the numeric node begins at
+ * offset 3, the variable-length portion of the numeric node will begin with
+ * one padding byte.
+ *
+ * XXX: old comment below; what does this mean?
  * Frequently, we pass a superheader reference to a function, and it doesn't
  * matter if it points to just after the start of a Jsonb, or to a temp buffer.
  */
+
 typedef struct
 {
-	int32		vl_len_;		/* varlena header (do not touch directly!) */
-	uint32		superheader;
-	/* (array of JEntry follows, size determined using uint32 superheader) */
-} Jsonb;
+	uint32		header;			/* Shares some flags with superheader */
+} JEntry;
 
 /*
- * JEntry: there is one of these for each key _and_ value for objects.  Arrays
- * have one per element.
- *
- * The position offset points to the _end_ so that we can get the length by
- * subtraction from the previous entry.  The JENTRY_ISFIRST flag indicates if
- * there is a previous entry.
+ * A jsonb array or object node.
+ * 
+ * An array has one child for each element. An object has two children for
+ * each key/value pair.
  */
+typedef struct JsonbContainer
+{
+	uint32		header;			/* number of children, and flags (JB_* below) */
+	JEntry		children[1];	/* variable length */
+} JsonbContainer;
+
 typedef struct
 {
-	uint32		header;			/* Shares some flags with superheader */
-} JEntry;
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	JsonbContainer root;
+} Jsonb;
 
-#define IsAJsonbScalar(jsonbval)	((jsonbval)->type >= jbvNull && \
-									 (jsonbval)->type <= jbvBool)
+#define JB_CMASK				0x0FFFFFFF
+
+#define JB_FSCALAR				0x10000000
+#define JB_FOBJECT				0x20000000
+#define JB_FARRAY				0x40000000
 
 /*
  * JsonbValue:	In-memory representation of Jsonb.  This is a convenient
@@ -161,8 +203,6 @@ struct JsonbValue
 		jbvBinary
 	}			type;			/* Influences sort order */
 
-	int			estSize;		/* Estimated size of node (including subnodes) */
-
 	union
 	{
 		Numeric numeric;
@@ -194,6 +234,9 @@ struct JsonbValue
 	}			val;
 };
 
+#define IsAJsonbScalar(jsonbval)	((jsonbval)->type >= jbvNull && \
+									 (jsonbval)->type <= jbvBool)
+
 /*
  * Pair within an Object.
  *

diff --git a/src/backend/utils/adt/jsonb.c b/src/backend/utils/adt/jsonb.c
index cf5d6f2..0d667c2 100644
--- a/src/backend/utils/adt/jsonb.c
+++ b/src/backend/utils/adt/jsonb.c
@@ -33,7 +33,6 @@ static void jsonb_in_array_end(void *pstate);
 static void jsonb_in_object_field_start(void *pstate, char *fname, bool isnull);
 static void jsonb_put_escaped_value(StringInfo out, JsonbValue *scalarVal);
 static void jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype);
-char	   *JsonbToCString(StringInfo out, char *in, int estimated_len);
 
 /*
  * jsonb type input function
@@ -65,7 +64,7 @@ jsonb_recv(PG_FUNCTION_ARGS)
 	if (version == 1)
 		str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
 	else
-		elog(ERROR, "Unsupported jsonb version number %d", version);
+		elog(ERROR, "unsupported jsonb version number %d", version);
 
 	return jsonb_from_cstring(str, nbytes);
 }
@@ -79,7 +78,7 @@ jsonb_out(PG_FUNCTION_ARGS)
 	Jsonb	   *jb = PG_GETARG_JSONB(0);
 	char	   *out;
 
-	out = JsonbToCString(NULL, VARDATA(jb), VARSIZE(jb));
+	out = JsonbToCString(NULL, (JsonbContainer *) VARDATA(jb), VARSIZE(jb));
 
 	PG_RETURN_CSTRING(out);
 }
@@ -97,7 +96,7 @@ jsonb_send(PG_FUNCTION_ARGS)
 	StringInfo	jtext = makeStringInfo();
 	int			version = 1;
 
-	(void) JsonbToCString(jtext, VARDATA(jb), VARSIZE(jb));
+	(void) JsonbToCString(jtext, (JsonbContainer *) VARDATA(jb), VARSIZE(jb));
 
 	pq_begintypsend(&buf);
 	pq_sendint(&buf, version, 1);
@@ -130,7 +129,7 @@ jsonb_typeof(PG_FUNCTION_ARGS)
 	{
 		Assert(JB_ROOT_IS_SCALAR(in));
 
-		it = JsonbIteratorInit(VARDATA_ANY(in));
+		it = JsonbIteratorInit(&in->root);
 
 		/*
 		 * A root scalar is stored as an array of one element, so we get the
@@ -249,7 +248,6 @@ jsonb_in_object_field_start(void *pstate, char *fname, bool isnull)
 	v.type = jbvString;
 	v.val.string.len = checkStringLen(strlen(fname));
 	v.val.string.val = pnstrdup(fname, v.val.string.len);
-	v.estSize = sizeof(JEntry) + v.val.string.len;
 
 	_state->res = pushJsonbValue(&_state->parseState, WJB_KEY, &v);
 }
@@ -290,8 +288,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 	JsonbInState *_state = (JsonbInState *) pstate;
 	JsonbValue	v;
 
-	v.estSize = sizeof(JEntry);
-
 	switch (tokentype)
 	{
 
@@ -300,7 +296,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 			v.type = jbvString;
 			v.val.string.len = checkStringLen(strlen(token));
 			v.val.string.val = pnstrdup(token, v.val.string.len);
-			v.estSize += v.val.string.len;
 			break;
 		case JSON_TOKEN_NUMBER:
 
@@ -312,7 +307,6 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
 			v.type = jbvNumeric;
 			v.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(token), 0, -1));
 
-			v.estSize += VARSIZE_ANY(v.val.numeric) +sizeof(JEntry) /* alignment */ ;
 			break;
 		case JSON_TOKEN_TRUE:
 			v.type = jbvBool;
@@ -374,7 +368,7 @@ jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
  * if they are converting it to a text* object.
  */
 char *
-JsonbToCString(StringInfo out, JsonbSuperHeader in, int estimated_len)
+JsonbToCString(StringInfo out, JsonbContainer *in, int estimated_len)
 {
 	bool		first = true;
 	JsonbIterator *it;
diff --git a/src/backend/utils/adt/jsonb_gin.c b/src/backend/utils/adt/jsonb_gin.c
index 9f8c178..cc71e5e 100644
--- a/src/backend/utils/adt/jsonb_gin.c
+++ b/src/backend/utils/adt/jsonb_gin.c
@@ -80,7 +80,7 @@ gin_extract_jsonb(PG_FUNCTION_ARGS)
 
 	entries = (Datum *) palloc(sizeof(Datum) * total);
 
-	it = JsonbIteratorInit(VARDATA(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
 	{
@@ -487,7 +487,7 @@ gin_extract_jsonb_hash(PG_FUNCTION_ARGS)
 
 	entries = (Datum *) palloc(sizeof(Datum) * total);
 
-	it = JsonbIteratorInit(VARDATA(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	tail.parent = NULL;
 	tail.hash = 0;
diff --git a/src/backend/utils/adt/jsonb_op.c b/src/backend/utils/adt/jsonb_op.c
index 38bd567..1db6382 100644
--- a/src/backend/utils/adt/jsonb_op.c
+++ b/src/backend/utils/adt/jsonb_op.c
@@ -34,10 +34,10 @@ jsonb_exists(PG_FUNCTION_ARGS)
 	kval.val.string.val = VARDATA_ANY(key);
 	kval.val.string.len = VARSIZE_ANY_EXHDR(key);
 
-	v = findJsonbValueFromSuperHeader(VARDATA(jb),
-									  JB_FOBJECT | JB_FARRAY,
-									  NULL,
-									  &kval);
+	v = findJsonbValueFromContainer(&jb->root,
+									JB_FOBJECT | JB_FARRAY,
+									NULL,
+									&kval);
 
 	PG_RETURN_BOOL(v != NULL);
 }
@@ -66,9 +66,9 @@ jsonb_exists_any(PG_FUNCTION_ARGS)
 	 */
 	for (i = 0; i < arrKey->val.array.nElems; i++)
 	{
-		if (findJsonbValueFromSuperHeader(VARDATA(jb),
-										  JB_FOBJECT | JB_FARRAY,
-										  plowbound,
+		if (findJsonbValueFromContainer(&jb->root,
+										JB_FOBJECT | JB_FARRAY,
+										plowbound,
 										arrKey->val.array.elems + i) != NULL)
 			PG_RETURN_BOOL(true);
 	}
@@ -100,9 +100,9 @@ jsonb_exists_all(PG_FUNCTION_ARGS)
 	 */
 	for (i = 0; i < arrKey->val.array.nElems; i++)
 	{
-		if (findJsonbValueFromSuperHeader(VARDATA(jb),
-										  JB_FOBJECT | JB_FARRAY,
-										  plowbound,
+		if (findJsonbValueFromContainer(&jb->root,
+										JB_FOBJECT | JB_FARRAY,
+										plowbound,
 										arrKey->val.array.elems + i) == NULL)
 			PG_RETURN_BOOL(false);
 	}
@@ -123,8 +123,8 @@ jsonb_contains(PG_FUNCTION_ARGS)
 		JB_ROOT_IS_OBJECT(val) != JB_ROOT_IS_OBJECT(tmpl))
 		PG_RETURN_BOOL(false);
 
-	it1 = JsonbIteratorInit(VARDATA(val));
-	it2 = JsonbIteratorInit(VARDATA(tmpl));
+	it1 = JsonbIteratorInit(&val->root);
+	it2 = JsonbIteratorInit(&tmpl->root);
 
 	PG_RETURN_BOOL(JsonbDeepContains(&it1, &it2));
 }
@@ -143,8 +143,8 @@ jsonb_contained(PG_FUNCTION_ARGS)
 		JB_ROOT_IS_OBJECT(val) != JB_ROOT_IS_OBJECT(tmpl))
 		PG_RETURN_BOOL(false);
 
-	it1 = JsonbIteratorInit(VARDATA(val));
-	it2 = JsonbIteratorInit(VARDATA(tmpl));
+	it1 = JsonbIteratorInit(&val->root);
+	it2 = JsonbIteratorInit(&tmpl->root);
 
 	PG_RETURN_BOOL(JsonbDeepContains(&it1, &it2));
 }
@@ -156,7 +156,7 @@ jsonb_ne(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) != 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) != 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -173,7 +173,7 @@ jsonb_lt(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) < 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) < 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -187,7 +187,7 @@ jsonb_gt(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) > 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) > 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -201,7 +201,7 @@ jsonb_le(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) <= 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) <= 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -215,7 +215,7 @@ jsonb_ge(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) >= 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) >= 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -229,7 +229,7 @@ jsonb_eq(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	bool		res;
 
-	res = (compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb)) == 0);
+	res = (compareJsonbContainers(&jba->root, &jbb->root) == 0);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -243,7 +243,7 @@ jsonb_cmp(PG_FUNCTION_ARGS)
 	Jsonb	   *jbb = PG_GETARG_JSONB(1);
 	int			res;
 
-	res = compareJsonbSuperHeaderValue(VARDATA(jba), VARDATA(jbb));
+	res = compareJsonbContainers(&jba->root, &jbb->root);
 
 	PG_FREE_IF_COPY(jba, 0);
 	PG_FREE_IF_COPY(jbb, 1);
@@ -265,7 +265,7 @@ jsonb_hash(PG_FUNCTION_ARGS)
 	if (JB_ROOT_COUNT(jb) == 0)
 		PG_RETURN_INT32(0);
 
-	it = JsonbIteratorInit(VARDATA(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
 	{
diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 1caaa4a..0ab1f37 100644
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -37,50 +37,17 @@
 #define JSONB_MAX_PAIRS (Min(MaxAllocSize / sizeof(JsonbPair), \
 							 JENTRY_POSMASK))
 
-/*
- * State used while converting an arbitrary JsonbValue into a Jsonb value
- * (4-byte varlena uncompressed representation of a Jsonb)
- *
- * ConvertLevel:  Bookkeeping around particular level when converting.
- */
-typedef struct convertLevel
-{
-	uint32		i;				/* Iterates once per element, or once per pair */
-	uint32	   *header;			/* Pointer to current container header */
-	JEntry	   *meta;			/* This level's metadata */
-	char	   *begin;			/* Pointer into convertState.buffer */
-} convertLevel;
-
-/*
- * convertState:  Overall bookkeeping state for conversion
- */
-typedef struct convertState
-{
-	/* Preallocated buffer in which to form varlena/Jsonb value */
-	Jsonb	   *buffer;
-	/* Pointer into buffer */
-	char	   *ptr;
-
-	/* State for  */
-	convertLevel *allState,		/* Overall state array */
-			   *contPtr;		/* Cur container pointer (in allState) */
-
-	/* Current size of buffer containing allState array */
-	Size		levelSz;
-
-} convertState;
-
 static int	compareJsonbScalarValue(JsonbValue *a, JsonbValue *b);
 static int	lexicalCompareJsonbStringValue(const void *a, const void *b);
-static Size convertJsonb(JsonbValue *val, Jsonb *buffer);
-static inline short addPaddingInt(convertState *cstate);
-static void walkJsonbValueConversion(JsonbValue *val, convertState *cstate,
-						 uint32 nestlevel);
-static void putJsonbValueConversion(convertState *cstate, JsonbValue *val,
-						uint32 flags, uint32 level);
-static void putScalarConversion(convertState *cstate, JsonbValue *scalarVal,
-					uint32 level, uint32 i);
-static void iteratorFromContainerBuf(JsonbIterator *it, char *buffer);
+static Jsonb *convertJsonb(JsonbValue *val);
+static inline short addPaddingInt(StringInfo buffer);
+static void walkJsonbValueConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void walkJsonbArrayConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void walkJsonbObjectConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level);
+static void putScalarConversion(StringInfo buffer, JsonbValue *scalarVal,
+								JEntry *header);
+static int reserveStringInfo(StringInfo str, int datalen);
+static void iteratorFromContainer(JsonbIterator *it, JsonbContainer *container);
 static bool formIterIsContainer(JsonbIterator **it, JsonbValue *val,
 					JEntry *ent, bool skipNested);
 static JsonbIterator *freeAndGetParent(JsonbIterator *it);
@@ -110,7 +77,6 @@ Jsonb *
 JsonbValueToJsonb(JsonbValue *val)
 {
 	Jsonb	   *out;
-	Size		sz;
 
 	if (IsAJsonbScalar(val))
 	{
@@ -127,17 +93,11 @@ JsonbValueToJsonb(JsonbValue *val)
 		pushJsonbValue(&pstate, WJB_ELEM, val);
 		res = pushJsonbValue(&pstate, WJB_END_ARRAY, NULL);
 
-		out = palloc(VARHDRSZ + res->estSize);
-		sz = convertJsonb(res, out);
-		Assert(sz <= res->estSize);
-		SET_VARSIZE(out, sz + VARHDRSZ);
+		out = convertJsonb(res);
 	}
 	else if (val->type == jbvObject || val->type == jbvArray)
 	{
-		out = palloc(VARHDRSZ + val->estSize);
-		sz = convertJsonb(val, out);
-		Assert(sz <= val->estSize);
-		SET_VARSIZE(out, VARHDRSZ + sz);
+		out = convertJsonb(val);
 	}
 	else
 	{
@@ -161,7 +121,7 @@ JsonbValueToJsonb(JsonbValue *val)
  * memory here.
  */
 int
-compareJsonbSuperHeaderValue(JsonbSuperHeader a, JsonbSuperHeader b)
+compareJsonbContainers(JsonbContainer *a, JsonbContainer *b)
 {
 	JsonbIterator *ita,
 			   *itb;
@@ -288,15 +248,15 @@ compareJsonbSuperHeaderValue(JsonbSuperHeader a, JsonbSuperHeader b)
  *
  * In order to proceed with the search, it is necessary for callers to have
  * both specified an interest in exactly one particular container type with an
- * appropriate flag, as well as having the pointed-to Jsonb superheader be of
+ * appropriate flag, as well as having the pointed-to Jsonb container be of
  * one of those same container types at the top level. (Actually, we just do
  * whichever makes sense to save callers the trouble of figuring it out - at
- * most one can make sense, because the super header either points to an array
- * (possible a "raw scalar" pseudo array) or an object.)
+ * most one can make sense, because the container either points to an array
+ * (possibly a "raw scalar" pseudo array) or an object.)
  *
  * Note that we can return a jbvBinary JsonbValue if this is called on an
  * object, but we never do so on an array.  If the caller asks to look through
- * a container type that is not of the type pointed to by the superheader,
+ * a container type that is not of the type pointed to by the container,
  * immediately fall through and return NULL.  If we cannot find the value,
  * return NULL.  Otherwise, return palloc()'d copy of value.
  *
@@ -309,25 +269,24 @@ compareJsonbSuperHeaderValue(JsonbSuperHeader a, JsonbSuperHeader b)
  * item, picking it up where we left off knowing that the second or subsequent
  * item can not be at a point below the low bound set when the first was found.
  * This is only useful for objects, not arrays (which have a user-defined
- * order), so array superheader Jsonbs should just pass NULL.  Moreover, it's
+ * order), so array container Jsonbs should just pass NULL.  Moreover, it's
  * only useful because we only match object pairs on the basis of their key, so
  * presumably anyone exploiting this is only interested in matching Object keys
  * with a String.  lowbound is given in units of pairs, not underlying values.
  */
 JsonbValue *
-findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
-							  uint32 *lowbound, JsonbValue *key)
+findJsonbValueFromContainer(JsonbContainer *container, uint32 flags,
+							uint32 *lowbound, JsonbValue *key)
 {
-	uint32		superheader = *(uint32 *) sheader;
-	JEntry	   *array = (JEntry *) (sheader + sizeof(uint32));
-	int			count = (superheader & JB_CMASK);
+	JEntry	   *array = container->children;
+	int			count = (container->header & JB_CMASK);
 	JsonbValue *result = palloc(sizeof(JsonbValue));
 
 	Assert((flags & ~(JB_FARRAY | JB_FOBJECT)) == 0);
 
-	if (flags & JB_FARRAY & superheader)
+	if (flags & JB_FARRAY & container->header)
 	{
-		char	   *data = (char *) (array + (superheader & JB_CMASK));
+		char	   *data = (char *) (array + (container->header & JB_CMASK));
 		int			i;
 
 		for (i = 0; i < count; i++)
@@ -337,28 +296,22 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 			if (JBE_ISNULL(*e) && key->type == jbvNull)
 			{
 				result->type = jbvNull;
-				result->estSize = sizeof(JEntry);
 			}
 			else if (JBE_ISSTRING(*e) && key->type == jbvString)
 			{
 				result->type = jbvString;
 				result->val.string.val = data + JBE_OFF(*e);
 				result->val.string.len = JBE_LEN(*e);
-				result->estSize = sizeof(JEntry) + result->val.string.len;
 			}
 			else if (JBE_ISNUMERIC(*e) && key->type == jbvNumeric)
 			{
 				result->type = jbvNumeric;
 				result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
-
-				result->estSize = 2 * sizeof(JEntry) +
-					VARSIZE_ANY(result->val.numeric);
 			}
 			else if (JBE_ISBOOL(*e) && key->type == jbvBool)
 			{
 				result->type = jbvBool;
 				result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
-				result->estSize = sizeof(JEntry);
 			}
 			else
 				continue;
@@ -367,10 +320,10 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 				return result;
 		}
 	}
-	else if (flags & JB_FOBJECT & superheader)
+	else if (flags & JB_FOBJECT & container->header)
 	{
 		/* Since this is an object, account for *Pairs* of Jentrys */
-		char	   *data = (char *) (array + (superheader & JB_CMASK) * 2);
+		char	   *data = (char *) (array + (container->header & JB_CMASK) * 2);
 		uint32		stopLow = lowbound ? *lowbound : 0,
 					stopMiddle;
 
@@ -395,7 +348,6 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 			candidate.type = jbvString;
 			candidate.val.string.val = data + JBE_OFF(*entry);
 			candidate.val.string.len = JBE_LEN(*entry);
-			candidate.estSize = sizeof(JEntry) + candidate.val.string.len;
 
 			difference = lengthCompareJsonbStringValue(&candidate, key, NULL);
 
@@ -410,28 +362,22 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 				if (JBE_ISNULL(*v))
 				{
 					result->type = jbvNull;
-					result->estSize = sizeof(JEntry);
 				}
 				else if (JBE_ISSTRING(*v))
 				{
 					result->type = jbvString;
 					result->val.string.val = data + JBE_OFF(*v);
 					result->val.string.len = JBE_LEN(*v);
-					result->estSize = sizeof(JEntry) + result->val.string.len;
 				}
 				else if (JBE_ISNUMERIC(*v))
 				{
 					result->type = jbvNumeric;
 					result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*v)));
-
-					result->estSize = 2 * sizeof(JEntry) +
-						VARSIZE_ANY(result->val.numeric);
 				}
 				else if (JBE_ISBOOL(*v))
 				{
 					result->type = jbvBool;
 					result->val.boolean = JBE_ISBOOL_TRUE(*v) != 0;
-					result->estSize = sizeof(JEntry);
 				}
 				else
 				{
@@ -443,7 +389,6 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 					result->val.binary.data = data + INTALIGN(JBE_OFF(*v));
 					result->val.binary.len = JBE_LEN(*v) -
 						(INTALIGN(JBE_OFF(*v)) - JBE_OFF(*v));
-					result->estSize = 2 * sizeof(JEntry) + result->val.binary.len;
 				}
 
 				return result;
@@ -467,67 +412,57 @@ findJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 flags,
 }
 
 /*
- * Get i-th value of Jsonb array from superheader.
+ * Get i-th value of a Jsonb array.
  *
- * Returns palloc()'d copy of value.
+ * Returns palloc()'d copy of the value, or NULL if it does not exist.
  */
 JsonbValue *
-getIthJsonbValueFromSuperHeader(JsonbSuperHeader sheader, uint32 i)
+getIthJsonbValueFromContainer(JsonbContainer *container, uint32 i)
 {
-	uint32		superheader = *(uint32 *) sheader;
 	JsonbValue *result;
-	JEntry	   *array,
-			   *e;
+	JEntry	   *e;
 	char	   *data;
+	uint32		nelements;
 
-	result = palloc(sizeof(JsonbValue));
+	if ((container->header & JB_FARRAY) == 0)
+		elog(ERROR, "not a jsonb array");
 
-	if (i >= (superheader & JB_CMASK))
+	nelements = container->header & JB_CMASK;
+
+	if (i >= nelements)
 		return NULL;
 
-	array = (JEntry *) (sheader + sizeof(uint32));
+	e = &container->children[i];
 
-	if (superheader & JB_FARRAY)
-	{
-		e = array + i;
-		data = (char *) (array + (superheader & JB_CMASK));
-	}
-	else
-	{
-		elog(ERROR, "not a jsonb array");
-	}
+	data = (char *) &container->children[nelements];
+
+	result = palloc(sizeof(JsonbValue));
 
 	if (JBE_ISNULL(*e))
 	{
 		result->type = jbvNull;
-		result->estSize = sizeof(JEntry);
 	}
 	else if (JBE_ISSTRING(*e))
 	{
 		result->type = jbvString;
 		result->val.string.val = data + JBE_OFF(*e);
 		result->val.string.len = JBE_LEN(*e);
-		result->estSize = sizeof(JEntry) + result->val.string.len;
 	}
 	else if (JBE_ISNUMERIC(*e))
 	{
 		result->type = jbvNumeric;
 		result->val.numeric = (Numeric) (data + INTALIGN(JBE_OFF(*e)));
-
-		result->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(result->val.numeric);
 	}
 	else if (JBE_ISBOOL(*e))
 	{
 		result->type = jbvBool;
 		result->val.boolean = JBE_ISBOOL_TRUE(*e) != 0;
-		result->estSize = sizeof(JEntry);
 	}
 	else
 	{
 		result->type = jbvBinary;
 		result->val.binary.data = data + INTALIGN(JBE_OFF(*e));
 		result->val.binary.len = JBE_LEN(*e) - (INTALIGN(JBE_OFF(*e)) - JBE_OFF(*e));
-		result->estSize = result->val.binary.len + 2 * sizeof(JEntry);
 	}
 
 	return result;
@@ -558,7 +493,6 @@ pushJsonbValue(JsonbParseState **pstate, int seq, JsonbValue *scalarVal)
 			*pstate = pushState(pstate);
 			result = &(*pstate)->contVal;
 			(*pstate)->contVal.type = jbvArray;
-			(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
 			(*pstate)->contVal.val.array.nElems = 0;
 			(*pstate)->contVal.val.array.rawScalar = (scalarVal &&
 											 scalarVal->val.array.rawScalar);
@@ -580,7 +514,6 @@ pushJsonbValue(JsonbParseState **pstate, int seq, JsonbValue *scalarVal)
 			*pstate = pushState(pstate);
 			result = &(*pstate)->contVal;
 			(*pstate)->contVal.type = jbvObject;
-			(*pstate)->contVal.estSize = 3 * sizeof(JEntry);
 			(*pstate)->contVal.val.object.nPairs = 0;
 			(*pstate)->size = 4;
 			(*pstate)->contVal.val.object.pairs = palloc(sizeof(JsonbPair) *
@@ -635,17 +568,17 @@ pushJsonbValue(JsonbParseState **pstate, int seq, JsonbValue *scalarVal)
 }
 
 /*
- * Given a Jsonb superheader, expand to JsonbIterator to iterate over items
+ * Given a JsonbContainer, expand to JsonbIterator to iterate over items
  * fully expanded to in-memory representation for manipulation.
  *
  * See JsonbIteratorNext() for notes on memory management.
  */
 JsonbIterator *
-JsonbIteratorInit(JsonbSuperHeader sheader)
+JsonbIteratorInit(JsonbContainer *sheader)
 {
 	JsonbIterator *it = palloc(sizeof(JsonbIterator));
 
-	iteratorFromContainerBuf(it, sheader);
+	iteratorFromContainer(it, sheader);
 	it->parent = NULL;
 
 	return it;
@@ -875,10 +808,10 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
 			Assert(rcont == WJB_KEY);
 
 			/* First, find value by key... */
-			lhsVal = findJsonbValueFromSuperHeader((*val)->buffer,
-												   JB_FOBJECT,
-												   NULL,
-												   &vcontained);
+			lhsVal = findJsonbValueFromContainer((JsonbContainer *) (*val)->buffer,
+												 JB_FOBJECT,
+												 NULL,
+												 &vcontained);
 
 			if (!lhsVal)
 				return false;
@@ -913,8 +846,8 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
 				Assert(lhsVal->type == jbvBinary);
 				Assert(vcontained.type == jbvBinary);
 
-				nestval = JsonbIteratorInit(lhsVal->val.binary.data);
-				nestContained = JsonbIteratorInit(vcontained.val.binary.data);
+				nestval = JsonbIteratorInit((JsonbContainer *) lhsVal->val.binary.data);
+				nestContained = JsonbIteratorInit((JsonbContainer *) vcontained.val.binary.data);
 
 				/*
 				 * Match "value" side of rhs datum object's pair recursively.
@@ -978,10 +911,10 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
 
 			if (IsAJsonbScalar(&vcontained))
 			{
-				if (!findJsonbValueFromSuperHeader((*val)->buffer,
-												   JB_FARRAY,
-												   NULL,
-												   &vcontained))
+				if (!findJsonbValueFromContainer((JsonbContainer *) (*val)->buffer,
+												 JB_FARRAY,
+												 NULL,
+												 &vcontained))
 					return false;
 			}
 			else
@@ -1025,8 +958,8 @@ JsonbDeepContains(JsonbIterator **val, JsonbIterator **mContained)
 							   *nestContained;
 					bool		contains;
 
-					nestval = JsonbIteratorInit(lhsConts[i].val.binary.data);
-					nestContained = JsonbIteratorInit(vcontained.val.binary.data);
+					nestval = JsonbIteratorInit((JsonbContainer *) lhsConts[i].val.binary.data);
+					nestContained = JsonbIteratorInit((JsonbContainer *) vcontained.val.binary.data);
 
 					contains = JsonbDeepContains(&nestval, &nestContained);
 
@@ -1209,244 +1142,230 @@ lexicalCompareJsonbStringValue(const void *a, const void *b)
 					  vb->val.string.len, DEFAULT_COLLATION_OID);
 }
 
+
+/*
+ * Reserve 'datalen' bytes at the end of StringInfo, enlarging the underlying
+ * buffer if necessary. Returns the offset to the reserved area.
+ */
+static int
+reserveStringInfo(StringInfo str, int datalen)
+{
+	int		offset;
+
+	/* Make more room if needed */
+	enlargeStringInfo(str, datalen);
+
+	/* remember current offset */
+	offset = str->len;
+
+	/* reserve the space */
+	str->len += datalen;
+
+	/* XXX: we don't bother with the trailing null that normal StringInfo
+	 * functions append */
+
+	return offset;
+}
+
 /*
- * Given a JsonbValue, convert to Jsonb and store in preallocated Jsonb buffer
- * sufficiently large to fit the value
+ * Given a JsonbValue, convert to Jsonb. The result is palloc'd.
  */
-static Size
-convertJsonb(JsonbValue *val, Jsonb *buffer)
+static Jsonb *
+convertJsonb(JsonbValue *val)
 {
-	convertState state;
-	Size		len;
+	StringInfoData buffer;
+	JEntry		header;
+	Jsonb	   *res;
+
+	initStringInfo(&buffer);
 
 	/* Should not already have binary representation */
 	Assert(val->type != jbvBinary);
 
-	state.buffer = buffer;
-	/* Start from superheader */
-	state.ptr = VARDATA(state.buffer);
-	state.levelSz = 8;
-	state.allState = palloc(sizeof(convertLevel) * state.levelSz);
+	/* Reserve the Jsonb header */
+	reserveStringInfo(&buffer, sizeof(VARHDRSZ));
 
-	walkJsonbValueConversion(val, &state, 0);
+	walkJsonbValueConversion(val, &buffer, &header, 0);
 
-	len = state.ptr - VARDATA(state.buffer);
+	res = (Jsonb *) buffer.data;
 
-	Assert(len <= val->estSize);
-	return len;
+	SET_VARSIZE(res, buffer.len);
+
+	return res;
 }
 
 /*
- * Walk the tree representation of Jsonb, as part of the process of converting
- * a JsonbValue to a Jsonb.
+ * Convert a single JsonbValue to a Jsonb node. 
  *
- * This high-level function takes care of recursion into sub-containers, but at
- * the top level calls putJsonbValueConversion once per sequential processing
- * token (in a manner similar to generic iteration).
+ * The value is written out to 'buffer'. The JEntry header for this node is
+ * returned in *header. It is filled in with the length of this value, but if
+ * it is stored in an array or an object (which is always, except for the root
+ * node), it is the caller's responsibility to adjust it with the offset
+ * within the container.
+ *
+ * If the value is an array or an object, this recurses. 'level' is only used
+ * for debugging purposes.
  */
 static void
-walkJsonbValueConversion(JsonbValue *val, convertState *cstate,
-						 uint32 nestlevel)
+walkJsonbValueConversion(JsonbValue *val, StringInfo buffer, JEntry *header, int level)
 {
-	int			i;
-
 	check_stack_depth();
 
 	if (!val)
 		return;
 
-	switch (val->type)
-	{
-		case jbvArray:
+	if (IsAJsonbScalar(val) || val->type == jbvBinary)
+		putScalarConversion(buffer, val, header);
+	else if (val->type == jbvArray)
+		walkJsonbArrayConversion(val, buffer, header, level);
+	else if (val->type == jbvObject)
+		walkJsonbObjectConversion(val, buffer, header, level);
+	else
+		elog(ERROR, "unknown type of jsonb container");
+}
 
-			putJsonbValueConversion(cstate, val, WJB_BEGIN_ARRAY, nestlevel);
-			for (i = 0; i < val->val.array.nElems; i++)
-			{
-				if (IsAJsonbScalar(&val->val.array.elems[i]) ||
-					val->val.array.elems[i].type == jbvBinary)
-					putJsonbValueConversion(cstate, val->val.array.elems + i,
-											WJB_ELEM, nestlevel);
-				else
-					walkJsonbValueConversion(val->val.array.elems + i, cstate,
-											 nestlevel + 1);
-			}
-			putJsonbValueConversion(cstate, val, WJB_END_ARRAY, nestlevel);
+static void
+walkJsonbArrayConversion(JsonbValue *val, StringInfo buffer, JEntry *pheader, int level)
+{
+	int			offset;
+	int			metaoffset;
+	int			i;
+	int			totallen;
+	JEntry		header;
 
-			break;
-		case jbvObject:
+	/* Initialize pointer into conversion buffer at this level */
+	offset = buffer->len;
 
-			putJsonbValueConversion(cstate, val, WJB_BEGIN_OBJECT, nestlevel);
-			for (i = 0; i < val->val.object.nPairs; i++)
-			{
-				putJsonbValueConversion(cstate, &val->val.object.pairs[i].key,
-										WJB_KEY, nestlevel);
-
-				if (IsAJsonbScalar(&val->val.object.pairs[i].value) ||
-					val->val.object.pairs[i].value.type == jbvBinary)
-					putJsonbValueConversion(cstate,
-											&val->val.object.pairs[i].value,
-											WJB_VALUE, nestlevel);
-				else
-					walkJsonbValueConversion(&val->val.object.pairs[i].value,
-											 cstate, nestlevel + 1);
-			}
-			putJsonbValueConversion(cstate, val, WJB_END_OBJECT, nestlevel);
+	addPaddingInt(buffer);
 
-			break;
-		default:
-			elog(ERROR, "unknown type of jsonb container");
+	/*
+	 * Construct the header Jentry, stored in the beginning of the variable-
+	 * length payload.
+	 */
+	header.header = val->val.array.nElems | JB_FARRAY;
+	if (val->val.array.rawScalar)
+	{
+		Assert(val->val.array.nElems == 1);
+		Assert(level == 0);
+		header.header |= JB_FSCALAR;
 	}
-}
-
-/*
- * walkJsonbValueConversion() worker.  Add padding sufficient to int-align our
- * access to conversion buffer.
- */
-static inline
-short
-addPaddingInt(convertState *cstate)
-{
-	short		padlen,
-				p;
 
-	padlen = INTALIGN(cstate->ptr - VARDATA(cstate->buffer)) -
-		(cstate->ptr - VARDATA(cstate->buffer));
+	appendBinaryStringInfo(buffer, (char *) &header, sizeof(uint32));
+	/* reserve space for the JEntries of the elements. */
+	metaoffset = reserveStringInfo(buffer, sizeof(JEntry) * val->val.array.nElems);
 
-	for (p = padlen; p > 0; p--)
+	totallen = 0;
+	for (i = 0; i < val->val.array.nElems; i++)
 	{
-		*cstate->ptr = '\0';
-		cstate->ptr++;
+		JsonbValue *elem = &val->val.array.elems[i];
+		int len;
+		JEntry meta;
+
+		walkJsonbValueConversion(elem, buffer, &meta, level + 1);
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
+
+		if (totallen > JENTRY_POSMASK)
+			ereport(ERROR,
+					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+					 errmsg("total size of jsonb array elements exceeds the maximum of %u bytes",
+							JENTRY_POSMASK)));
+
+		if (i == 0)
+			meta.header |= JENTRY_ISFIRST;
+		else
+			meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * i], &meta, sizeof(JEntry));
 	}
 
-	return padlen;
+	totallen = buffer->len - offset;
+
+	/* Initialize the header of this node, in the container's JEntry array */
+	pheader->header = JENTRY_ISNEST | totallen;
 }
 
-/*
- * walkJsonbValueConversion() worker.
- *
- * As part of the process of converting an arbitrary JsonbValue to a Jsonb,
- * copy over an arbitrary individual JsonbValue.  This function may copy any
- * type of value, even containers (Objects/arrays).  However, it is not
- * responsible for recursive aspects of walking the tree (so only top-level
- * Object/array details are handled).
- *
- * No details about their keys/values/elements are handled recursively -
- * rather, the function is called as required for the start of an Object/Array,
- * and the end (i.e.  there is one call per sequential processing WJB_* token).
- */
 static void
-putJsonbValueConversion(convertState *cstate, JsonbValue *val, uint32 flags,
-						uint32 level)
+walkJsonbObjectConversion(JsonbValue *val, StringInfo buffer, JEntry *pheader, int level)
 {
-	if (level == cstate->levelSz)
-	{
-		cstate->levelSz *= 2;
-		cstate->allState = repalloc(cstate->allState,
-									sizeof(convertLevel) * cstate->levelSz);
-	}
+	uint32		header;
+	int			offset;
+	int			metaoffset;
+	int			i;
+	int			totallen;
 
-	cstate->contPtr = cstate->allState + level;
+	/* Initialize pointer into conversion buffer at this level */
+	offset = buffer->len;
 
-	if (flags & (WJB_BEGIN_ARRAY | WJB_BEGIN_OBJECT))
-	{
-		Assert(((flags & WJB_BEGIN_ARRAY) && val->type == jbvArray) ||
-			   ((flags & WJB_BEGIN_OBJECT) && val->type == jbvObject));
+	addPaddingInt(buffer);
 
-		/* Initialize pointer into conversion buffer at this level */
-		cstate->contPtr->begin = cstate->ptr;
+	/* Initialize header */
+	header = val->val.object.nPairs | JB_FOBJECT;
+	appendBinaryStringInfo(buffer, (char *) &header, sizeof(uint32));
 
-		addPaddingInt(cstate);
+	/* reserve space for the JEntries of the keys and values */
+	metaoffset = reserveStringInfo(buffer, sizeof(JEntry) * val->val.object.nPairs * 2);
 
-		/* Initialize everything else at this level */
-		cstate->contPtr->header = (uint32 *) cstate->ptr;
-		/* Advance past header */
-		cstate->ptr += sizeof(uint32);
-		cstate->contPtr->meta = (JEntry *) cstate->ptr;
-		cstate->contPtr->i = 0;
+	totallen = 0;
+	for (i = 0; i < val->val.object.nPairs; i++)
+	{
+		JsonbPair *pair = &val->val.object.pairs[i];
+		int len;
+		JEntry meta;
 
-		if (val->type == jbvArray)
-		{
-			*cstate->contPtr->header = val->val.array.nElems | JB_FARRAY;
-			cstate->ptr += sizeof(JEntry) * val->val.array.nElems;
+		/* put key */
+		putScalarConversion(buffer, &pair->key, &meta);
 
-			if (val->val.array.rawScalar)
-			{
-				Assert(val->val.array.nElems == 1);
-				Assert(level == 0);
-				*cstate->contPtr->header |= JB_FSCALAR;
-			}
-		}
-		else
-		{
-			*cstate->contPtr->header = val->val.object.nPairs | JB_FOBJECT;
-			cstate->ptr += sizeof(JEntry) * val->val.object.nPairs * 2;
-		}
-	}
-	else if (flags & WJB_ELEM)
-	{
-		putScalarConversion(cstate, val, level, cstate->contPtr->i);
-		cstate->contPtr->i++;
-	}
-	else if (flags & WJB_KEY)
-	{
-		Assert(val->type == jbvString);
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
 
-		putScalarConversion(cstate, val, level, cstate->contPtr->i * 2);
-	}
-	else if (flags & WJB_VALUE)
-	{
-		putScalarConversion(cstate, val, level, cstate->contPtr->i * 2 + 1);
-		cstate->contPtr->i++;
-	}
-	else if (flags & (WJB_END_ARRAY | WJB_END_OBJECT))
-	{
-		convertLevel *prevPtr;	/* Prev container pointer */
-		uint32		len,
-					i;
+		if (totallen > JENTRY_POSMASK)
+			ereport(ERROR,
+					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+					 errmsg("total size of jsonb array elements exceeds the maximum of %u bytes",
+							JENTRY_POSMASK)));
 
-		Assert(((flags & WJB_END_ARRAY) && val->type == jbvArray) ||
-			   ((flags & WJB_END_OBJECT) && val->type == jbvObject));
+		if (i == 0)
+			meta.header |= JENTRY_ISFIRST;
+		else
+			meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * (i * 2)], &meta, sizeof(JEntry));
 
-		if (level == 0)
-			return;
+		walkJsonbValueConversion(&pair->value, buffer, &meta, level);
+		len = meta.header & JENTRY_POSMASK;
+		totallen += len;
 
-		len = cstate->ptr - (char *) cstate->contPtr->begin;
+		if (totallen > JENTRY_POSMASK)
+			ereport(ERROR,
+					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+					 errmsg("total size of jsonb array elements exceeds the maximum of %u bytes",
+							JENTRY_POSMASK)));
 
-		prevPtr = cstate->contPtr - 1;
+		meta.header = (meta.header & ~JENTRY_POSMASK) | totallen;
+		memcpy(&buffer->data[metaoffset + sizeof(JEntry) * (i * 2 + 1)], &meta, sizeof(JEntry));
+	}
 
-		if (*prevPtr->header & JB_FARRAY)
-		{
-			i = prevPtr->i;
+	totallen = buffer->len - offset;
 
-			prevPtr->meta[i].header = JENTRY_ISNEST;
+	pheader->header = JENTRY_ISNEST | totallen;
+}
 
-			if (i == 0)
-				prevPtr->meta[0].header |= JENTRY_ISFIRST | len;
-			else
-				prevPtr->meta[i].header |=
-					(prevPtr->meta[i - 1].header & JENTRY_POSMASK) + len;
-		}
-		else if (*prevPtr->header & JB_FOBJECT)
-		{
-			i = 2 * prevPtr->i + 1;		/* Value, not key */
+/*
+ * Append padding, so that the length of the StringInfo is int-aligned.
+ * Returns the number of padding bytes appended.
+ */
+static inline
+short
+addPaddingInt(StringInfo buffer)
+{
+	short		padlen,
+				p;
 
-			prevPtr->meta[i].header = JENTRY_ISNEST;
+	padlen = INTALIGN(buffer->len) - buffer->len;
 
-			prevPtr->meta[i].header |=
-				(prevPtr->meta[i - 1].header & JENTRY_POSMASK) + len;
-		}
-		else
-		{
-			elog(ERROR, "invalid jsonb container type");
-		}
+	for (p = 0; p < padlen; p++)
+		appendStringInfoChar(buffer, '\0');
 
-		Assert(cstate->ptr - cstate->contPtr->begin <= val->estSize);
-		prevPtr->i++;
-	}
-	else
-	{
-		elog(ERROR, "unknown flag encountered during jsonb tree walk");
-	}
+	return padlen;
 }
 
 /*
@@ -1456,84 +1375,59 @@ putJsonbValueConversion(convertState *cstate, JsonbValue *val, uint32 flags,
  * This is a worker function for putJsonbValueConversion() (itself a worker for
  * walkJsonbValueConversion()).  It handles the details with regard to Jentry
  * metadata peculiar to each scalar type.
+ *
+ * It is the callers responsibility to shift the offset if this is stored
+ * in an array or object.
  */
 static void
-putScalarConversion(convertState *cstate, JsonbValue *scalarVal, uint32 level,
-					uint32 i)
+putScalarConversion(StringInfo buffer, JsonbValue *scalarVal, JEntry *header)
 {
 	int			numlen;
 	short		padlen;
 
-	cstate->contPtr = cstate->allState + level;
-
-	if (i == 0)
-		cstate->contPtr->meta[0].header = JENTRY_ISFIRST;
-	else
-		cstate->contPtr->meta[i].header = 0;
-
 	switch (scalarVal->type)
 	{
 		case jbvNull:
-			cstate->contPtr->meta[i].header |= JENTRY_ISNULL;
-
-			if (i > 0)
-				cstate->contPtr->meta[i].header |=
-					cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK;
+			header->header = JENTRY_ISNULL;
 			break;
+
 		case jbvString:
-			memcpy(cstate->ptr, scalarVal->val.string.val, scalarVal->val.string.len);
-			cstate->ptr += scalarVal->val.string.len;
+			appendBinaryStringInfo(buffer, scalarVal->val.string.val, scalarVal->val.string.len);
 
-			if (i == 0)
-				cstate->contPtr->meta[0].header |= scalarVal->val.string.len;
-			else
-				cstate->contPtr->meta[i].header |=
-					(cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK) +
-					scalarVal->val.string.len;
+			header->header = scalarVal->val.string.len;
 			break;
+
 		case jbvNumeric:
 			numlen = VARSIZE_ANY(scalarVal->val.numeric);
-			padlen = addPaddingInt(cstate);
+			padlen = addPaddingInt(buffer);
 
-			memcpy(cstate->ptr, scalarVal->val.numeric, numlen);
-			cstate->ptr += numlen;
+			appendBinaryStringInfo(buffer, (char *) scalarVal->val.numeric, numlen);
 
-			cstate->contPtr->meta[i].header |= JENTRY_ISNUMERIC;
-			if (i == 0)
-				cstate->contPtr->meta[0].header |= padlen + numlen;
-			else
-				cstate->contPtr->meta[i].header |=
-					(cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK)
-					+ padlen + numlen;
+			header->header = JENTRY_ISNUMERIC | (padlen + numlen);
 			break;
+
 		case jbvBool:
-			cstate->contPtr->meta[i].header |= (scalarVal->val.boolean) ?
+			header->header = (scalarVal->val.boolean) ?
 				JENTRY_ISTRUE : JENTRY_ISFALSE;
-
-			if (i > 0)
-				cstate->contPtr->meta[i].header |=
-					cstate->contPtr->meta[i - 1].header & JENTRY_POSMASK;
 			break;
+
 		default:
 			elog(ERROR, "invalid jsonb scalar type");
 	}
 }
 
 /*
- * Given superheader pointer into buffer, initialize iterator.  Must be a
- * container type.
+ * Initialize an iterator for iterating all elements in a container.
  */
 static void
-iteratorFromContainerBuf(JsonbIterator *it, JsonbSuperHeader sheader)
+iteratorFromContainer(JsonbIterator *it, JsonbContainer *container)
 {
-	uint32		superheader = *(uint32 *) sheader;
-
-	it->containerType = superheader & (JB_FARRAY | JB_FOBJECT);
-	it->nElems = superheader & JB_CMASK;
-	it->buffer = sheader;
+	it->containerType = container->header & (JB_FARRAY | JB_FOBJECT);
+	it->nElems = container->header & JB_CMASK;
+	it->buffer = (char *) container;
 
 	/* Array starts just after header */
-	it->meta = (JEntry *) (sheader + sizeof(uint32));
+	it->meta = (JEntry *) (container->header + sizeof(uint32));
 	it->state = jbi_start;
 
 	switch (it->containerType)
@@ -1541,7 +1435,7 @@ iteratorFromContainerBuf(JsonbIterator *it, JsonbSuperHeader sheader)
 		case JB_FARRAY:
 			it->dataProper =
 				(char *) it->meta + it->nElems * sizeof(JEntry);
-			it->isScalar = (superheader & JB_FSCALAR) != 0;
+			it->isScalar = (container->header & JB_FSCALAR) != 0;
 			/* This is either a "raw scalar", or an array */
 			Assert(!it->isScalar || it->nElems == 1);
 			break;
@@ -1584,7 +1478,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 	if (JBE_ISNULL(*ent))
 	{
 		val->type = jbvNull;
-		val->estSize = sizeof(JEntry);
 
 		return false;
 	}
@@ -1593,7 +1486,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvString;
 		val->val.string.val = (*it)->dataProper + JBE_OFF(*ent);
 		val->val.string.len = JBE_LEN(*ent);
-		val->estSize = sizeof(JEntry) + val->val.string.len;
 
 		return false;
 	}
@@ -1602,15 +1494,12 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvNumeric;
 		val->val.numeric = (Numeric) ((*it)->dataProper + INTALIGN(JBE_OFF(*ent)));
 
-		val->estSize = 2 * sizeof(JEntry) + VARSIZE_ANY(val->val.numeric);
-
 		return false;
 	}
 	else if (JBE_ISBOOL(*ent))
 	{
 		val->type = jbvBool;
 		val->val.boolean = JBE_ISBOOL_TRUE(*ent) != 0;
-		val->estSize = sizeof(JEntry);
 
 		return false;
 	}
@@ -1619,7 +1508,6 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		val->type = jbvBinary;
 		val->val.binary.data = (*it)->dataProper + INTALIGN(JBE_OFF(*ent));
 		val->val.binary.len = JBE_LEN(*ent) - (INTALIGN(JBE_OFF(*ent)) - JBE_OFF(*ent));
-		val->estSize = val->val.binary.len + 2 * sizeof(JEntry);
 
 		return false;
 	}
@@ -1633,8 +1521,8 @@ formIterIsContainer(JsonbIterator **it, JsonbValue *val, JEntry *ent,
 		 */
 		JsonbIterator *child = palloc(sizeof(JsonbIterator));
 
-		iteratorFromContainerBuf(child,
-								 (*it)->dataProper + INTALIGN(JBE_OFF(*ent)));
+		iteratorFromContainer(child,
+							  (JsonbContainer *) ((*it)->dataProper + INTALIGN(JBE_OFF(*ent))));
 
 		child->parent = *it;
 		*it = child;
@@ -1694,8 +1582,6 @@ appendKey(JsonbParseState *pstate, JsonbValue *string)
 
 	object->val.object.pairs[object->val.object.nPairs].key = *string;
 	object->val.object.pairs[object->val.object.nPairs].order = object->val.object.nPairs;
-
-	object->estSize += string->estSize;
 }
 
 /*
@@ -1710,7 +1596,6 @@ appendValue(JsonbParseState *pstate, JsonbValue *scalarVal)
 	Assert(object->type == jbvObject);
 
 	object->val.object.pairs[object->val.object.nPairs++].value = *scalarVal;
-	object->estSize += scalarVal->estSize;
 }
 
 /*
@@ -1737,7 +1622,6 @@ appendElement(JsonbParseState *pstate, JsonbValue *scalarVal)
 	}
 
 	array->val.array.elems[array->val.array.nElems++] = *scalarVal;
-	array->estSize += scalarVal->estSize;
 }
 
 /*
@@ -1832,11 +1716,7 @@ uniqueifyJsonbObject(JsonbValue *object)
 		while (ptr - object->val.object.pairs < object->val.object.nPairs)
 		{
 			/* Avoid copying over duplicate */
-			if (lengthCompareJsonbStringValue(ptr, res, NULL) == 0)
-			{
-				object->estSize -= ptr->key.estSize + ptr->value.estSize;
-			}
-			else
+			if (lengthCompareJsonbStringValue(ptr, res, NULL) != 0)
 			{
 				res++;
 				if (ptr != res)
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index 6b1ce9b..ac393ce 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -106,7 +106,7 @@ static inline Datum populate_recordset_worker(FunctionCallInfo fcinfo,
 						  bool have_record_arg);
 
 /* Worker that takes care of common setup for us */
-static JsonbValue *findJsonbValueFromSuperHeaderLen(JsonbSuperHeader sheader,
+static JsonbValue *findJsonbValueFromContainerLen(JsonbContainer *container,
 								 uint32 flags,
 								 char *key,
 								 uint32 keylen);
@@ -286,7 +286,7 @@ jsonb_object_keys(PG_FUNCTION_ARGS)
 		state->sent_count = 0;
 		state->result = palloc(state->result_size * sizeof(char *));
 
-		it = JsonbIteratorInit(VARDATA_ANY(jb));
+		it = JsonbIteratorInit(&jb->root);
 
 		while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 		{
@@ -484,7 +484,7 @@ jsonb_object_field(PG_FUNCTION_ARGS)
 
 	Assert(JB_ROOT_IS_OBJECT(jb));
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -545,7 +545,7 @@ jsonb_object_field_text(PG_FUNCTION_ARGS)
 
 	Assert(JB_ROOT_IS_OBJECT(jb));
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -580,7 +580,7 @@ jsonb_object_field_text(PG_FUNCTION_ARGS)
 					StringInfo	jtext = makeStringInfo();
 					Jsonb	   *tjb = JsonbValueToJsonb(&v);
 
-					(void) JsonbToCString(jtext, VARDATA(tjb), -1);
+					(void) JsonbToCString(jtext, &tjb->root , -1);
 					result = cstring_to_text_with_len(jtext->data, jtext->len);
 				}
 				PG_RETURN_TEXT_P(result);
@@ -628,7 +628,7 @@ jsonb_array_element(PG_FUNCTION_ARGS)
 
 	Assert(JB_ROOT_IS_ARRAY(jb));
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -682,7 +682,7 @@ jsonb_array_element_text(PG_FUNCTION_ARGS)
 
 	Assert(JB_ROOT_IS_ARRAY(jb));
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -711,7 +711,7 @@ jsonb_array_element_text(PG_FUNCTION_ARGS)
 					StringInfo	jtext = makeStringInfo();
 					Jsonb	   *tjb = JsonbValueToJsonb(&v);
 
-					(void) JsonbToCString(jtext, VARDATA(tjb), -1);
+					(void) JsonbToCString(jtext, &tjb->root, -1);
 					result = cstring_to_text_with_len(jtext->data, jtext->len);
 				}
 				PG_RETURN_TEXT_P(result);
@@ -1155,7 +1155,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
 				have_array = false;
 	JsonbValue *jbvp = NULL;
 	JsonbValue	tv;
-	JsonbSuperHeader superHeader;
+	JsonbContainer *container;
 
 	if (array_contains_nulls(path))
 		ereport(ERROR,
@@ -1170,15 +1170,15 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
 	else if (JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb))
 		have_array = true;
 
-	superHeader = (JsonbSuperHeader) VARDATA(jb);
+	container = &jb->root;
 
 	for (i = 0; i < npath; i++)
 	{
 		if (have_object)
 		{
-			jbvp = findJsonbValueFromSuperHeaderLen(superHeader,
-													JB_FOBJECT,
-													VARDATA_ANY(pathtext[i]),
+			jbvp = findJsonbValueFromContainerLen(container,
+												  JB_FOBJECT,
+												  VARDATA_ANY(pathtext[i]),
 											 VARSIZE_ANY_EXHDR(pathtext[i]));
 		}
 		else if (have_array)
@@ -1192,7 +1192,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
 			if (*endptr != '\0' || lindex > INT_MAX || lindex < 0)
 				PG_RETURN_NULL();
 			index = (uint32) lindex;
-			jbvp = getIthJsonbValueFromSuperHeader(superHeader, index);
+			jbvp = getIthJsonbValueFromContainer(container, index);
 		}
 		else
 		{
@@ -1210,11 +1210,11 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
 
 		if (jbvp->type == jbvBinary)
 		{
-			JsonbIterator *it = JsonbIteratorInit(jbvp->val.binary.data);
+			JsonbIterator *it = JsonbIteratorInit((JsonbContainer *) jbvp->val.binary.data);
 			int			r;
 
 			r = JsonbIteratorNext(&it, &tv, true);
-			superHeader = (JsonbSuperHeader) jbvp->val.binary.data;
+			container = (JsonbContainer *) jbvp->val.binary.data;
 			have_object = r == WJB_BEGIN_OBJECT;
 			have_array = r == WJB_BEGIN_ARRAY;
 		}
@@ -1238,7 +1238,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
 	if (as_text)
 	{
 		PG_RETURN_TEXT_P(cstring_to_text(JsonbToCString(NULL,
-														VARDATA(res),
+														&res->root,
 														VARSIZE(res))));
 	}
 	else
@@ -1428,7 +1428,7 @@ each_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 									ALLOCSET_DEFAULT_MAXSIZE);
 
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -1477,7 +1477,7 @@ each_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 						StringInfo	jtext = makeStringInfo();
 						Jsonb	   *jb = JsonbValueToJsonb(&v);
 
-						(void) JsonbToCString(jtext, VARDATA(jb), 2 * v.estSize);
+						(void) JsonbToCString(jtext, &jb->root, 0);
 						sv = cstring_to_text_with_len(jtext->data, jtext->len);
 					}
 
@@ -1753,7 +1753,7 @@ elements_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 									ALLOCSET_DEFAULT_MAXSIZE);
 
 
-	it = JsonbIteratorInit(VARDATA_ANY(jb));
+	it = JsonbIteratorInit(&jb->root);
 
 	while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 	{
@@ -1797,7 +1797,7 @@ elements_worker_jsonb(FunctionCallInfo fcinfo, bool as_text)
 						StringInfo	jtext = makeStringInfo();
 						Jsonb	   *jb = JsonbValueToJsonb(&v);
 
-						(void) JsonbToCString(jtext, VARDATA(jb), 2 * v.estSize);
+						(void) JsonbToCString(jtext, &jb->root, 0);
 						sv = cstring_to_text_with_len(jtext->data, jtext->len);
 					}
 
@@ -2219,8 +2219,8 @@ populate_record_worker(FunctionCallInfo fcinfo, bool have_record_arg)
 		{
 			char	   *key = NameStr(tupdesc->attrs[i]->attname);
 
-			v = findJsonbValueFromSuperHeaderLen(VARDATA(jb), JB_FOBJECT, key,
-												 strlen(key));
+			v = findJsonbValueFromContainerLen(&jb->root, JB_FOBJECT, key,
+											   strlen(key));
 		}
 
 		/*
@@ -2282,7 +2282,7 @@ populate_record_worker(FunctionCallInfo fcinfo, bool have_record_arg)
 							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 							 errmsg("cannot populate with a nested object unless use_json_as_text is true")));
 				else if (v->type == jbvBinary)
-					s = JsonbToCString(NULL, v->val.binary.data, v->val.binary.len);
+					s = JsonbToCString(NULL, (JsonbContainer *) v->val.binary.data, v->val.binary.len);
 				else
 					elog(ERROR, "invalid jsonb type");
 			}
@@ -2529,8 +2529,8 @@ make_row_from_rec_and_jsonb(Jsonb *element, PopulateRecordsetState *state)
 
 		key = NameStr(tupdesc->attrs[i]->attname);
 
-		v = findJsonbValueFromSuperHeaderLen(VARDATA(element), JB_FOBJECT,
-											 key, strlen(key));
+		v = findJsonbValueFromContainerLen(&element->root, JB_FOBJECT,
+										   key, strlen(key));
 
 		/*
 		 * We can't just skip here if the key wasn't found since we might have
@@ -2582,7 +2582,7 @@ make_row_from_rec_and_jsonb(Jsonb *element, PopulateRecordsetState *state)
 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 						 errmsg("cannot populate with a nested object unless use_json_as_text is true")));
 			else if (v->type == jbvBinary)
-				s = JsonbToCString(NULL, v->val.binary.data, v->val.binary.len);
+				s = JsonbToCString(NULL, (JsonbContainer *) v->val.binary.data, v->val.binary.len);
 			else
 				elog(ERROR, "invalid jsonb type");
 
@@ -2750,7 +2750,7 @@ populate_recordset_worker(FunctionCallInfo fcinfo, bool have_record_arg)
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 			   errmsg("cannot call jsonb_populate_recordset on non-array")));
 
-		it = JsonbIteratorInit(VARDATA_ANY(jb));
+		it = JsonbIteratorInit(&jb->root);
 
 		while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
 		{
@@ -3019,11 +3019,11 @@ populate_recordset_object_field_end(void *state, char *fname, bool isnull)
 }
 
 /*
- * findJsonbValueFromSuperHeader() wrapper that sets up JsonbValue key string.
+ * findJsonbValueFromContainer() wrapper that sets up JsonbValue key string.
  */
 static JsonbValue *
-findJsonbValueFromSuperHeaderLen(JsonbSuperHeader sheader, uint32 flags,
-								 char *key, uint32 keylen)
+findJsonbValueFromContainerLen(JsonbContainer *container, uint32 flags,
+							   char *key, uint32 keylen)
 {
 	JsonbValue	k;
 
@@ -3031,5 +3031,5 @@ findJsonbValueFromSuperHeaderLen(JsonbSuperHeader sheader, uint32 flags,
 	k.val.string.val = key;
 	k.val.string.len = keylen;
 
-	return findJsonbValueFromSuperHeader(sheader, flags, NULL, &k);
+	return findJsonbValueFromContainer(container, flags, NULL, &k);
 }
diff --git a/src/include/utils/jsonb.h b/src/include/utils/jsonb.h
index dea64ad..14ac2ee 100644
--- a/src/include/utils/jsonb.h
+++ b/src/include/utils/jsonb.h
@@ -16,17 +16,6 @@
 #include "utils/array.h"
 #include "utils/numeric.h"
 
-/*
- * JB_CMASK is used to extract count of items
- *
- * It's not possible to get more than 2^28 items into an Jsonb.
- */
-#define JB_CMASK				0x0FFFFFFF
-
-#define JB_FSCALAR				0x10000000
-#define JB_FOBJECT				0x20000000
-#define JB_FARRAY				0x40000000
-
 /* Get information on varlena Jsonb */
 #define JB_ROOT_COUNT(jbp_)		( *(uint32*) VARDATA(jbp_) & JB_CMASK)
 #define JB_ROOT_IS_SCALAR(jbp_) ( *(uint32*) VARDATA(jbp_) & JB_FSCALAR)
@@ -98,7 +87,6 @@
 
 typedef struct JsonbPair JsonbPair;
 typedef struct JsonbValue JsonbValue;
-typedef char *JsonbSuperHeader;
 
 /*
  * Jsonbs are varlena objects, so must meet the varlena convention that the
@@ -109,35 +97,87 @@ typedef char *JsonbSuperHeader;
  * representation.  Often, JsonbValues are just shims through which a Jsonb
  * buffer is accessed, but they can also be deep copied and passed around.
  *
- * We have an abstraction called a "superheader".  This is a pointer that
- * conventionally points to the first item after our 4-byte uncompressed
- * varlena header, from which we can read flags using bitwise operations.
+ * Jsonb is a tree structure. Each node in the tree consists of a JEntry
+ * header, and a variable-length content.  The JEntry header indicates what
+ * kind of a node it is, e.g. a string or an array (see JENTRY_IS* macros),
+ * and the offset and length of its variable-length portion within the
+ * container.
+ *
+ * The header and the content of a node are not stored physically together.
+ * Instead, the array or object containing the node has an array that holds
+ * the JEntry headers of all the child nodes, followed by their variable-length
+ * portions.
  *
- * Frequently, we pass a superheader reference to a function, and it doesn't
- * matter if it points to just after the start of a Jsonb, or to a temp buffer.
+ * The root node is an exception; it has no parent array or object that could
+ * hold its JEntry. Hence, there is no Jentry header for the root node.
+ * It is implicitly known that the the root node must be an array or an
+ * object. The content of both an array and an object begins with a uint32
+ * header field containing the number of elements, and an JB_FOBJECT or
+ * JB_FARRAY flag. By peeking into that header, we can determine which it is.
+ * When a naked scalar value needs to be stored as a Jsonb value, what we
+ * actually store is an array with one element, with the flags in the array's
+ * header field set to JB_FSCALAR | JB_FARRAY.
+ *
+ * The variable-length data of a container node, an array or an object,
+ * begins with a uint32 header. It contains the number of child nodes,
+ * and a flag indicating if it's an array or an object (JB_* macros).
+ * An array has one child node for each element, and an object has two
+ * child nodes for each  key-value pair. After the uint32 header, there is
+ * an array of JEntry structs, one for each child node, followed by the
+ * variable-length data of each child.
+ *
+ * To encode the length and offset of the variable-length portion of each
+ * node in a compact way, the JEntry stores only the end offset within the
+ * variable-length portion of the container node. For the first JEntry in the
+ * container's JEntry array, that equals to the length of the node data. For
+ * convenience, the JENTRY_ISFIRST flag is set. The begin offset and length
+ * of the rest of the entries can be calculated using the end offset of the
+ * previous JEntry in the array.
+ *
+ *
+ * Alignment
+ * ---------
+ *
+ * Overall, the Jsonb struct requires 4-bytes alignment. Within the struct,
+ * the variable-length portion of some node types is aligned to a 4-byte
+ * boundary, while others are not. When alignment is needed, the padding is
+ * in the beginning of the node that requires it. For example, if a numeric
+ * node is stored after a string node, so that the numeric node begins at
+ * offset 3, the variable-length portion of the numeric node will begin with
+ * one padding byte.
+ *
+ * Frequently, we pass a JsonbContainer reference to a function, and it doesn't
+ * matter if it points to Jsonb->root, or to a temp buffer.
  */
+
 typedef struct
 {
-	int32		vl_len_;		/* varlena header (do not touch directly!) */
-	uint32		superheader;
-	/* (array of JEntry follows, size determined using uint32 superheader) */
-} Jsonb;
+	uint32		header;			/* See JENTRY_* flags */
+} JEntry;
 
 /*
- * JEntry: there is one of these for each key _and_ value for objects.  Arrays
- * have one per element.
- *
- * The position offset points to the _end_ so that we can get the length by
- * subtraction from the previous entry.  The JENTRY_ISFIRST flag indicates if
- * there is a previous entry.
+ * A jsonb array or object node.
+ * 
+ * An array has one child for each element. An object has two children for
+ * each key/value pair. 
  */
+typedef struct JsonbContainer
+{
+	uint32		header;			/* number of elements, and flags (JB_* below) */
+	JEntry		children[1];	/* variable length */
+} JsonbContainer;
+
 typedef struct
 {
-	uint32		header;			/* Shares some flags with superheader */
-} JEntry;
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	JsonbContainer root;
+} Jsonb;
 
-#define IsAJsonbScalar(jsonbval)	((jsonbval)->type >= jbvNull && \
-									 (jsonbval)->type <= jbvBool)
+#define JB_CMASK				0x0FFFFFFF
+
+#define JB_FSCALAR				0x10000000
+#define JB_FOBJECT				0x20000000
+#define JB_FARRAY				0x40000000
 
 /*
  * JsonbValue:	In-memory representation of Jsonb.  This is a convenient
@@ -161,8 +201,6 @@ struct JsonbValue
 		jbvBinary
 	}			type;			/* Influences sort order */
 
-	int			estSize;		/* Estimated size of node (including subnodes) */
-
 	union
 	{
 		Numeric numeric;
@@ -194,6 +232,9 @@ struct JsonbValue
 	}			val;
 };
 
+#define IsAJsonbScalar(jsonbval)	((jsonbval)->type >= jbvNull && \
+									 (jsonbval)->type <= jbvBool)
+
 /*
  * Pair within an Object.
  *
@@ -294,17 +335,16 @@ extern Datum gin_consistent_jsonb_hash(PG_FUNCTION_ARGS);
 extern Datum gin_triconsistent_jsonb_hash(PG_FUNCTION_ARGS);
 
 /* Support functions */
-extern int compareJsonbSuperHeaderValue(JsonbSuperHeader a,
-							 JsonbSuperHeader b);
-extern JsonbValue *findJsonbValueFromSuperHeader(JsonbSuperHeader sheader,
+extern int compareJsonbContainers(JsonbContainer *a, JsonbContainer *b);
+extern JsonbValue *findJsonbValueFromContainer(JsonbContainer *sheader,
 							  uint32 flags,
 							  uint32 *lowbound,
 							  JsonbValue *key);
-extern JsonbValue *getIthJsonbValueFromSuperHeader(JsonbSuperHeader sheader,
+extern JsonbValue *getIthJsonbValueFromContainer(JsonbContainer *sheader,
 								uint32 i);
 extern JsonbValue *pushJsonbValue(JsonbParseState **pstate, int seq,
 			   JsonbValue *scalarVal);
-extern JsonbIterator *JsonbIteratorInit(JsonbSuperHeader buffer);
+extern JsonbIterator *JsonbIteratorInit(JsonbContainer *container);
 extern int JsonbIteratorNext(JsonbIterator **it, JsonbValue *val,
 				  bool skipNested);
 extern Jsonb *JsonbValueToJsonb(JsonbValue *val);
@@ -314,7 +354,7 @@ extern JsonbValue *arrayToJsonbSortedArray(ArrayType *a);
 extern void JsonbHashScalarValue(const JsonbValue *scalarVal, uint32 *hash);
 
 /* jsonb.c support function */
-extern char *JsonbToCString(StringInfo out, JsonbSuperHeader in,
+extern char *JsonbToCString(StringInfo out, JsonbContainer *in,
 			   int estimated_len);
 
 #endif   /* __JSONB_H__ */