SQL/JSON: support the IS JSON predicate

This introduces the SQL standard IS JSON predicate. It operates on text and bytea values representing JSON, as well as on the json and jsonb types. Each test has IS and IS NOT variants and supports a WITH UNIQUE KEYS flag. The tests are: IS JSON [VALUE] IS JSON ARRAY IS JSON OBJECT IS JSON SCALAR These should be self-explanatory. The WITH UNIQUE KEYS flag makes these return false when duplicate keys exist in any object within the value, not necessarily directly contained in the outermost object. Author: Nikita Glukhov <[email protected]> Author: Teodor Sigaev <[email protected]> Author: Oleg Bartunov <[email protected]> Author: Alexander Korotkov <[email protected]> Author: Amit Langote <[email protected]> Author: Andrew Dunstan <[email protected]> Reviewers have included (in no particular order) Andres Freund, Alexander Korotkov, Pavel Stehule, Andrew Alsup, Erik Rijkers, Zihong Yu, Himanshu Upadhyaya, Daniel Gustafsson, Justin Pryzby. Discussion: https://postgr.es/m/CAF4Au4w2x-5LTnN_bxky-mq4=WOqsGsxSpENCzHRAzSnEd8+WQ@mail.gmail.com Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/abd9b83b-aa66-f230-3d6d-734817f0995d%40postgresql.org

Author: alvherre

doc/src/sgml/func.sgml

@@ -16005,6 +16005,86 @@ table2-mapping
 </tgroup>
 </table>
 
