X-Git-Url: https://git.8kb.co.uk/?a=blobdiff_plain;f=jsonb_opx.c;h=29ea74a4b6ffa529f636f2ca76f67c7839cb3612;hb=c121fab7a779e85ecb31c42ba4788630370a2c75;hp=d2c498c49f77b1c3e3a8632ee06d3cec49a914d8;hpb=2d389c1c39e2f652522f333cc7ecc31dd23a9ae0;p=postgresql%2Fpg_jsonb_opx diff --git a/jsonb_opx.c b/jsonb_opx.c index d2c498c..29ea74a 100755 --- a/jsonb_opx.c +++ b/jsonb_opx.c @@ -17,14 +17,125 @@ #include "utils/jsonb.h" #include "catalog/pg_type.h" #include "utils/builtins.h" +#include "jsonb_opx.h" #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif -Datum jsonb_delete_text(PG_FUNCTION_ARGS); +Datum jsonb_delete_key(PG_FUNCTION_ARGS); -PG_FUNCTION_INFO_V1(jsonb_delete_text); +PG_FUNCTION_INFO_V1(jsonb_delete_key); + +/* + * Operator function to delete key from left operand where a match is found in + * the right operand. + * + * jsonb, text -> jsonb + * + */ +Datum +jsonb_delete_key(PG_FUNCTION_ARGS) +{ + /* pointers to incoming jsonb and text data */ + Jsonb *input_jsonb = PG_GETARG_JSONB(0); + text *input_text = PG_GETARG_TEXT_P(1); + + /* pointers to return jsonb value data and state to be converted to jsonb on return */ + JsonbParseState *state = NULL; + JsonbValue *return_jsonb_value = NULL; + + /* pointer to iterator for input_jsonb value data */ + JsonbIterator *jsonb_iterator; + JsonbValue jsonb_iterator_value; + int32 jsonb_iterator_token; + + /* variables used for skip logic */ + int32 skip_level = 0; + int32 nest_level = 0; + int32 array_level = 0; + bool push = true; + + /* + * If we've been supplied with an existing key iterate round json data and rebuild + * with key/element excluded. + * + * skip_key, nest_level and array_level are crude counts to check if the the value + * for the key is closed and ensure we don't match on keys within nested objects. + * Because we are recursing into nested elements but blindly just pushing them onto + * the return value we can get away without deeper knowledge of the json? + */ + + jsonb_iterator = JsonbIteratorInit(&input_jsonb->root); + + while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, false)) != WJB_DONE) + { + push = true; + switch (jsonb_iterator_token) + { + case WJB_BEGIN_ARRAY: + array_level++; + break; + case WJB_BEGIN_OBJECT: + nest_level++; + break; + case WJB_ELEM: + case WJB_KEY: + if (skip_level == 0 && ((jsonb_iterator_token == WJB_KEY && nest_level == 1 && array_level == 0) || + (jsonb_iterator_token == WJB_ELEM && nest_level == 0 && array_level == 1))) + { + if (jsonb_iterator_value.type == jbvString) + { + if ((jsonb_iterator_value.val.string.len == VARSIZE_ANY_EXHDR(input_text)) && + (memcmp(jsonb_iterator_value.val.string.val, + VARDATA_ANY(input_text), + jsonb_iterator_value.val.string.len) == 0)) + { + + if (jsonb_iterator_token == WJB_ELEM) + push = false; + else + skip_level = nest_level; + } + } + } + } + + if (push && (skip_level == 0 || nest_level < skip_level)) + { + return_jsonb_value = pushJsonbValueBlind(&state, jsonb_iterator_token, &jsonb_iterator_value); + } + + switch (jsonb_iterator_token) + { + case WJB_END_OBJECT: + nest_level--; + if (skip_level == nest_level && array_level == 0) + skip_level = 0; + break; + case WJB_END_ARRAY: + array_level--; + if (skip_level == nest_level && array_level == 0) + skip_level = 0; + break; + case WJB_VALUE: + if (skip_level == nest_level) + skip_level = 0; + } + } + + if (JB_ROOT_IS_SCALAR(input_jsonb) && !return_jsonb_value->val.array.rawScalar && return_jsonb_value->val.array.nElems == 1) + return_jsonb_value->val.array.rawScalar = true; + + PG_FREE_IF_COPY(input_jsonb, 0); + PG_FREE_IF_COPY(input_text, 1); + + PG_RETURN_JSONB(JsonbValueToJsonb(return_jsonb_value)); +} + +Datum jsonb_delete_keys(PG_FUNCTION_ARGS); + +PG_FUNCTION_INFO_V1(jsonb_delete_keys); /* * Operator function to delete keys from left operand where a match is found in @@ -34,7 +145,7 @@ PG_FUNCTION_INFO_V1(jsonb_delete_text); * */ Datum -jsonb_delete_text(PG_FUNCTION_ARGS) +jsonb_delete_keys(PG_FUNCTION_ARGS) { /* general loops */ int i; @@ -43,21 +154,20 @@ jsonb_delete_text(PG_FUNCTION_ARGS) Jsonb *input_jsonb = PG_GETARG_JSONB(0); ArrayType *input_array = PG_GETARG_ARRAYTYPE_P(1); - /* pointers to return jsonb_value data and state to be converted to jsonb on return */ + /* pointers to return jsonb value data and state to be converted to jsonb on return */ JsonbParseState *state = NULL; JsonbValue *return_jsonb_value = NULL; - /* pointer to iterator for input_jsonb and lookup value data */ - JsonbValue jsonb_lookup_value; - JsonbValue *jsonb_value = NULL; + /* pointer to iterator for input_jsonb value data */ JsonbIterator *jsonb_iterator; JsonbValue jsonb_iterator_value; int32 jsonb_iterator_token; /* variables used for skip logic */ - int32 skip_key = 0; + int32 skip_level = 0; int32 nest_level = 0; int32 array_level = 0; + bool push = true; /* array element variables for use during deconstruction */ Datum *datums; @@ -66,13 +176,6 @@ jsonb_delete_text(PG_FUNCTION_ARGS) /* individual array values values from incoming text[] */ text *array_element_text; - bool exists = false; - - /* check that supplied jsonb isn't non object, i.e. scalar or array */ - if (!JB_ROOT_IS_OBJECT(input_jsonb)) - ereport(ERROR, - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("cannot call on a non-object"))); /* assert input_array is a text array type */ Assert(ARR_ELEMTYPE(input_array) == TEXTOID); @@ -87,105 +190,88 @@ jsonb_delete_text(PG_FUNCTION_ARGS) deconstruct_array(input_array, TEXTOID, -1, false, 'i', &datums, &nulls, &count); - /* first check to make sure at least one key exists - this is potentially just extra unwanted work */ - for (i=0; iroot, - JB_FOBJECT | JB_FARRAY, &jsonb_lookup_value); - - if (jsonb_value != NULL) { - exists = true; - break; - } - } - - if (!exists) + /* if the array is empty there's no work to do so return the input value */ + if (count == 0) PG_RETURN_JSONB(input_jsonb); /* - * If we've been supplied with existing keys iterate round json data matching those keys. + * If we've been supplied with existing keys iterate round json data and rebuild + * with keys/elements excluded. * - * skip_key, nest_level and array_level are crude counts to check if the the value for the key is closed - * and ensure we don't match on keys within nested objects. Because we are recursing into nested elements - * but blindly just pushing them onto the return value we can get away without deeper knowledge of the json? + * skip_level, nest_level and array_level are crude counts to check if the the value + * for the key is closed and ensure we don't match on keys within nested objects. + * Because we are recursing into nested elements but blindly just pushing them onto + * the return value we can get away without deeper knowledge of the json? */ - jsonb_iterator = JsonbIteratorInit(&input_jsonb->root); while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, false)) != WJB_DONE) { + push = true; switch (jsonb_iterator_token) { case WJB_BEGIN_ARRAY: array_level++; - if (skip_key == 0) - return_jsonb_value = pushJsonbValue(&state, WJB_BEGIN_ARRAY, &jsonb_iterator_value); break; case WJB_BEGIN_OBJECT: nest_level++; - if (skip_key == 0) - return_jsonb_value = pushJsonbValue(&state, WJB_BEGIN_OBJECT, &jsonb_iterator_value); break; + case WJB_ELEM: case WJB_KEY: - /* Check each key against our array of keys */ - if (skip_key > 0) { - skip_key++; - } - else if (nest_level == 1){ - for (i=0; i 0) - skip_key--; - break; - case WJB_ELEM: - if (skip_key == 0) - return_jsonb_value = pushJsonbValue(&state, WJB_ELEM, &jsonb_iterator_value); + if (push && (skip_level == 0 || nest_level < skip_level)) + { + return_jsonb_value = pushJsonbValueBlind(&state, jsonb_iterator_token, &jsonb_iterator_value); + } + + switch (jsonb_iterator_token) + { + case WJB_END_OBJECT: + nest_level--; + if (skip_level == nest_level && array_level == 0) + skip_level = 0; break; case WJB_END_ARRAY: array_level--; - if (skip_key == 0) - return_jsonb_value = pushJsonbValue(&state, WJB_END_ARRAY, NULL); - else if (skip_key > 0 && array_level == 0) - skip_key--; - break; - case WJB_END_OBJECT: - nest_level--; - if (skip_key == 0) - return_jsonb_value = pushJsonbValue(&state, WJB_END_OBJECT, NULL); - else if (skip_key > 0) - skip_key--; + if (skip_level == nest_level && array_level == 0) + skip_level = 0; break; - default: - elog(ERROR, "invalid JsonbIteratorNext rc: %d", jsonb_iterator_token); + case WJB_VALUE: + if (skip_level == nest_level) + skip_level = 0; } } + + if (JB_ROOT_IS_SCALAR(input_jsonb) && !return_jsonb_value->val.array.rawScalar && return_jsonb_value->val.array.nElems == 1) + return_jsonb_value->val.array.rawScalar = true; + PG_FREE_IF_COPY(input_jsonb, 0); PG_FREE_IF_COPY(input_array, 1); @@ -210,7 +296,7 @@ jsonb_delete_jsonb(PG_FUNCTION_ARGS) Jsonb *input_jsonb_a = PG_GETARG_JSONB(0); Jsonb *input_jsonb_b = PG_GETARG_JSONB(1); - /* pointers to return jsonb_value data and state to be converted to jsonb on return */ + /* pointers to return jsonb value data and state to be converted to jsonb on return */ JsonbValue *return_jsonb_value = NULL; JsonbParseState *state = NULL; @@ -221,62 +307,86 @@ jsonb_delete_jsonb(PG_FUNCTION_ARGS) int32 jsonb_iterator_token; bool skip_nested = false; - /* pointer to iterator and container for pushing nested parts of input_jsonb_a */ - JsonbContainer *nest_jsonb_container_a; - JsonbIterator *nest_jsonb_iterator; bool push = true; - /* inner iterator for iterating around jbvBinary types */ - JsonbValue nest_jsonb_iterator_value; - int32 nest_jsonb_iterator_token; - /* pointer to lookup on input_jsonb_b */ JsonbValue *jsonb_lookup_value = NULL; + /* + * check if either right jsonb is empty and return left if so + */ + if (JB_ROOT_COUNT(input_jsonb_b) == 0) + PG_RETURN_JSONB(input_jsonb_a); + jsonb_iterator = JsonbIteratorInit(&input_jsonb_a->root); - while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested)) != WJB_DONE) { + while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested)) != WJB_DONE) + { skip_nested = true; + push = true; switch (jsonb_iterator_token) { case WJB_BEGIN_ARRAY: case WJB_BEGIN_OBJECT: - case WJB_ELEM: case WJB_END_ARRAY: case WJB_END_OBJECT: - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); + return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, NULL); break; - case WJB_KEY: - jsonb_lookup_value = findJsonbValueFromContainer(&input_jsonb_b->root, JB_FOBJECT | JB_FARRAY, &jsonb_iterator_value); - jsonb_iterator_key = jsonb_iterator_value; + case WJB_ELEM: + /* + * findJsonbValueFromContainer only supports jsonb arrays containting scalar values? + * If container is something like '[[1]]' or '[{"a":1}]' will error with "invalid jsonb scalar type" + */ + jsonb_lookup_value = findJsonbValueFromContainer(&input_jsonb_b->root, JB_FOBJECT | JB_FARRAY, &jsonb_iterator_value); + if (jsonb_lookup_value == NULL) + { + if (jsonb_iterator_value.type == jbvBinary) + { + return_jsonb_value = pushJsonbBinary(&state, jsonb_iterator_value.val.binary.data); + } + else + { + return_jsonb_value = pushJsonbValue(&state, WJB_ELEM, &jsonb_iterator_value); + } + } + break; + case WJB_KEY : + jsonb_lookup_value = findJsonbValueFromContainer(&input_jsonb_b->root, JB_FOBJECT | JB_FARRAY, &jsonb_iterator_value); - jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested); - if (jsonb_iterator_token != WJB_VALUE) - elog(ERROR, "invalid JsonbIteratorNext (expected WJB_VALUE) rc: %d", jsonb_iterator_token); + jsonb_iterator_key = jsonb_iterator_value; + jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested); + if (jsonb_iterator_token != WJB_VALUE) + elog(ERROR, "invalid JsonbIteratorNext (expected WJB_VALUE) rc: %d", jsonb_iterator_token); - if (jsonb_lookup_value != NULL) { - if (jsonb_lookup_value->type == jsonb_iterator_value.type) { - switch (jsonb_lookup_value->type) { + if (jsonb_lookup_value != NULL) + { + + if (jsonb_lookup_value->type == jsonb_iterator_value.type) + { + switch (jsonb_lookup_value->type) + { + case jbvNull: + push = false; + break; case jbvNumeric: - if (strcmp( - DatumGetCString(DirectFunctionCall1(numeric_out, PointerGetDatum(jsonb_lookup_value->val.numeric))), - DatumGetCString(DirectFunctionCall1(numeric_out, PointerGetDatum(jsonb_iterator_value.val.numeric))) - ) == 0) + if (DatumGetBool(DirectFunctionCall2(numeric_eq, + PointerGetDatum(jsonb_lookup_value->val.numeric), + PointerGetDatum(jsonb_iterator_value.val.numeric)))) push = false; break; case jbvString: - if (strcmp( - pnstrdup(jsonb_lookup_value->val.string.val,jsonb_lookup_value->val.string.len), - pnstrdup(jsonb_iterator_value.val.string.val,jsonb_iterator_value.val.string.len) - ) == 0) + if ((jsonb_lookup_value->val.string.len == jsonb_iterator_value.val.string.len) && + (memcmp(jsonb_lookup_value->val.string.val, + jsonb_iterator_value.val.string.val, + jsonb_lookup_value->val.string.len) == 0)) push = false; break; case jbvBinary: - if (strcmp( - JsonbToCString(NULL, jsonb_lookup_value->val.binary.data, jsonb_lookup_value->val.binary.len), - JsonbToCString(NULL, jsonb_iterator_value.val.binary.data, jsonb_lookup_value->val.binary.len) - ) == 0) + if ((jsonb_lookup_value->val.binary.len == jsonb_iterator_value.val.binary.len) && + (memcmp(jsonb_lookup_value->val.binary.data, + jsonb_iterator_value.val.binary.data, + jsonb_lookup_value->val.binary.len) == 0)) push = false; break; case jbvBool: @@ -288,29 +398,25 @@ jsonb_delete_jsonb(PG_FUNCTION_ARGS) case jbvObject: /* should not be possible? */ default: - ereport(NOTICE, (errcode(ERRCODE_SUCCESSFUL_COMPLETION), errmsg("unexpected lookup type"))); + ereport(ERROR, (errcode(ERRCODE_SUCCESSFUL_COMPLETION), errmsg("unexpected lookup type %i", jsonb_iterator_token))); } } } - if (push) { + if (push) + { return_jsonb_value = pushJsonbValue(&state, WJB_KEY, &jsonb_iterator_key); /* if our value is nested binary data, iterate separately pushing each val */ - if (jsonb_iterator_value.type == jbvBinary) { - nest_jsonb_container_a = jsonb_iterator_value.val.binary.data; - - nest_jsonb_iterator = JsonbIteratorInit(nest_jsonb_container_a); - while ((nest_jsonb_iterator_token = JsonbIteratorNext(&nest_jsonb_iterator, &nest_jsonb_iterator_value, false)) != WJB_DONE) { - return_jsonb_value = pushJsonbValue(&state, nest_jsonb_iterator_token, &nest_jsonb_iterator_value); - } + if (jsonb_iterator_value.type == jbvBinary) + { + return_jsonb_value = pushJsonbBinary(&state, jsonb_iterator_value.val.binary.data); } - else { + else + { return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); } } - else - push = true; break; case WJB_VALUE: /* should not be possible */ @@ -320,12 +426,42 @@ jsonb_delete_jsonb(PG_FUNCTION_ARGS) } + if (JB_ROOT_IS_SCALAR(input_jsonb_a) && !return_jsonb_value->val.array.rawScalar && return_jsonb_value->val.array.nElems == 1) + return_jsonb_value->val.array.rawScalar = true; + PG_FREE_IF_COPY(input_jsonb_a, 0); PG_FREE_IF_COPY(input_jsonb_b, 1); PG_RETURN_JSONB(JsonbValueToJsonb(return_jsonb_value)); } +Datum jsonb_delete_path(PG_FUNCTION_ARGS); + +PG_FUNCTION_INFO_V1(jsonb_delete_path); + +/* + * Test + * jsonb, text[] -> jsonb + * + */ +Datum +jsonb_delete_path(PG_FUNCTION_ARGS) +{ + /* pointers to incoming jsonb and text[] data */ + Jsonb *input_jsonb_a = PG_GETARG_JSONB(0); + ArrayType *input_array = PG_GETARG_ARRAYTYPE_P(1); + + /* pointer to return jsonb data */ + Jsonb *return_jsonb = NULL; + + return_jsonb = jsonbModifyPath(input_jsonb_a, input_array, NULL); + + PG_FREE_IF_COPY(input_jsonb_a, 0); + PG_FREE_IF_COPY(input_array, 1); + + PG_RETURN_JSONB(return_jsonb); +} + Datum jsonb_concat_jsonb(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(jsonb_concat_jsonb); @@ -340,28 +476,46 @@ PG_FUNCTION_INFO_V1(jsonb_concat_jsonb); Datum jsonb_concat_jsonb(PG_FUNCTION_ARGS) { - /* incoming jsonb and text[] data */ + /* incoming jsonb data */ Jsonb *input_jsonb_a = PG_GETARG_JSONB(0); Jsonb *input_jsonb_b = PG_GETARG_JSONB(1); - /* return jsonb_value data to be converted to jsonb on return */ + /* return jsonb value data to be converted to jsonb on return */ + JsonbParseState *state = NULL; JsonbValue *return_jsonb_value = NULL; /* iterator for input_jsonb_b */ JsonbIterator *jsonb_iterator; - JsonbValue jsonb_iterator_value; + JsonbValue jsonb_iterator_value; int32 jsonb_iterator_token; - - JsonbParseState *state = NULL; - bool skip_nested = false; + int32 jsonb_root_open; + int32 jsonb_root_close; int32 nest_level = 0; - - /* check that supplied jsonb isn't non object, i.e. scalar or array */ - if (!JB_ROOT_IS_OBJECT(input_jsonb_a) || !JB_ROOT_IS_OBJECT(input_jsonb_b)) - ereport(ERROR, - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("cannot call on a non-object"))); + bool first = true; + + /* + * check if either supplied jsonb is empty and return the other if so + */ + if (JB_ROOT_COUNT(input_jsonb_a) == 0) + PG_RETURN_JSONB(input_jsonb_b); + else if (JB_ROOT_COUNT(input_jsonb_b) == 0) + PG_RETURN_JSONB(input_jsonb_a); + + /* + * rather than restrict concatenation to objects, allow any jsonb root + * but if one is an array use an array as the root container else + * default to object + */ + if (JB_ROOT_IS_ARRAY(input_jsonb_a) || JB_ROOT_IS_ARRAY(input_jsonb_b)) + { + jsonb_root_open = WJB_BEGIN_ARRAY; + jsonb_root_close = WJB_END_ARRAY; + } else + { + jsonb_root_open = WJB_BEGIN_OBJECT; + jsonb_root_close = WJB_END_OBJECT; + } /* * The following is essentially a cut 'n shut job; discarding the closing root @@ -370,65 +524,187 @@ jsonb_concat_jsonb(PG_FUNCTION_ARGS) * deduplication down to lower level jsonb logic. */ - jsonb_iterator = JsonbIteratorInit(&input_jsonb_a->root); + return_jsonb_value = pushJsonbValue(&state, jsonb_root_open, NULL); - while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested)) != WJB_DONE) { + jsonb_iterator = JsonbIteratorInit(&input_jsonb_a->root); - switch (jsonb_iterator_token) + while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, false)) != WJB_DONE) + { + if (jsonb_iterator_token == jsonb_root_open && (first || nest_level > 0)) { - case WJB_BEGIN_ARRAY: - case WJB_KEY: - case WJB_VALUE: - case WJB_ELEM: - case WJB_END_ARRAY: - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); - break; - case WJB_BEGIN_OBJECT: - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); nest_level++; - break; - case WJB_END_OBJECT: + if (nest_level == 1) + { + first = false; + continue; + } + } + else if (jsonb_iterator_token == jsonb_root_close && nest_level > 0) + { nest_level--; - if (nest_level != 0) - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); - break; - default: - elog(ERROR, "invalid JsonbIteratorNext rc: %d", jsonb_iterator_token); + if (nest_level == 0) + continue; } + first = false; + return_jsonb_value = pushJsonbValueBlind(&state, jsonb_iterator_token, &jsonb_iterator_value); } nest_level = 0; + first = true; jsonb_iterator = JsonbIteratorInit(&input_jsonb_b->root); - while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, skip_nested)) != WJB_DONE) { - - switch (jsonb_iterator_token) + while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, false)) != WJB_DONE) + { + if (jsonb_iterator_token == jsonb_root_open && (first || nest_level > 0)) { - case WJB_BEGIN_ARRAY: - case WJB_KEY: - case WJB_VALUE: - case WJB_ELEM: - case WJB_END_ARRAY: - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); - break; - case WJB_BEGIN_OBJECT: - if (nest_level != 0) - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); nest_level++; - break; - case WJB_END_OBJECT: + if (nest_level == 1) + { + first = false; + continue; + } + } + else if (jsonb_iterator_token == jsonb_root_close && nest_level > 0) + { nest_level--; - return_jsonb_value = pushJsonbValue(&state, jsonb_iterator_token, &jsonb_iterator_value); - break; - default: - elog(ERROR, "invalid JsonbIteratorNext rc: %d", jsonb_iterator_token); + if (nest_level == 0) + continue; + } + + first = false; + return_jsonb_value = pushJsonbValueBlind(&state, jsonb_iterator_token, &jsonb_iterator_value); + } + + return_jsonb_value = pushJsonbValue(&state, jsonb_root_close, NULL); + + PG_FREE_IF_COPY(input_jsonb_a, 0); + PG_FREE_IF_COPY(input_jsonb_b, 1); + + PG_RETURN_JSONB(JsonbValueToJsonb(return_jsonb_value)); +} + +Datum jsonb_replace_jsonb(PG_FUNCTION_ARGS); + +PG_FUNCTION_INFO_V1(jsonb_replace_jsonb); + +/* + * Operator function to replace json in left operand where keys match + * in the right operand. + * + * jsonb, jsonb -> jsonb + * + */ +Datum +jsonb_replace_jsonb(PG_FUNCTION_ARGS) +{ + /* incoming jsonb data */ + Jsonb *input_jsonb_a = PG_GETARG_JSONB(0); + Jsonb *input_jsonb_b = PG_GETARG_JSONB(1); + + /* return jsonb value data to be converted to jsonb on return */ + JsonbParseState *state = NULL; + JsonbValue *return_jsonb_value = NULL; + + /* lookup jsonb value data */ + JsonbValue jsonb_lookup_key; + JsonbValue *jsonb_lookup_value = NULL; + uint32 jsonb_lookup_flags; + + /* iterator for input_jsonb_b */ + JsonbIterator *jsonb_iterator; + JsonbValue jsonb_iterator_value; + int32 jsonb_iterator_token; + + /* + * check if supplied replacement jsonb is empty and return unchanged if so + */ + if (JB_ROOT_COUNT(input_jsonb_b) == 0) + PG_RETURN_JSONB(input_jsonb_a); + + if (JB_ROOT_IS_OBJECT(input_jsonb_a)) + jsonb_lookup_flags = JB_FOBJECT; + else + jsonb_lookup_flags = JB_FOBJECT | JB_FARRAY; + + jsonb_iterator = JsonbIteratorInit(&input_jsonb_a->root); + while ((jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, true)) != WJB_DONE) + { + if ((jsonb_iterator_token == WJB_ELEM ) && (jsonb_iterator_value.type == jbvBinary)) + { + return_jsonb_value = pushJsonbBinary(&state, jsonb_iterator_value.val.binary.data); + } + else + { + return_jsonb_value = pushJsonbValueBlind(&state, jsonb_iterator_token, &jsonb_iterator_value); } + Assert(jsonb_iterator_token != WJB_VALUE); + + if ( jsonb_iterator_token == WJB_KEY ) + { + jsonb_lookup_key.type = jbvString; + jsonb_lookup_key.val.string.val = jsonb_iterator_value.val.string.val; + jsonb_lookup_key.val.string.len = jsonb_iterator_value.val.string.len; + + jsonb_iterator_token = JsonbIteratorNext(&jsonb_iterator, &jsonb_iterator_value, true); + Assert(jsonb_iterator_token == WJB_VALUE); + + jsonb_lookup_value = findJsonbValueFromContainer(&input_jsonb_b->root, + jsonb_lookup_flags, &jsonb_lookup_key); + + /* if there's nothing to replace push the original value */ + if (jsonb_lookup_value == NULL) + { + jsonb_lookup_value = &jsonb_iterator_value; + } + + /* if our value is nested binary data, iterate separately pushing each val */ + if (jsonb_lookup_value->type == jbvBinary) + { + return_jsonb_value = pushJsonbBinary(&state, jsonb_lookup_value->val.binary.data); + } + else + { + return_jsonb_value = pushJsonbValue(&state, WJB_VALUE, jsonb_lookup_value); + } + } } + if (JB_ROOT_IS_SCALAR(input_jsonb_a) && !return_jsonb_value->val.array.rawScalar && return_jsonb_value->val.array.nElems == 1) + return_jsonb_value->val.array.rawScalar = true; + PG_FREE_IF_COPY(input_jsonb_a, 0); PG_FREE_IF_COPY(input_jsonb_b, 1); PG_RETURN_JSONB(JsonbValueToJsonb(return_jsonb_value)); } + +Datum jsonb_replace_path(PG_FUNCTION_ARGS); + +PG_FUNCTION_INFO_V1(jsonb_replace_path); + +/* + * Test + * jsonb, text[], jsonb -> jsonb + * + */ +Datum +jsonb_replace_path(PG_FUNCTION_ARGS) +{ + /* pointers to incoming jsonb and text[] data */ + Jsonb *input_jsonb_a = PG_GETARG_JSONB(0); + ArrayType *input_array = PG_GETARG_ARRAYTYPE_P(1); + Jsonb *input_jsonb_b = PG_GETARG_JSONB(2); + + /* pointer to return jsonb data */ + Jsonb *return_jsonb = NULL; + + return_jsonb = jsonbModifyPath(input_jsonb_a, input_array, input_jsonb_b); + + PG_FREE_IF_COPY(input_jsonb_a, 0); + PG_FREE_IF_COPY(input_array, 1); + PG_FREE_IF_COPY(input_jsonb_b, 2); + + PG_RETURN_JSONB(return_jsonb); +}