Add jsonb <=> bytea casts

Author: Nikita Glukhov

src/backend/utils/adt/jsonb.c

@@ -238,6 +238,23 @@ jsonb_typeof(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(cstring_to_text(result));
 }
 
+/*
+ * jsonb_from_bytea -- bytea to jsonb conversion with validation
+ */
+Datum
+jsonb_from_bytea(PG_FUNCTION_ARGS)
+{
+	bytea	   *ba = PG_GETARG_BYTEA_P(0);
+	Jsonb	   *jb = (Jsonb *) ba;
+
+	if (!JsonbValidate(VARDATA(jb), VARSIZE(jb) - VARHDRSZ))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+				 errmsg("incorrect jsonb binary data format")));
+
+	PG_RETURN_JSONB_P(jb);
+}
+
 /*
  * jsonb_from_cstring
  *

src/backend/utils/adt/jsonb_util.c

@@ -1892,3 +1892,133 @@ uniqueifyJsonbObject(JsonbValue *object)
 		object->val.object.nPairs = res + 1 - object->val.object.pairs;
 	}
 }
+
+bool
+JsonbValidate(const void *data, uint32 size)
+{
+	const JsonbContainer *jbc = data;
+	const JEntry *entries;
+	const char *base;
+	uint32		header;
+	uint32		nentries;
+	uint32		offset;
+	uint32		i;
+	uint32		nkeys = 0;
+
+	check_stack_depth();
+
+	/* check header size */
+	if (size < offsetof(JsonbContainer, children))
+		return false;
+
+	size -= offsetof(JsonbContainer, children);
+
+	/* read header */
+	header = jbc->header;
+	entries = &jbc->children[0];
+	nentries = header & JB_CMASK;
+
+	switch (header & ~JB_CMASK)
+	{
+		case JB_FOBJECT:
+			nkeys = nentries;
+			nentries *= 2;
+			break;
+
+		case JB_FARRAY | JB_FSCALAR:
+			if (nentries != 1)
+				/* scalar pseudo-array must have one element */
+				return false;
+			break;
+
+		case JB_FARRAY:
+			break;
+
+		default:
+			/* invalid container type */
+			return false;
+	}
+
+	/* check JEntry array size */
+	if (size < sizeof(JEntry) * nentries)
+		return false;
+
+	size -= sizeof(JEntry) * nentries;
+
+	base = (const char *) &entries[nentries];
+
+	for (i = 0, offset = 0; i < nentries; i++)
+	{
+		JEntry		entry = entries[i];
+		uint32		offlen = JBE_OFFLENFLD(entry);
+		uint32		length;
+		uint32		nextOffset;
+
+		if (JBE_HAS_OFF(entry))
+		{
+			nextOffset = offlen;
+			length = nextOffset - offset;
+		}
+		else
+		{
+			length = offlen;
+			nextOffset = offset + length;
+		}
+
+		if (nextOffset < offset || nextOffset > size)
+			return false;
+
+		/* check that object key is string */
+		if (i < nkeys && !JBE_ISSTRING(entry))
+			return false;
+
+		switch (entry & JENTRY_TYPEMASK)
+		{
+			case JENTRY_ISSTRING:
+				break;
+
+			case JENTRY_ISNUMERIC:
+				{
+					uint32		padding = INTALIGN(offset) - offset;
+
+					if (length < padding)
+						return false;
+
+					if (length - padding < sizeof(struct varlena))
+						return false;
+
+					/* TODO JsonValidateNumeric(); */
+					break;
+				}
+
+			case JENTRY_ISBOOL_FALSE:
+			case JENTRY_ISBOOL_TRUE:
+			case JENTRY_ISNULL:
+				if (length)
+					return false;
+
+				break;
+
+			case JENTRY_ISCONTAINER:
+				{
+					uint32		padding = INTALIGN(offset) - offset;
+
+					if (length < padding)
+						return false;
+
+					if (!JsonbValidate(&base[offset + padding],
+									   length - padding))
+						return false;
+
+					break;
+				}
+
+			default:
+				return false;
+		}
+
+		offset = nextOffset;
+	}
+
+	return true;
+}

src/include/catalog/pg_cast.dat

@@ -496,6 +496,13 @@
 { castsource => 'jsonb', casttarget => 'json', castfunc => '0',
   castcontext => 'a', castmethod => 'i' },
 
+# jsonb to/from bytea
+{ castsource => 'jsonb', casttarget => 'bytea', castfunc => '0',
+  castcontext => 'e', castmethod => 'b' },
+{ castsource => 'bytea', casttarget => 'jsonb',
+  castfunc => 'jsonb_from_bytea(bytea)',
+  castcontext => 'e', castmethod => 'f' },
+
 # jsonb to numeric and bool types
 { castsource => 'jsonb', casttarget => 'bool', castfunc => 'bool(jsonb)',
   castcontext => 'e', castmethod => 'f' },