+<para>
+<xref linkend="functions-sqljson-misc" /> details SQL/JSON
+facilities for testing JSON.
+</para>
+
+<table id="functions-sqljson-misc">
+<title>SQL/JSON Testing Functions</title>
+<tgroup cols="1">
+<thead>
+<row>
+<entry role="func_table_entry"><para role="func_signature">
+Function signature
+</para>
+<para>
+Description
+</para>
+<para>
+Example(s)
+</para></entry>
+</row>
+</thead>
+<tbody>
+<row>
+<entry role="func_table_entry"><para role="func_signature">
+<indexterm><primary>IS JSON</primary></indexterm>
+<replaceable>expression</replaceable> <literal>IS</literal> <optional> <literal>NOT</literal> </optional> <literal>JSON</literal>
+<optional> { <literal>VALUE</literal> | <literal>SCALAR</literal> | <literal>ARRAY</literal> | <literal>OBJECT</literal> } </optional>
+<optional> { <literal>WITH</literal> | <literal>WITHOUT</literal> } <literal>UNIQUE</literal> <optional> <literal>KEYS</literal> </optional> </optional>
+</para>
+<para>
+This predicate tests whether <replaceable>expression</replaceable> can be
+parsed as JSON, possibly of a specified type.
+If <literal>SCALAR</literal> or <literal>ARRAY</literal> or
+<literal>OBJECT</literal> is specified, the
+test is whether or not the JSON is of that particular type. If
+<literal>WITH UNIQUE KEYS</literal> is specified, then any object in the
+<replaceable>expression</replaceable> is also tested to see if it
+has duplicate keys.
+</para>
+<para>
+<programlisting>
+SELECT js,
+js IS JSON "json?",
+js IS JSON SCALAR "scalar?",
+js IS JSON OBJECT "object?",
+js IS JSON ARRAY "array?"
+FROM (VALUES
+('123'), ('"abc"'), ('{"a": "b"}'), ('[1,2]'),('abc')) foo(js);
+js | json? | scalar? | object? | array?
+------------+-------+---------+---------+--------
+123 | t | t | f | f
+"abc" | t | t | f | f
+{"a": "b"} | t | f | t | f
+[1,2] | t | f | f | t
+abc | f | f | f | f
+</programlisting>
+</para>
+<para>
+<programlisting>
+SELECT js,
+js IS JSON OBJECT "object?",
+js IS JSON ARRAY "array?",
+js IS JSON ARRAY WITH UNIQUE KEYS "array w. UK?",
+js IS JSON ARRAY WITHOUT UNIQUE KEYS "array w/o UK?"
+FROM (VALUES ('[{"a":"1"},
+{"b":"2","b":"3"}]')) foo(js);
+-[ RECORD 1 ]-+--------------------
+js | [{"a":"1"}, +
+| {"b":"2","b":"3"}]
+object? | f
+array? | t
+array w. UK? | f
+array w/o UK? | t
+</programlisting>
+</para></entry>
+</row>
+</tbody>
+</tgroup>
+</table>
+
 <para>
 <xref linkend="functions-json-processing-table"/> shows the functions that
 are available for processing <type>json</type> and <type>jsonb</type> values.

src/backend/executor/execExpr.c

@@ -2370,6 +2370,19 @@ ExecInitExprRec(Expr *node, ExprState *state,
 }
 break;
 
+case T_JsonIsPredicate:
+{
+JsonIsPredicate *pred = (JsonIsPredicate *) node;
+
+ExecInitExprRec((Expr *) pred->expr, state, resv, resnull);
+
+scratch.opcode = EEOP_IS_JSON;
+scratch.d.is_json.pred = pred;
+
+ExprEvalPushStep(state, &scratch);
+break;
+}
+
 case T_NullTest:
 {
 NullTest *ntest = (NullTest *) node;

src/backend/executor/execExprInterp.c

@@ -73,6 +73,7 @@
 #include "utils/expandedrecord.h"
 #include "utils/json.h"
 #include "utils/jsonb.h"
+#include "utils/jsonfuncs.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/timestamp.h"
@@ -477,6 +478,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 &&CASE_EEOP_HASHED_SCALARARRAYOP,
 &&CASE_EEOP_XMLEXPR,
 &&CASE_EEOP_JSON_CONSTRUCTOR,
+&&CASE_EEOP_IS_JSON,
 &&CASE_EEOP_AGGREF,
 &&CASE_EEOP_GROUPING_FUNC,
 &&CASE_EEOP_WINDOW_FUNC,
@@ -1521,6 +1523,14 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
 EEO_NEXT();
 }
 
+EEO_CASE(EEOP_IS_JSON)
+{
+/* too complex for an inline implementation */
+ExecEvalJsonIsPredicate(state, op);
+
+EEO_NEXT();
+}
+
 EEO_CASE(EEOP_AGGREF)
 {
 /*
@@ -3921,6 +3931,95 @@ ExecEvalJsonConstructor(ExprState *state, ExprEvalStep *op,
 *op->resnull = isnull;
 }
 
+/*
+* Evaluate a IS JSON predicate.
+*/
+void
+ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
+{
+JsonIsPredicate *pred = op->d.is_json.pred;
+Datum js = *op->resvalue;
+Oid exprtype;
+bool res;
+
+if (*op->resnull)
+{
+*op->resvalue = BoolGetDatum(false);
+return;
+}
+
+exprtype = exprType(pred->expr);
+
+if (exprtype == TEXTOID || exprtype == JSONOID)
+{
+text *json = DatumGetTextP(js);
+
+if (pred->item_type == JS_TYPE_ANY)
+res = true;
+else
+{
+switch (json_get_first_token(json, false))
+{
+case JSON_TOKEN_OBJECT_START:
+res = pred->item_type == JS_TYPE_OBJECT;
+break;
+case JSON_TOKEN_ARRAY_START:
+res = pred->item_type == JS_TYPE_ARRAY;
+break;
+case JSON_TOKEN_STRING:
+case JSON_TOKEN_NUMBER:
+case JSON_TOKEN_TRUE:
+case JSON_TOKEN_FALSE:
+case JSON_TOKEN_NULL:
+res = pred->item_type == JS_TYPE_SCALAR;
+break;
+default:
+res = false;
+break;
+}
+}
+
+/*
+* Do full parsing pass only for uniqueness check or for JSON text
+* validation.
+*/
+if (res && (pred->unique_keys || exprtype == TEXTOID))
+res = json_validate(json, pred->unique_keys, false);
+}
+else if (exprtype == JSONBOID)
+{
+if (pred->item_type == JS_TYPE_ANY)
+res = true;
+else
+{
+Jsonb *jb = DatumGetJsonbP(js);
+
+switch (pred->item_type)
+{
+case JS_TYPE_OBJECT:
+res = JB_ROOT_IS_OBJECT(jb);
+break;
+case JS_TYPE_ARRAY:
+res = JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb);
+break;
+case JS_TYPE_SCALAR:
+res = JB_ROOT_IS_ARRAY(jb) && JB_ROOT_IS_SCALAR(jb);
+break;
+default:
+res = false;
+break;
+}
+}
+
+/* Key uniqueness check is redundant for jsonb */
+}
+else
+res = false;
+
+*op->resvalue = BoolGetDatum(res);
+}
+
+
 /*
 * ExecEvalGroupingFunc
 *

src/backend/jit/llvm/llvmjit_expr.c

@@ -1848,6 +1848,12 @@ llvm_compile_expr(ExprState *state)
 LLVMBuildBr(b, opblocks[opno + 1]);
 break;
 
+case EEOP_IS_JSON:
+build_EvalXFunc(b, mod, "ExecEvalJsonIsPredicate",
+v_state, op);
+LLVMBuildBr(b, opblocks[opno + 1]);
+break;
+
 case EEOP_AGGREF:
 {
 LLVMValueRef v_aggno;

src/backend/jit/llvm/llvmjit_types.c

@@ -133,6 +133,7 @@ void *referenced_functions[] =
 ExecEvalWholeRowVar,
 ExecEvalXmlExpr,
 ExecEvalJsonConstructor,
+ExecEvalJsonIsPredicate,
 MakeExpandedObjectReadOnlyInternal,
 slot_getmissingattrs,
 slot_getsomeattrs_int,

src/backend/nodes/makefuncs.c

@@ -894,3 +894,22 @@ makeJsonKeyValue(Node *key, Node *value)
 
 return (Node *) n;
 }
+
+/*
+* makeJsonIsPredicate -
+* creates a JsonIsPredicate node
+*/
+Node *
+makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type,
+bool unique_keys, int location)
+{
+JsonIsPredicate *n = makeNode(JsonIsPredicate);
+
+n->expr = expr;
+n->format = format;
+n->item_type = item_type;
+n->unique_keys = unique_keys;
+n->location = location;
+
+return (Node *) n;
+}

