static Jsonb *
jnumber_op(PGFunction f, Jsonb *l, Jsonb *r)
{
FunctionCallInfoData fcinfo;
JsonbValue *jv;
Datum n;
AssertArg(r != NULL);
if (!((l == NULL || JB_ROOT_IS_SCALAR(l)) && JB_ROOT_IS_SCALAR(r)))
ereport_op(f, l, r);
InitFunctionCallInfoData(fcinfo, NULL, 0, InvalidOid, NULL, NULL);
if (l != NULL)
{
jv = getIthJsonbValueFromContainer(&l->root, 0);
if (jv->type != jbvNumeric)
ereport_op(f, l, r);
fcinfo.arg[fcinfo.nargs] = NumericGetDatum(jv->val.numeric);
fcinfo.argnull[fcinfo.nargs] = false;
fcinfo.nargs++;
}
jv = getIthJsonbValueFromContainer(&r->root, 0);
if (jv->type != jbvNumeric)
ereport_op(f, l, r);
fcinfo.arg[fcinfo.nargs] = NumericGetDatum(jv->val.numeric);
fcinfo.argnull[fcinfo.nargs] = false;
fcinfo.nargs++;
n = (*f) (&fcinfo);
if (fcinfo.isnull)
elog(ERROR, "function %p returned NULL", (void *) f);
if (f == numeric_power || f == numeric_div)
{
int s;
s = DatumGetInt32(DirectFunctionCall1(numeric_scale, fcinfo.arg[0])) +
DatumGetInt32(DirectFunctionCall1(numeric_scale, fcinfo.arg[1]));
if (s == 0)
n = DirectFunctionCall2(numeric_trunc, n, 0);
}
return numeric_to_jnumber(DatumGetNumeric(n));
}
static Datum
jsonb_num(Jsonb *j, PGFunction f)
{
const char *type;
if (f == numeric_int8)
type = "int8";
else if (f == numeric_int4)
type = "int4";
else if (f == numeric_float8)
type = "float8";
else
elog(ERROR, "unexpected type");
if (JB_ROOT_IS_SCALAR(j))
{
JsonbValue *jv;
jv = getIthJsonbValueFromContainer(&j->root, 0);
if (jv->type == jbvNumeric)
{
Datum n;
n = DirectFunctionCall1(f, NumericGetDatum(jv->val.numeric));
return n;
}
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%s cannot be converted to %s",
JsonbToCString(NULL, &j->root, VARSIZE(j)), type)));
return 0;
}
/*
* SQL function jsonb_typeof(jsonb) -> text
*
* This function is here because the analog json function is in json.c, since
* it uses the json parser internals not exposed elsewhere.
*/
Datum
jsonb_typeof(PG_FUNCTION_ARGS)
{
Jsonb *in = PG_GETARG_JSONB(0);
JsonbIterator *it;
JsonbValue v;
char *result;
if (JB_ROOT_IS_OBJECT(in))
result = "object";
else if (JB_ROOT_IS_ARRAY(in) && !JB_ROOT_IS_SCALAR(in))
result = "array";
else
{
Assert(JB_ROOT_IS_SCALAR(in));
it = JsonbIteratorInit(VARDATA_ANY(in));
/*
* A root scalar is stored as an array of one element, so we get the
* array and then its first (and only) member.
*/
(void) JsonbIteratorNext(&it, &v, true);
Assert(v.type == jbvArray);
(void) JsonbIteratorNext(&it, &v, true);
switch (v.type)
{
case jbvNull:
result = "null";
break;
case jbvString:
result = "string";
break;
case jbvNumeric:
result = "number";
break;
case jbvBool:
result = "boolean";
break;
default:
elog(ERROR, "unknown jsonb scalar type");
}
}
PG_RETURN_TEXT_P(cstring_to_text(result));
}
/*
* jsonb_delete:
* Return copy of jsonb with the specified item removed.
* Item is a one key or element from jsonb, specified by name.
* If there are many keys or elements with than name,
* the first one will be removed.
*/
Datum
jsonb_delete(PG_FUNCTION_ARGS)
{
Jsonb *in = PG_GETARG_JSONB(0);
text *key = PG_GETARG_TEXT_PP(1);
char *keyptr = VARDATA_ANY(key);
int keylen = VARSIZE_ANY_EXHDR(key);
JsonbParseState *state = NULL;
JsonbIterator *it;
uint32 r;
JsonbValue v, *res = NULL;
bool skipped = false;
if (JB_ROOT_IS_SCALAR(in))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot delete from scalar")));
if (JB_ROOT_COUNT(in) == 0)
{
PG_RETURN_JSONB(in);
}
it = JsonbIteratorInit(&in->root);
while((r = JsonbIteratorNext(&it, &v, false)) != 0)
{
if (!skipped && (r == WJB_ELEM || r == WJB_KEY) &&
(v.type == jbvString && keylen == v.val.string.len &&
memcmp(keyptr, v.val.string.val, keylen) == 0))
{
/* we should delete only one key/element */
skipped = true;
if (r == WJB_KEY)
{
/* skip corresponding value */
JsonbIteratorNext(&it, &v, true);
}
continue;
}
res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
}
Assert(res != NULL);
PG_RETURN_JSONB(JsonbValueToJsonb(res));
}
/*
* jsonb_set:
* Replace/create value of jsonb key or jsonb element, which can be found by the specified path.
* Path must be replesented as an array of key names or indexes. If indexes will be used,
* the same rules implied as for jsonb_delete_idx (negative indexing and edge cases)
*/
Datum
jsonb_set(PG_FUNCTION_ARGS)
{
Jsonb *in = PG_GETARG_JSONB(0);
ArrayType *path = PG_GETARG_ARRAYTYPE_P(1);
Jsonb *newval = PG_GETARG_JSONB(2);
bool create = PG_GETARG_BOOL(3);
JsonbValue *res = NULL;
Datum *path_elems;
bool *path_nulls;
int path_len;
JsonbIterator *it;
JsonbParseState *st = NULL;
if (ARR_NDIM(path) > 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("wrong number of array subscripts")));
if (JB_ROOT_IS_SCALAR(in))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot set path in scalar")));
if (JB_ROOT_COUNT(in) == 0 && !create)
{
PG_RETURN_JSONB(in);
}
deconstruct_array(path, TEXTOID, -1, false, 'i',
&path_elems, &path_nulls, &path_len);
if (path_len == 0)
{
PG_RETURN_JSONB(in);
}
it = JsonbIteratorInit(&in->root);
res = setPath(&it, path_elems, path_nulls, path_len, &st, 0, newval, create);
Assert (res != NULL);
PG_RETURN_JSONB(JsonbValueToJsonb(res));
}
Datum
jsonb_numeric(PG_FUNCTION_ARGS)
{
Jsonb *j = PG_GETARG_JSONB(0);
if (JB_ROOT_IS_SCALAR(j))
{
JsonbValue *jv;
jv = getIthJsonbValueFromContainer(&j->root, 0);
if (jv->type == jbvNumeric)
PG_RETURN_DATUM(datumCopy(NumericGetDatum(jv->val.numeric), false,
-1));
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("%s cannot be converted to numeric",
JsonbToCString(NULL, &j->root, VARSIZE(j)))));
PG_RETURN_NULL();
}
Datum
jsonb_bool(PG_FUNCTION_ARGS)
{
Jsonb *j = PG_GETARG_JSONB(0);
if (JB_ROOT_IS_SCALAR(j))
{
JsonbValue *jv;
jv = getIthJsonbValueFromContainer(&j->root, 0);
switch (jv->type)
{
case jbvNull:
PG_RETURN_NULL();
case jbvString:
PG_RETURN_BOOL(jv->val.string.len > 0);
case jbvNumeric:
{
Datum b;
if (numeric_is_nan(jv->val.numeric))
PG_RETURN_BOOL(false);
b = DirectFunctionCall2(numeric_ne,
NumericGetDatum(jv->val.numeric),
get_numeric_0_datum());
PG_RETURN_DATUM(b);
}
case jbvBool:
PG_RETURN_BOOL(jv->val.boolean);
default:
elog(ERROR, "unknown jsonb scalar type");
}
}
Assert(JB_ROOT_IS_OBJECT(j) || JB_ROOT_IS_ARRAY(j));
PG_RETURN_BOOL(JB_ROOT_COUNT(j) > 0);
}
/*
* Turn a Datum into jsonb, adding it to the result JsonbInState.
*
* tcategory and outfuncoid are from a previous call to json_categorize_type,
* except that if is_null is true then they can be invalid.
*
* If key_scalar is true, the value is stored as a key, so insist
* it's of an acceptable type, and force it to be a jbvString.
*/
static void
datum_to_jsonb(Datum val, bool is_null, JsonbInState *result,
JsonbTypeCategory tcategory, Oid outfuncoid,
bool key_scalar)
{
char *outputstr;
bool numeric_error;
JsonbValue jb;
bool scalar_jsonb = false;
check_stack_depth();
/* Convert val to a JsonbValue in jb (in most cases) */
if (is_null)
{
Assert(!key_scalar);
jb.type = jbvNull;
}
else if (key_scalar &&
(tcategory == JSONBTYPE_ARRAY ||
tcategory == JSONBTYPE_COMPOSITE ||
tcategory == JSONBTYPE_JSON ||
tcategory == JSONBTYPE_JSONB ||
tcategory == JSONBTYPE_JSONCAST))
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("key value must be scalar, not array, composite, or json")));
}
else
{
if (tcategory == JSONBTYPE_JSONCAST)
val = OidFunctionCall1(outfuncoid, val);
switch (tcategory)
{
case JSONBTYPE_ARRAY:
array_to_jsonb_internal(val, result);
break;
case JSONBTYPE_COMPOSITE:
composite_to_jsonb(val, result);
break;
case JSONBTYPE_BOOL:
if (key_scalar)
{
outputstr = DatumGetBool(val) ? "true" : "false";
jb.type = jbvString;
jb.val.string.len = strlen(outputstr);
jb.val.string.val = outputstr;
}
else
{
jb.type = jbvBool;
jb.val.boolean = DatumGetBool(val);
}
break;
case JSONBTYPE_NUMERIC:
outputstr = OidOutputFunctionCall(outfuncoid, val);
if (key_scalar)
{
/* always quote keys */
jb.type = jbvString;
jb.val.string.len = strlen(outputstr);
jb.val.string.val = outputstr;
}
else
{
/*
* Make it numeric if it's a valid JSON number, otherwise
* a string. Invalid numeric output will always have an
* 'N' or 'n' in it (I think).
*/
numeric_error = (strchr(outputstr, 'N') != NULL ||
strchr(outputstr, 'n') != NULL);
if (!numeric_error)
{
jb.type = jbvNumeric;
jb.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(outputstr), 0, -1));
pfree(outputstr);
}
else
{
jb.type = jbvString;
jb.val.string.len = strlen(outputstr);
jb.val.string.val = outputstr;
}
}
break;
case JSONBTYPE_DATE:
{
DateADT date;
struct pg_tm tm;
char buf[MAXDATELEN + 1];
date = DatumGetDateADT(val);
/* Same as date_out(), but forcing DateStyle */
if (DATE_NOT_FINITE(date))
EncodeSpecialDate(date, buf);
else
{
j2date(date + POSTGRES_EPOCH_JDATE,
&(tm.tm_year), &(tm.tm_mon), &(tm.tm_mday));
EncodeDateOnly(&tm, USE_XSD_DATES, buf);
}
jb.type = jbvString;
jb.val.string.len = strlen(buf);
jb.val.string.val = pstrdup(buf);
}
break;
case JSONBTYPE_TIMESTAMP:
{
Timestamp timestamp;
struct pg_tm tm;
fsec_t fsec;
char buf[MAXDATELEN + 1];
timestamp = DatumGetTimestamp(val);
/* Same as timestamp_out(), but forcing DateStyle */
if (TIMESTAMP_NOT_FINITE(timestamp))
EncodeSpecialTimestamp(timestamp, buf);
else if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, NULL) == 0)
EncodeDateTime(&tm, fsec, false, 0, NULL, USE_XSD_DATES, buf);
else
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
jb.type = jbvString;
jb.val.string.len = strlen(buf);
jb.val.string.val = pstrdup(buf);
}
break;
case JSONBTYPE_TIMESTAMPTZ:
{
TimestampTz timestamp;
struct pg_tm tm;
int tz;
fsec_t fsec;
const char *tzn = NULL;
char buf[MAXDATELEN + 1];
timestamp = DatumGetTimestampTz(val);
/* Same as timestamptz_out(), but forcing DateStyle */
if (TIMESTAMP_NOT_FINITE(timestamp))
EncodeSpecialTimestamp(timestamp, buf);
else if (timestamp2tm(timestamp, &tz, &tm, &fsec, &tzn, NULL) == 0)
EncodeDateTime(&tm, fsec, true, tz, tzn, USE_XSD_DATES, buf);
else
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
jb.type = jbvString;
jb.val.string.len = strlen(buf);
jb.val.string.val = pstrdup(buf);
}
break;
case JSONBTYPE_JSONCAST:
case JSONBTYPE_JSON:
{
/* parse the json right into the existing result object */
JsonLexContext *lex;
JsonSemAction sem;
text *json = DatumGetTextP(val);
lex = makeJsonLexContext(json, true);
memset(&sem, 0, sizeof(sem));
sem.semstate = (void *) result;
sem.object_start = jsonb_in_object_start;
sem.array_start = jsonb_in_array_start;
sem.object_end = jsonb_in_object_end;
sem.array_end = jsonb_in_array_end;
sem.scalar = jsonb_in_scalar;
sem.object_field_start = jsonb_in_object_field_start;
pg_parse_json(lex, &sem);
}
break;
case JSONBTYPE_JSONB:
{
Jsonb *jsonb = DatumGetJsonb(val);
JsonbIterator *it;
it = JsonbIteratorInit(&jsonb->root);
if (JB_ROOT_IS_SCALAR(jsonb))
{
(void) JsonbIteratorNext(&it, &jb, true);
Assert(jb.type == jbvArray);
(void) JsonbIteratorNext(&it, &jb, true);
scalar_jsonb = true;
}
else
{
JsonbIteratorToken type;
while ((type = JsonbIteratorNext(&it, &jb, false))
!= WJB_DONE)
{
if (type == WJB_END_ARRAY || type == WJB_END_OBJECT ||
type == WJB_BEGIN_ARRAY || type == WJB_BEGIN_OBJECT)
result->res = pushJsonbValue(&result->parseState,
type, NULL);
else
result->res = pushJsonbValue(&result->parseState,
type, &jb);
}
}
}
break;
default:
outputstr = OidOutputFunctionCall(outfuncoid, val);
jb.type = jbvString;
jb.val.string.len = checkStringLen(strlen(outputstr));
jb.val.string.val = outputstr;
break;
}
}
/* Now insert jb into result, unless we did it recursively */
if (!is_null && !scalar_jsonb &&
tcategory >= JSONBTYPE_JSON && tcategory <= JSONBTYPE_JSONCAST)
{
/* work has been done recursively */
return;
}
else if (result->parseState == NULL)
{
/* single root scalar */
JsonbValue va;
va.type = jbvArray;
va.val.array.rawScalar = true;
va.val.array.nElems = 1;
result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, &va);
result->res = pushJsonbValue(&result->parseState, WJB_ELEM, &jb);
result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
}
else
{
JsonbValue *o = &result->parseState->contVal;
switch (o->type)
{
case jbvArray:
result->res = pushJsonbValue(&result->parseState, WJB_ELEM, &jb);
break;
case jbvObject:
result->res = pushJsonbValue(&result->parseState,
key_scalar ? WJB_KEY : WJB_VALUE,
&jb);
break;
default:
elog(ERROR, "unexpected parent of nested structure");
}
}
}
Datum
jsonb_add(PG_FUNCTION_ARGS)
{
Jsonb *l = PG_GETARG_JSONB(0);
Jsonb *r = PG_GETARG_JSONB(1);
JsonbValue *ljv;
JsonbValue *rjv;
JsonbValue jv;
Size len;
char *buf;
Datum n;
char *nstr;
if (!(JB_ROOT_IS_SCALAR(l) && JB_ROOT_IS_SCALAR(r)))
{
Datum j;
if ((JB_ROOT_IS_SCALAR(l) && JB_ROOT_IS_OBJECT(r)) ||
(JB_ROOT_IS_OBJECT(l) && JB_ROOT_IS_SCALAR(r)) ||
(JB_ROOT_IS_OBJECT(l) && JB_ROOT_IS_OBJECT(r)))
ereport_op_str("+", l, r);
j = DirectFunctionCall2(jsonb_concat,
JsonbGetDatum(l), JsonbGetDatum(r));
PG_RETURN_DATUM(j);
}
ljv = getIthJsonbValueFromContainer(&l->root, 0);
rjv = getIthJsonbValueFromContainer(&r->root, 0);
if (ljv->type == jbvString && rjv->type == jbvString)
{
len = ljv->val.string.len + rjv->val.string.len;
buf = palloc(len + 1);
strncpy(buf, ljv->val.string.val, ljv->val.string.len);
strncpy(buf + ljv->val.string.len,
rjv->val.string.val, rjv->val.string.len);
buf[len] = '\0';
jv.type = jbvString;
jv.val.string.len = len;
jv.val.string.val = buf;
PG_RETURN_JSONB(JsonbValueToJsonb(&jv));
}
else if (ljv->type == jbvString && rjv->type == jbvNumeric)
{
n = DirectFunctionCall1(numeric_out,
NumericGetDatum(rjv->val.numeric));
nstr = DatumGetCString(n);
len = ljv->val.string.len + strlen(nstr);
buf = palloc(len + 1);
strncpy(buf, ljv->val.string.val, ljv->val.string.len);
strcpy(buf + ljv->val.string.len, nstr);
jv.type = jbvString;
jv.val.string.len = len;
jv.val.string.val = buf;
PG_RETURN_JSONB(JsonbValueToJsonb(&jv));
}
else if (ljv->type == jbvNumeric && rjv->type == jbvString)
{
Size nlen;
n = DirectFunctionCall1(numeric_out,
NumericGetDatum(ljv->val.numeric));
nstr = DatumGetCString(n);
nlen = strlen(nstr);
len = nlen + rjv->val.string.len;
buf = palloc(len + 1);
strcpy(buf, nstr);
strncpy(buf + nlen, rjv->val.string.val, rjv->val.string.len);
buf[len] = '\0';
jv.type = jbvString;
jv.val.string.len = len;
jv.val.string.val = buf;
PG_RETURN_JSONB(JsonbValueToJsonb(&jv));
}
else if (ljv->type == jbvNumeric && rjv->type == jbvNumeric)
{
n = DirectFunctionCall2(numeric_add,
NumericGetDatum(ljv->val.numeric),
NumericGetDatum(rjv->val.numeric));
PG_RETURN_JSONB(numeric_to_jnumber(DatumGetNumeric(n)));
}
else
{
ereport_op_str("+", l, r);
}
PG_RETURN_NULL();
}
/*
* jsonb_delete_idx:
* Return a copy of jsonb withour specified items.
* Delete key (only from the top level of object) or element from jsonb by index (idx).
* Negative idx value is supported, and it implies the countdown from the last key/element.
* If idx is more, than numbers of keys/elements, or equal - nothing will be deleted.
* If idx is negative and -idx is more, than number of keys/elements - the last one will be deleted.
*
* TODO: take care about nesting values.
*/
Datum
jsonb_delete_idx(PG_FUNCTION_ARGS)
{
Jsonb *in = PG_GETARG_JSONB(0);
int idx = PG_GETARG_INT32(1);
JsonbParseState *state = NULL;
JsonbIterator *it;
uint32 r, i = 0, n;
JsonbValue v, *res = NULL;
if (JB_ROOT_IS_SCALAR(in))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot delete from scalar")));
if (JB_ROOT_COUNT(in) == 0)
{
PG_RETURN_JSONB(in);
}
it = JsonbIteratorInit(&in->root);
r = JsonbIteratorNext(&it, &v, false);
if (r == WJB_BEGIN_ARRAY)
n = v.val.array.nElems;
else
n = v.val.object.nPairs;
if (idx < 0)
{
if (-idx > n)
idx = n;
else
idx = n + idx;
}
if (idx >= n)
{
PG_RETURN_JSONB(in);
}
pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
while((r = JsonbIteratorNext(&it, &v, true)) != 0)
{
if (r == WJB_ELEM || r == WJB_KEY)
{
if (i++ == idx)
{
if (r == WJB_KEY)
JsonbIteratorNext(&it, &v, true); /* skip value */
continue;
}
}
res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
}
Assert (res != NULL);
PG_RETURN_JSONB(JsonbValueToJsonb(res));
}