src/include/catalog/pg_proc.dat

@@ -9131,6 +9131,9 @@
 { oid => '6062', descr => 'check jsonb value type',
   proname => 'jsonb_is_valid', prorettype => 'bool',
   proargtypes => 'jsonb text', prosrc => 'jsonb_is_valid' },
+{ oid => '6116', descr => 'bytea to jsonb',
+  proname => 'jsonb_from_bytea', prorettype => 'jsonb', proargtypes => 'bytea',
+  prosrc => 'jsonb_from_bytea' },
 
 { oid => '3478',
   proname => 'jsonb_object_field', prorettype => 'jsonb',

src/include/utils/jsonb.h

@@ -388,6 +388,7 @@ extern bool JsonbDeepContains(JsonbIterator **val,
 extern void JsonbHashScalarValue(const JsonbValue *scalarVal, uint32 *hash);
 extern void JsonbHashScalarValueExtended(const JsonbValue *scalarVal,
 										 uint64 *hash, uint64 seed);
+extern bool JsonbValidate(const void *data, uint32 size);
 
 /* jsonb.c support functions */
 extern char *JsonbToCString(StringInfo out, JsonbContainer *in,

src/test/regress/expected/jsonb.out

@@ -4930,3 +4930,24 @@ select '12345.0000000000000000000000000000000000000000000005'::jsonb::int8;
  12345
 (1 row)
 
+-- test jsonb to/from bytea conversion
+SELECT '{"a": 1, "b": [2, true]}'::jsonb::bytea;
+                                                   bytea                                                    
+------------------------------------------------------------------------------------------------------------
+ \x0200002001000080010000000a000010140000506162000020000000008001000200004008000090000000302000000000800200
+(1 row)
+
+SELECT '{"a": 1, "b": [2, true]}'::jsonb::bytea::jsonb;
+          jsonb           
+--------------------------
+ {"a": 1, "b": [2, true]}
+(1 row)
+
+SELECT 'aaaa'::bytea::jsonb;
+ERROR:  incorrect jsonb binary data format
+SELECT count(*) FROM testjsonb WHERE j::bytea::jsonb <> j;
+ count 
+-------
+     0
+(1 row)
+

src/test/regress/expected/opr_sanity.out

@@ -879,6 +879,9 @@ WHERE c.castfunc = p.oid AND
 -- texttoxml(), which does an XML syntax check.
 -- As of 9.1, this finds the cast from pg_node_tree to text, which we
 -- intentionally do not provide a reverse pathway for.
+-- As of 10.0, this finds the cast from jsonb to bytea, because those are
+-- binary-compatible while the reverse goes through jsonb_from_bytea(),
+-- which does a jsonb structure validation.
 SELECT castsource::regtype, casttarget::regtype, castfunc, castcontext
 FROM pg_cast c
 WHERE c.castmethod = 'b' AND
@@ -898,7 +901,8 @@ WHERE c.castmethod = 'b' AND
  xml               | text              |        0 | a
  xml               | character varying |        0 | a
  xml               | character         |        0 | a
-(10 rows)
+ jsonb             | bytea             |        0 | e
+(11 rows)
 
 -- **************** pg_conversion ****************
 -- Look for illegal values in pg_conversion fields.

src/test/regress/sql/jsonb.sql

@@ -1250,3 +1250,9 @@ select '12345.0000000000000000000000000000000000000000000005'::jsonb::float8;
 select '12345.0000000000000000000000000000000000000000000005'::jsonb::int2;
 select '12345.0000000000000000000000000000000000000000000005'::jsonb::int4;
 select '12345.0000000000000000000000000000000000000000000005'::jsonb::int8;
+
+-- test jsonb to/from bytea conversion
+SELECT '{"a": 1, "b": [2, true]}'::jsonb::bytea;
+SELECT '{"a": 1, "b": [2, true]}'::jsonb::bytea::jsonb;
+SELECT 'aaaa'::bytea::jsonb;
+SELECT count(*) FROM testjsonb WHERE j::bytea::jsonb <> j;

src/test/regress/sql/opr_sanity.sql

@@ -485,6 +485,10 @@ WHERE c.castfunc = p.oid AND
 -- As of 9.1, this finds the cast from pg_node_tree to text, which we
 -- intentionally do not provide a reverse pathway for.
 
+-- As of 10.0, this finds the cast from jsonb to bytea, because those are
+-- binary-compatible while the reverse goes through jsonb_from_bytea(),
+-- which does a jsonb structure validation.
+
 SELECT castsource::regtype, casttarget::regtype, castfunc, castcontext
 FROM pg_cast c
 WHERE c.castmethod = 'b' AND