Rename JsonIsPredicate.value_type, fix JSON backend/nodes/ infrastructure.

I started out with the intention to rename value_type to item_type to
avoid a collision with a typedef name that appears on some platforms.

Along the way, I noticed that the adjacent field "format" was not being
correctly handled by the backend/nodes/ infrastructure functions:
copyfuncs.c erroneously treated it as a scalar, while equalfuncs,
outfuncs, and readfuncs omitted handling it at all.  This looks like
it might be cosmetic at the moment because the field is always NULL
after parse analysis; but that's likely a bug in itself, and the code's
certainly not very future-proof.  Let's fix it while we can still do so
without forcing an initdb on beta testers.

Further study found a few other inconsistencies in the backend/nodes/
infrastructure for the recently-added JSON node types, so fix those too.

catversion bumped because of potential change in stored rules.

Discussion: https://postgr.es/m/526703.1652385613@sss.pgh.pa.us

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index e024611aa5438daebae0bc35bcbd69cf6ea16025..e44ad68cda166f7bb66c72ccbcafbbbb46ae84f4 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -3952,24 +3952,24 @@ ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
    {
        text       *json = DatumGetTextP(js);
 
-       if (pred->value_type == JS_TYPE_ANY)
+       if (pred->item_type == JS_TYPE_ANY)
            res = true;
        else
        {
            switch (json_get_first_token(json, false))
            {
                case JSON_TOKEN_OBJECT_START:
-                   res = pred->value_type == JS_TYPE_OBJECT;
+                   res = pred->item_type == JS_TYPE_OBJECT;
                    break;
                case JSON_TOKEN_ARRAY_START:
-                   res = pred->value_type == JS_TYPE_ARRAY;
+                   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->value_type == JS_TYPE_SCALAR;
+                   res = pred->item_type == JS_TYPE_SCALAR;
                    break;
                default:
                    res = false;
@@ -3986,13 +3986,13 @@ ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
    }
    else if (exprtype == JSONBOID)
    {
-       if (pred->value_type == JS_TYPE_ANY)
+       if (pred->item_type == JS_TYPE_ANY)
            res = true;
        else
        {
            Jsonb      *jb = DatumGetJsonbP(js);
 
-           switch (pred->value_type)
+           switch (pred->item_type)
            {
                case JS_TYPE_OBJECT:
                    res = JB_ROOT_IS_OBJECT(jb);

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 205506305b04951e61abb284f17d2a135e8c3018..51d630fa8925e04db5a8a95abf6745c4545f1624 100644 (file)
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2557,11 +2557,11 @@ _copyJsonExpr(const JsonExpr *from)
    COPY_NODE_FIELD(result_coercion);
    COPY_NODE_FIELD(format);
    COPY_NODE_FIELD(path_spec);
-   COPY_NODE_FIELD(passing_values);
    COPY_NODE_FIELD(passing_names);
+   COPY_NODE_FIELD(passing_values);
    COPY_NODE_FIELD(returning);
-   COPY_NODE_FIELD(on_error);
    COPY_NODE_FIELD(on_empty);
+   COPY_NODE_FIELD(on_error);
    COPY_NODE_FIELD(coercions);
    COPY_SCALAR_FIELD(wrapper);
    COPY_SCALAR_FIELD(omit_quotes);
@@ -2637,8 +2637,8 @@ _copyJsonIsPredicate(const JsonIsPredicate *from)
    JsonIsPredicate *newnode = makeNode(JsonIsPredicate);
 
    COPY_NODE_FIELD(expr);
-   COPY_SCALAR_FIELD(format);
-   COPY_SCALAR_FIELD(value_type);
+   COPY_NODE_FIELD(format);
+   COPY_SCALAR_FIELD(item_type);
    COPY_SCALAR_FIELD(unique_keys);
    COPY_LOCATION_FIELD(location);
 
@@ -2764,6 +2764,7 @@ _copyJsonTableParent(const JsonTableParent *from)
    COPY_SCALAR_FIELD(outerJoin);
    COPY_SCALAR_FIELD(colMin);
    COPY_SCALAR_FIELD(colMax);
+   COPY_SCALAR_FIELD(errorOnError);
 
    return newnode;
 }

diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index 9688b22a4b99086c983ac30c0f5a37e7634d777a..e747e1667d01252ea841808fa1cfea066b72fd36 100644 (file)
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -186,6 +186,7 @@ _equalJsonTableParent(const JsonTableParent *a, const JsonTableParent *b)
    COMPARE_SCALAR_FIELD(outerJoin);
    COMPARE_SCALAR_FIELD(colMin);
    COMPARE_SCALAR_FIELD(colMax);
+   COMPARE_SCALAR_FIELD(errorOnError);
 
    return true;
 }
@@ -1104,7 +1105,8 @@ _equalJsonIsPredicate(const JsonIsPredicate *a,
                      const JsonIsPredicate *b)
 {
    COMPARE_NODE_FIELD(expr);
-   COMPARE_SCALAR_FIELD(value_type);
+   COMPARE_NODE_FIELD(format);
+   COMPARE_SCALAR_FIELD(item_type);
    COMPARE_SCALAR_FIELD(unique_keys);
    COMPARE_LOCATION_FIELD(location);
 
@@ -1134,11 +1136,11 @@ _equalJsonExpr(const JsonExpr *a, const JsonExpr *b)
    COMPARE_NODE_FIELD(result_coercion);
    COMPARE_NODE_FIELD(format);
    COMPARE_NODE_FIELD(path_spec);
-   COMPARE_NODE_FIELD(passing_values);
    COMPARE_NODE_FIELD(passing_names);
+   COMPARE_NODE_FIELD(passing_values);
    COMPARE_NODE_FIELD(returning);
-   COMPARE_NODE_FIELD(on_error);
    COMPARE_NODE_FIELD(on_empty);
+   COMPARE_NODE_FIELD(on_error);
    COMPARE_NODE_FIELD(coercions);
    COMPARE_SCALAR_FIELD(wrapper);
    COMPARE_SCALAR_FIELD(omit_quotes);

diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c
index 41e26a0fe679a35c5c6b759e274a84d5f6355fa8..28288dcfc101c0530f80c506fc164ad90f9530cf 100644 (file)
--- a/src/backend/nodes/makefuncs.c
+++ b/src/backend/nodes/makefuncs.c
@@ -927,14 +927,14 @@ makeJsonKeyValue(Node *key, Node *value)
  *   creates a JsonIsPredicate node
  */
 Node *
-makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType value_type,
+makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type,
                    bool unique_keys, int location)
 {
    JsonIsPredicate *n = makeNode(JsonIsPredicate);
 
    n->expr = expr;
    n->format = format;
-   n->value_type = value_type;
+   n->item_type = item_type;
    n->unique_keys = unique_keys;
    n->location = location;
 

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 0271ea9d7869dd615d018f592911efd51455bacc..ce129155925965903e168a327384cbb71da8f178 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -1801,13 +1801,13 @@ _outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node)
 {
    WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR");
 
+   WRITE_ENUM_FIELD(type, JsonConstructorType);
    WRITE_NODE_FIELD(args);
    WRITE_NODE_FIELD(func);
    WRITE_NODE_FIELD(coercion);
-   WRITE_ENUM_FIELD(type, JsonConstructorType);
    WRITE_NODE_FIELD(returning);
-   WRITE_BOOL_FIELD(unique);
    WRITE_BOOL_FIELD(absent_on_null);
+   WRITE_BOOL_FIELD(unique);
    WRITE_LOCATION_FIELD(location);
 }
 
@@ -1817,7 +1817,8 @@ _outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node)
    WRITE_NODE_TYPE("JSONISPREDICATE");
 
    WRITE_NODE_FIELD(expr);
-   WRITE_ENUM_FIELD(value_type, JsonValueType);
+   WRITE_NODE_FIELD(format);
+   WRITE_ENUM_FIELD(item_type, JsonValueType);
    WRITE_BOOL_FIELD(unique_keys);
    WRITE_LOCATION_FIELD(location);
 }
@@ -1841,11 +1842,11 @@ _outJsonExpr(StringInfo str, const JsonExpr *node)
    WRITE_NODE_FIELD(result_coercion);
    WRITE_NODE_FIELD(format);
    WRITE_NODE_FIELD(path_spec);
-   WRITE_NODE_FIELD(passing_values);
    WRITE_NODE_FIELD(passing_names);
+   WRITE_NODE_FIELD(passing_values);
    WRITE_NODE_FIELD(returning);
-   WRITE_NODE_FIELD(on_error);
    WRITE_NODE_FIELD(on_empty);
+   WRITE_NODE_FIELD(on_error);
    WRITE_NODE_FIELD(coercions);
    WRITE_ENUM_FIELD(wrapper, JsonWrapper);
    WRITE_BOOL_FIELD(omit_quotes);
@@ -1883,7 +1884,7 @@ _outJsonItemCoercions(StringInfo str, const JsonItemCoercions *node)
 static void
 _outJsonTableParent(StringInfo str, const JsonTableParent *node)
 {
-   WRITE_NODE_TYPE("JSONTABPNODE");
+   WRITE_NODE_TYPE("JSONTABLEPARENT");
 
    WRITE_NODE_FIELD(path);
    WRITE_STRING_FIELD(name);
@@ -1891,12 +1892,13 @@ _outJsonTableParent(StringInfo str, const JsonTableParent *node)
    WRITE_BOOL_FIELD(outerJoin);
    WRITE_INT_FIELD(colMin);
    WRITE_INT_FIELD(colMax);
+   WRITE_BOOL_FIELD(errorOnError);
 }
 
 static void
 _outJsonTableSibling(StringInfo str, const JsonTableSibling *node)
 {
-   WRITE_NODE_TYPE("JSONTABSNODE");
+   WRITE_NODE_TYPE("JSONTABLESIBLING");
 
    WRITE_NODE_FIELD(larg);
    WRITE_NODE_FIELD(rarg);

diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index ddf76ac778fd9e363b1e196b9016115da0f3f8c2..6a05b694152444118319ff77eaffeb11bc9555d1 100644 (file)
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1484,13 +1484,13 @@ _readJsonConstructorExpr(void)
 {
    READ_LOCALS(JsonConstructorExpr);
 
+   READ_ENUM_FIELD(type, JsonConstructorType);
    READ_NODE_FIELD(args);
    READ_NODE_FIELD(func);
    READ_NODE_FIELD(coercion);
-   READ_INT_FIELD(type);
    READ_NODE_FIELD(returning);
-   READ_BOOL_FIELD(unique);
    READ_BOOL_FIELD(absent_on_null);
+   READ_BOOL_FIELD(unique);
    READ_LOCATION_FIELD(location);
 
    READ_DONE();
@@ -1523,11 +1523,11 @@ _readJsonExpr(void)
    READ_NODE_FIELD(result_coercion);
    READ_NODE_FIELD(format);
    READ_NODE_FIELD(path_spec);
-   READ_NODE_FIELD(passing_values);
    READ_NODE_FIELD(passing_names);
+   READ_NODE_FIELD(passing_values);
    READ_NODE_FIELD(returning);
-   READ_NODE_FIELD(on_error);
    READ_NODE_FIELD(on_empty);
+   READ_NODE_FIELD(on_error);
    READ_NODE_FIELD(coercions);
    READ_ENUM_FIELD(wrapper, JsonWrapper);
    READ_BOOL_FIELD(omit_quotes);
@@ -1547,6 +1547,7 @@ _readJsonTableParent(void)
    READ_BOOL_FIELD(outerJoin);
    READ_INT_FIELD(colMin);
    READ_INT_FIELD(colMax);
+   READ_BOOL_FIELD(errorOnError);
 
    READ_DONE();
 }
@@ -1610,7 +1611,8 @@ _readJsonIsPredicate()
    READ_LOCALS(JsonIsPredicate);
 
    READ_NODE_FIELD(expr);
-   READ_ENUM_FIELD(value_type, JsonValueType);
+   READ_NODE_FIELD(format);
+   READ_ENUM_FIELD(item_type, JsonValueType);
    READ_BOOL_FIELD(unique_keys);
    READ_LOCATION_FIELD(location);
 
@@ -3229,9 +3231,9 @@ parseNodeString(void)
        return_value = _readJsonCoercion();
    else if (MATCH("JSONITEMCOERCIONS", 17))
        return_value = _readJsonItemCoercions();
-   else if (MATCH("JSONTABPNODE", 12))
+   else if (MATCH("JSONTABLEPARENT", 15))
        return_value = _readJsonTableParent();
-   else if (MATCH("JSONTABSNODE", 12))
+   else if (MATCH("JSONTABLESIBLING", 16))
        return_value = _readJsonTableSibling();
    else
    {

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index 17709c3416bc62035e3f879940c193f608853176..0dc2fc472e58020821d9f521d555d6d585daf578 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -4018,8 +4018,7 @@ transformJsonParseArg(ParseState *pstate, Node *jsexpr, JsonFormat *format,
 }
 
 /*
- * Transform IS JSON predicate into
- * json[b]_is_valid(json, value_type [, check_key_uniqueness]) call.
+ * Transform IS JSON predicate.
  */
 static Node *
 transformJsonIsPredicate(ParseState *pstate, JsonIsPredicate *pred)
@@ -4035,7 +4034,8 @@ transformJsonIsPredicate(ParseState *pstate, JsonIsPredicate *pred)
                 errmsg("cannot use type %s in IS JSON predicate",
                        format_type_be(exprtype))));
 
-   return makeJsonIsPredicate(expr, NULL, pred->value_type,
+   /* This intentionally(?) drops the format clause. */
+   return makeJsonIsPredicate(expr, NULL, pred->item_type,
                               pred->unique_keys, pred->location);
 }
 

diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index f22ecfc58323d6805e861e163a14dc5e426f8df9..49c4201dde6b2b36b460bb9c86bdb4bdb8541b58 100644 (file)
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -9730,7 +9730,9 @@ get_rule_expr(Node *node, deparse_context *context,
 
                appendStringInfoString(context->buf, " IS JSON");
 
-               switch (pred->value_type)
+               /* TODO: handle FORMAT clause */
+
+               switch (pred->item_type)
                {
                    case JS_TYPE_SCALAR:
                        appendStringInfoString(context->buf, " SCALAR");

diff --git a/src/backend/utils/misc/queryjumble.c b/src/backend/utils/misc/queryjumble.c
index d35027275f173086c297bcb21458d5f6e4d79c74..eeaa0b31fe231dbc5d28399f5646fe7b7e7a4836 100644 (file)
--- a/src/backend/utils/misc/queryjumble.c
+++ b/src/backend/utils/misc/queryjumble.c
@@ -741,7 +741,7 @@ JumbleExpr(JumbleState *jstate, Node *node)
            {
                JsonFormat *format = (JsonFormat *) node;
 
-               APP_JUMB(format->type);
+               APP_JUMB(format->format_type);
                APP_JUMB(format->encoding);
            }
            break;
@@ -767,12 +767,13 @@ JumbleExpr(JumbleState *jstate, Node *node)
            {
                JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
 
+               APP_JUMB(ctor->type);
+               JumbleExpr(jstate, (Node *) ctor->args);
                JumbleExpr(jstate, (Node *) ctor->func);
                JumbleExpr(jstate, (Node *) ctor->coercion);
                JumbleExpr(jstate, (Node *) ctor->returning);
-               APP_JUMB(ctor->type);
-               APP_JUMB(ctor->unique);
                APP_JUMB(ctor->absent_on_null);
+               APP_JUMB(ctor->unique);
            }
            break;
        case T_JsonIsPredicate:
@@ -781,8 +782,8 @@ JumbleExpr(JumbleState *jstate, Node *node)
 
                JumbleExpr(jstate, (Node *) pred->expr);
                JumbleExpr(jstate, (Node *) pred->format);
+               APP_JUMB(pred->item_type);
                APP_JUMB(pred->unique_keys);
-               APP_JUMB(pred->value_type);
            }
            break;
        case T_JsonExpr:

diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 805e870842e70ac4609141d286d494b1177bb03e..2cdcfa667a80165c70ebb136a113103142b7409c 100644 (file)
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -53,6 +53,6 @@
  */
 
 /*                         yyyymmddN */
-#define CATALOG_VERSION_NO 202205121
+#define CATALOG_VERSION_NO 202205131
 
 #endif

diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h
index c717468eb391c3ce18753783c492e80950895ade..06e6369026a4962cfc923a1dcbe3bdef52277458 100644 (file)
--- a/src/include/nodes/makefuncs.h
+++ b/src/include/nodes/makefuncs.h
@@ -114,7 +114,7 @@ extern Node *makeJsonTableJoinedPlan(JsonTablePlanJoinType type,
                                     Node *plan1, Node *plan2, int location);
 extern Node *makeJsonKeyValue(Node *key, Node *value);
 extern Node *makeJsonIsPredicate(Node *expr, JsonFormat *format,
-                                JsonValueType vtype, bool unique_keys,
+                                JsonValueType item_type, bool unique_keys,
                                 int location);
 extern JsonEncoding makeJsonEncoding(char *name);
 

diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
index 66e179c4356766d5c8c2d17e4c5217baa2eaa3c1..51505eee85dfff7446defaf4d4e401e96f3f7d1a 100644 (file)
--- a/src/include/nodes/primnodes.h
+++ b/src/include/nodes/primnodes.h
@@ -1387,14 +1387,14 @@ typedef enum JsonValueType
 
 /*
  * JsonIsPredicate -
- *     untransformed representation of IS JSON predicate
+ *     representation of IS JSON predicate
  */
 typedef struct JsonIsPredicate
 {
    NodeTag     type;
-   Node       *expr;           /* untransformed expression */
+   Node       *expr;           /* subject expression */
    JsonFormat *format;         /* FORMAT clause, if specified */
-   JsonValueType value_type;   /* JSON item type */
+   JsonValueType item_type;    /* JSON item type */
    bool        unique_keys;    /* check key uniqueness? */
    int         location;       /* token location, or -1 if unknown */
 } JsonIsPredicate;