src/backend/nodes/nodeFuncs.c

@@ -261,6 +261,9 @@ exprType(const Node *expr)
 case T_JsonConstructorExpr:
 type = ((const JsonConstructorExpr *) expr)->returning->typid;
 break;
+case T_JsonIsPredicate:
+type = BOOLOID;
+break;
 default:
 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
 type = InvalidOid;	/* keep compiler quiet */
@@ -983,6 +986,9 @@ exprCollation(const Node *expr)
 coll = InvalidOid;
 }
 break;
+case T_JsonIsPredicate:
+coll = InvalidOid;	/* result is always an boolean type */
+break;
 default:
 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
 coll = InvalidOid;	/* keep compiler quiet */
@@ -1205,6 +1211,9 @@ exprSetCollation(Node *expr, Oid collation)
 * json[b] type */
 }
 break;
+case T_JsonIsPredicate:
+Assert(!OidIsValid(collation)); /* result is always boolean */
+break;
 default:
 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
 break;
@@ -1653,6 +1662,9 @@ exprLocation(const Node *expr)
 case T_JsonConstructorExpr:
 loc = ((const JsonConstructorExpr *) expr)->location;
 break;
+case T_JsonIsPredicate:
+loc = ((const JsonIsPredicate *) expr)->location;
+break;
 default:
 /* for any other node type it's just unknown... */
 loc = -1;
@@ -2406,6 +2418,8 @@ expression_tree_walker_impl(Node *node,
 return true;
 }
 break;
+case T_JsonIsPredicate:
+return walker(((JsonIsPredicate *) node)->expr, context);
 default:
 elog(ERROR, "unrecognized node type: %d",
 (int) nodeTag(node));
@@ -3413,6 +3427,16 @@ expression_tree_mutator_impl(Node *node,
 MUTATE(newnode->coercion, jve->coercion, Expr *);
 MUTATE(newnode->returning, jve->returning, JsonReturning *);
 
+return (Node *) newnode;
+}
+case T_JsonIsPredicate:
+{
+JsonIsPredicate *pred = (JsonIsPredicate *) node;
+JsonIsPredicate *newnode;
+
+FLATCOPY(newnode, pred, JsonIsPredicate);
+MUTATE(newnode->expr, pred->expr, Node *);
+
 return (Node *) newnode;
 }
 default:
@@ -4261,6 +4285,8 @@ raw_expression_tree_walker_impl(Node *node,
 return true;
 }
 break;
+case T_JsonIsPredicate:
+return walker(((JsonIsPredicate *) node)->expr, context);
 default:
 elog(ERROR, "unrecognized node type: %d",
 (int) nodeTag(node));