jsonb.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "access/htup_details.h"
#include "access/transam.h"
#include "catalog/pg_type.h"
#include "libpq/pqformat.h"
#include "parser/parse_coerce.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/lsyscache.h"
#include "utils/json.h"
#include "utils/jsonapi.h"
#include "utils/jsonb.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for jsonb.c:

Go to the source code of this file.

Data Structures
struct	JsonbInState
struct	JsonbAggState

Typedefs
typedef struct JsonbInState	JsonbInState
typedef struct JsonbAggState	JsonbAggState

Enumerations
enum	JsonbTypeCategory {   JSONBTYPE_NULL, JSONBTYPE_BOOL, JSONBTYPE_NUMERIC, JSONBTYPE_DATE,   JSONBTYPE_TIMESTAMP, JSONBTYPE_TIMESTAMPTZ, JSONBTYPE_JSON, JSONBTYPE_JSONB,   JSONBTYPE_ARRAY, JSONBTYPE_COMPOSITE, JSONBTYPE_JSONCAST, JSONBTYPE_OTHER }

Functions
static Datum	jsonb_from_cstring (char *json, int len)
static size_t	checkStringLen (size_t len)
static void	jsonb_in_object_start (void *pstate)
static void	jsonb_in_object_end (void *pstate)
static void	jsonb_in_array_start (void *pstate)
static void	jsonb_in_array_end (void *pstate)
static void	jsonb_in_object_field_start (void *pstate, char *fname, bool isnull)
static void	jsonb_put_escaped_value (StringInfo out, JsonbValue *scalarVal)
static void	jsonb_in_scalar (void *pstate, char *token, JsonTokenType tokentype)
static void	jsonb_categorize_type (Oid typoid, JsonbTypeCategory *tcategory, Oid *outfuncoid)
static void	composite_to_jsonb (Datum composite, JsonbInState *result)
static void	array_dim_to_jsonb (JsonbInState *result, int dim, int ndims, int *dims, Datum *vals, bool *nulls, int *valcount, JsonbTypeCategory tcategory, Oid outfuncoid)
static void	array_to_jsonb_internal (Datum array, JsonbInState *result)
static void	datum_to_jsonb (Datum val, bool is_null, JsonbInState *result, JsonbTypeCategory tcategory, Oid outfuncoid, bool key_scalar)
static void	add_jsonb (Datum val, bool is_null, JsonbInState *result, Oid val_type, bool key_scalar)
static JsonbParseState *	clone_parse_state (JsonbParseState *state)
static char *	JsonbToCStringWorker (StringInfo out, JsonbContainer *in, int estimated_len, bool indent)
static void	add_indent (StringInfo out, bool indent, int level)
Datum	jsonb_in (PG_FUNCTION_ARGS)
Datum	jsonb_recv (PG_FUNCTION_ARGS)
Datum	jsonb_out (PG_FUNCTION_ARGS)
Datum	jsonb_send (PG_FUNCTION_ARGS)
Datum	jsonb_typeof (PG_FUNCTION_ARGS)
char *	JsonbToCString (StringInfo out, JsonbContainer *in, int estimated_len)
char *	JsonbToCStringIndent (StringInfo out, JsonbContainer *in, int estimated_len)
Datum	to_jsonb (PG_FUNCTION_ARGS)
Datum	jsonb_build_object (PG_FUNCTION_ARGS)
Datum	jsonb_build_object_noargs (PG_FUNCTION_ARGS)
Datum	jsonb_build_array (PG_FUNCTION_ARGS)
Datum	jsonb_build_array_noargs (PG_FUNCTION_ARGS)
Datum	jsonb_object (PG_FUNCTION_ARGS)
Datum	jsonb_object_two_arg (PG_FUNCTION_ARGS)
Datum	jsonb_agg_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_agg_finalfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_finalfn (PG_FUNCTION_ARGS)

Typedef Documentation

typedef struct JsonbAggState JsonbAggState

typedef struct JsonbInState JsonbInState

Enumeration Type Documentation

enum JsonbTypeCategory

Enumerator
JSONBTYPE_NULL
JSONBTYPE_BOOL
JSONBTYPE_NUMERIC
JSONBTYPE_DATE
JSONBTYPE_TIMESTAMP
JSONBTYPE_TIMESTAMPTZ
JSONBTYPE_JSON
JSONBTYPE_JSONB
JSONBTYPE_ARRAY
JSONBTYPE_COMPOSITE
JSONBTYPE_JSONCAST
JSONBTYPE_OTHER

Definition at line 38 of file jsonb.c.

{
    JSONBTYPE_NULL,             /* null, so we didn't bother to identify */
    JSONBTYPE_BOOL,             /* boolean (built-in types only) */
    JSONBTYPE_NUMERIC,          /* numeric (ditto) */
    JSONBTYPE_DATE,             /* we use special formatting for datetimes */
    JSONBTYPE_TIMESTAMP,        /* we use special formatting for timestamp */
    JSONBTYPE_TIMESTAMPTZ,      /* ... and timestamptz */
    JSONBTYPE_JSON,             /* JSON */
    JSONBTYPE_JSONB,            /* JSONB */
    JSONBTYPE_ARRAY,            /* array */
    JSONBTYPE_COMPOSITE,        /* composite */
    JSONBTYPE_JSONCAST,         /* something with an explicit cast to JSON */
    JSONBTYPE_OTHER             /* all else */
} JsonbTypeCategory;

Function Documentation

static void add_indent ( StringInfo  out, bool  indent, int  level  )

static

Definition at line 570 of file jsonb.c.

References appendBinaryStringInfo(), appendStringInfoCharMacro, and i.

Referenced by JsonbToCStringWorker().

{
    if (indent)
    {
        int         i;

        appendStringInfoCharMacro(out, '\n');
        for (i = 0; i < level; i++)
            appendBinaryStringInfo(out, "    ", 4);
    }
}

static void add_jsonb ( Datum  val, bool  is_null, JsonbInState *  result, Oid  val_type, bool  key_scalar  )

static

Definition at line 1118 of file jsonb.c.

References datum_to_jsonb(), ereport, errcode(), errmsg(), ERROR, InvalidOid, jsonb_categorize_type(), and JSONBTYPE_NULL.

Referenced by jsonb_build_array(), and jsonb_build_object().

{
    JsonbTypeCategory tcategory;
    Oid         outfuncoid;

    if (val_type == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("could not determine input data type")));

    if (is_null)
    {
        tcategory = JSONBTYPE_NULL;
        outfuncoid = InvalidOid;
    }
    else
        jsonb_categorize_type(val_type,
                              &tcategory, &outfuncoid);

    datum_to_jsonb(val, is_null, result, tcategory, outfuncoid, key_scalar);
}

static void array_dim_to_jsonb ( JsonbInState *  result, int  dim, int  ndims, int *  dims, Datum *  vals, bool *  nulls, int *  valcount, JsonbTypeCategory  tcategory, Oid  outfuncoid  )

static

Definition at line 966 of file jsonb.c.

References Assert, datum_to_jsonb(), i, NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by array_to_jsonb_internal().

{
    int         i;

    Assert(dim < ndims);

    result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, NULL);

    for (i = 1; i <= dims[dim]; i++)
    {
        if (dim + 1 == ndims)
        {
            datum_to_jsonb(vals[*valcount], nulls[*valcount], result, tcategory,
                           outfuncoid, false);
            (*valcount)++;
        }
        else
        {
            array_dim_to_jsonb(result, dim + 1, ndims, dims, vals, nulls,
                               valcount, tcategory, outfuncoid);
        }
    }

    result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
}

static void array_to_jsonb_internal ( Datum  array, JsonbInState *  result  )

static

Definition at line 998 of file jsonb.c.

References ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, array_dim_to_jsonb(), ArrayGetNItems(), DatumGetArrayTypeP, deconstruct_array(), get_typlenbyvalalign(), jsonb_categorize_type(), NULL, JsonbInState::parseState, pfree(), pushJsonbValue(), JsonbInState::res, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by datum_to_jsonb().

{
    ArrayType  *v = DatumGetArrayTypeP(array);
    Oid         element_type = ARR_ELEMTYPE(v);
    int        *dim;
    int         ndim;
    int         nitems;
    int         count = 0;
    Datum      *elements;
    bool       *nulls;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    JsonbTypeCategory tcategory;
    Oid         outfuncoid;

    ndim = ARR_NDIM(v);
    dim = ARR_DIMS(v);
    nitems = ArrayGetNItems(ndim, dim);

    if (nitems <= 0)
    {
        result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, NULL);
        result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
        return;
    }

    get_typlenbyvalalign(element_type,
                         &typlen, &typbyval, &typalign);

    jsonb_categorize_type(element_type,
                          &tcategory, &outfuncoid);

    deconstruct_array(v, element_type, typlen, typbyval,
                      typalign, &elements, &nulls,
                      &nitems);

    array_dim_to_jsonb(result, 0, ndim, dim, elements, nulls, &count, tcategory,
                       outfuncoid);

    pfree(elements);
    pfree(nulls);
}

static size_t checkStringLen ( size_t  len )

static

Definition at line 252 of file jsonb.c.

References ereport, errcode(), errdetail(), errmsg(), ERROR, and JENTRY_OFFLENMASK.

Referenced by datum_to_jsonb(), jsonb_in_object_field_start(), and jsonb_in_scalar().

{
    if (len > JENTRY_OFFLENMASK)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("string too long to represent as jsonb string"),
                 errdetail("Due to an implementation restriction, jsonb strings cannot exceed %d bytes.",
                           JENTRY_OFFLENMASK)));

    return len;
}

static JsonbParseState * clone_parse_state ( JsonbParseState *  state )

static

Definition at line 1531 of file jsonb.c.

References JsonbParseState::contVal, JsonbParseState::next, NULL, palloc(), result, and JsonbParseState::size.

Referenced by jsonb_agg_finalfn(), and jsonb_object_agg_finalfn().

{
    JsonbParseState *result,
               *icursor,
               *ocursor;

    if (state == NULL)
        return NULL;

    result = palloc(sizeof(JsonbParseState));
    icursor = state;
    ocursor = result;
    for (;;)
    {
        ocursor->contVal = icursor->contVal;
        ocursor->size = icursor->size;
        icursor = icursor->next;
        if (icursor == NULL)
            break;
        ocursor->next = palloc(sizeof(JsonbParseState));
        ocursor = ocursor->next;
    }
    ocursor->next = NULL;

    return result;
}

static void composite_to_jsonb ( Datum  composite, JsonbInState *  result  )

static

Definition at line 1046 of file jsonb.c.

References datum_to_jsonb(), DatumGetHeapTupleHeader, heap_getattr, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, InvalidOid, jbvString, jsonb_categorize_type(), JSONBTYPE_NULL, lookup_rowtype_tupdesc(), NameStr, tupleDesc::natts, NULL, JsonbInState::parseState, pushJsonbValue(), ReleaseTupleDesc, JsonbInState::res, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescAttr, JsonbValue::type, JsonbValue::val, val, WJB_BEGIN_OBJECT, WJB_END_OBJECT, and WJB_KEY.

Referenced by datum_to_jsonb().

{
    HeapTupleHeader td;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupdesc;
    HeapTupleData tmptup,
               *tuple;
    int         i;

    td = DatumGetHeapTupleHeader(composite);

    /* Extract rowtype info and find a tupdesc */
    tupType = HeapTupleHeaderGetTypeId(td);
    tupTypmod = HeapTupleHeaderGetTypMod(td);
    tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);

    /* Build a temporary HeapTuple control structure */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
    tmptup.t_data = td;
    tuple = &tmptup;

    result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_OBJECT, NULL);

    for (i = 0; i < tupdesc->natts; i++)
    {
        Datum       val;
        bool        isnull;
        char       *attname;
        JsonbTypeCategory tcategory;
        Oid         outfuncoid;
        JsonbValue  v;
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);

        if (att->attisdropped)
            continue;

        attname = NameStr(att->attname);

        v.type = jbvString;
        /* don't need checkStringLen here - can't exceed maximum name length */
        v.val.string.len = strlen(attname);
        v.val.string.val = attname;

        result->res = pushJsonbValue(&result->parseState, WJB_KEY, &v);

        val = heap_getattr(tuple, i + 1, tupdesc, &isnull);

        if (isnull)
        {
            tcategory = JSONBTYPE_NULL;
            outfuncoid = InvalidOid;
        }
        else
            jsonb_categorize_type(att->atttypid, &tcategory, &outfuncoid);

        datum_to_jsonb(val, isnull, result, tcategory, outfuncoid, false);
    }

    result->res = pushJsonbValue(&result->parseState, WJB_END_OBJECT, NULL);
    ReleaseTupleDesc(tupdesc);
}

static void datum_to_jsonb ( Datum  val, bool  is_null, JsonbInState *  result, JsonbTypeCategory  tcategory, Oid  outfuncoid, bool  key_scalar  )

static

Definition at line 699 of file jsonb.c.

References JsonSemAction::array_end, JsonSemAction::array_start, array_to_jsonb_internal(), Assert, buf, check_stack_depth(), checkStringLen(), composite_to_jsonb(), JsonbParseState::contVal, CStringGetDatum, DATE_NOT_FINITE, DatumGetBool, DatumGetDateADT, DatumGetJsonb, DatumGetNumeric, DatumGetTextPP, DatumGetTimestamp, DatumGetTimestampTz, DirectFunctionCall3, elog, EncodeDateOnly(), EncodeDateTime(), EncodeSpecialDate(), EncodeSpecialTimestamp(), ereport, errcode(), errmsg(), ERROR, j2date(), JB_ROOT_IS_SCALAR, jbvArray, jbvBool, jbvNull, jbvNumeric, jbvObject, jbvString, jsonb_in_array_end(), jsonb_in_array_start(), jsonb_in_object_end(), jsonb_in_object_field_start(), jsonb_in_object_start(), jsonb_in_scalar(), JsonbIteratorInit(), JsonbIteratorNext(), JSONBTYPE_ARRAY, JSONBTYPE_BOOL, JSONBTYPE_COMPOSITE, JSONBTYPE_DATE, JSONBTYPE_JSON, JSONBTYPE_JSONB, JSONBTYPE_JSONCAST, JSONBTYPE_NUMERIC, JSONBTYPE_TIMESTAMP, JSONBTYPE_TIMESTAMPTZ, makeJsonLexContext(), MAXDATELEN, NULL, numeric_in(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, OidFunctionCall1, OidOutputFunctionCall(), JsonbInState::parseState, pfree(), pg_parse_json(), POSTGRES_EPOCH_JDATE, pstrdup(), pushJsonbValue(), JsonbInState::res, Jsonb::root, JsonSemAction::scalar, JsonSemAction::semstate, timestamp2tm(), TIMESTAMP_NOT_FINITE, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, JsonbValue::type, USE_XSD_DATES, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by add_jsonb(), array_dim_to_jsonb(), composite_to_jsonb(), jsonb_agg_transfn(), jsonb_object_agg_transfn(), and to_jsonb().

{
    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 = DatumGetTextPP(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_agg_finalfn

(

PG_FUNCTION_ARGS

)

Definition at line 1681 of file jsonb.c.

References AggCheckCallContext(), arg, Assert, clone_parse_state(), JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, JsonbAggState::res, result, and WJB_END_ARRAY.

{
    JsonbAggState *arg;
    JsonbInState result;
    Jsonb      *out;

    /* cannot be called directly because of internal-type argument */
    Assert(AggCheckCallContext(fcinfo, NULL));

    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();       /* returns null iff no input values */

    arg = (JsonbAggState *) PG_GETARG_POINTER(0);

    /*
     * We need to do a shallow clone of the argument in case the final
     * function is called more than once, so we avoid changing the argument. A
     * shallow clone is sufficient as we aren't going to change any of the
     * values, just add the final array end marker.
     */

    result.parseState = clone_parse_state(arg->res->parseState);

    result.res = pushJsonbValue(&result.parseState,
                                WJB_END_ARRAY, NULL);

    out = JsonbValueToJsonb(result.res);

    PG_RETURN_POINTER(out);
}

Datum jsonb_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1563 of file jsonb.c.

References AggCheckCallContext(), buf, datum_to_jsonb(), DatumGetNumeric, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, jbvNumeric, jbvString, jsonb_categorize_type(), JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), MemoryContextSwitchTo(), NULL, numeric_uplus(), NumericGetDatum, palloc(), palloc0(), JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, JsonbAggState::res, result, Jsonb::root, snprintf(), JsonbValue::type, JsonbValue::val, val, JsonbAggState::val_category, JsonbAggState::val_output_func, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

{
    MemoryContext oldcontext,
                aggcontext;
    JsonbAggState *state;
    JsonbInState elem;
    Datum       val;
    JsonbInState *result;
    bool        single_scalar = false;
    JsonbIterator *it;
    Jsonb      *jbelem;
    JsonbValue  v;
    JsonbIteratorToken type;

    if (!AggCheckCallContext(fcinfo, &aggcontext))
    {
        /* cannot be called directly because of internal-type argument */
        elog(ERROR, "jsonb_agg_transfn called in non-aggregate context");
    }

    /* set up the accumulator on the first go round */

    if (PG_ARGISNULL(0))
    {
        Oid         arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);

        if (arg_type == InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine input data type")));

        oldcontext = MemoryContextSwitchTo(aggcontext);
        state = palloc(sizeof(JsonbAggState));
        result = palloc0(sizeof(JsonbInState));
        state->res = result;
        result->res = pushJsonbValue(&result->parseState,
                                     WJB_BEGIN_ARRAY, NULL);
        MemoryContextSwitchTo(oldcontext);

        jsonb_categorize_type(arg_type, &state->val_category,
                              &state->val_output_func);
    }
    else
    {
        state = (JsonbAggState *) PG_GETARG_POINTER(0);
        result = state->res;
    }

    /* turn the argument into jsonb in the normal function context */

    val = PG_ARGISNULL(1) ? (Datum) 0 : PG_GETARG_DATUM(1);

    memset(&elem, 0, sizeof(JsonbInState));

    datum_to_jsonb(val, PG_ARGISNULL(1), &elem, state->val_category,
                   state->val_output_func, false);

    jbelem = JsonbValueToJsonb(elem.res);

    /* switch to the aggregate context for accumulation operations */

    oldcontext = MemoryContextSwitchTo(aggcontext);

    it = JsonbIteratorInit(&jbelem->root);

    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        switch (type)
        {
            case WJB_BEGIN_ARRAY:
                if (v.val.array.rawScalar)
                    single_scalar = true;
                else
                    result->res = pushJsonbValue(&result->parseState,
                                                 type, NULL);
                break;
            case WJB_END_ARRAY:
                if (!single_scalar)
                    result->res = pushJsonbValue(&result->parseState,
                                                 type, NULL);
                break;
            case WJB_BEGIN_OBJECT:
            case WJB_END_OBJECT:
                result->res = pushJsonbValue(&result->parseState,
                                             type, NULL);
                break;
            case WJB_ELEM:
            case WJB_KEY:
            case WJB_VALUE:
                if (v.type == jbvString)
                {
                    /* copy string values in the aggregate context */
                    char       *buf = palloc(v.val.string.len + 1);

                    snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
                    v.val.string.val = buf;
                }
                else if (v.type == jbvNumeric)
                {
                    /* same for numeric */
                    v.val.numeric =
                        DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
                                                            NumericGetDatum(v.val.numeric)));
                }
                result->res = pushJsonbValue(&result->parseState,
                                             type, &v);
                break;
            default:
                elog(ERROR, "unknown jsonb iterator token type");
        }
    }

    MemoryContextSwitchTo(oldcontext);

    PG_RETURN_POINTER(state);
}

Datum jsonb_build_array

(

PG_FUNCTION_ARGS

)

Definition at line 1267 of file jsonb.c.

References add_jsonb(), arg, CStringGetTextDatum, ereport, errcode(), errmsg(), ERROR, get_fn_expr_arg_stable(), get_fn_expr_argtype(), i, InvalidOid, JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_NARGS, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, TEXTOID, UNKNOWNOID, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

{
    int         nargs = PG_NARGS();
    int         i;
    Datum       arg;
    Oid         val_type;
    JsonbInState result;

    memset(&result, 0, sizeof(JsonbInState));

    result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_ARRAY, NULL);

    for (i = 0; i < nargs; i++)
    {
        val_type = get_fn_expr_argtype(fcinfo->flinfo, i);
        /* see comments in jsonb_build_object above */
        if (val_type == UNKNOWNOID && get_fn_expr_arg_stable(fcinfo->flinfo, i))
        {
            val_type = TEXTOID;
            if (PG_ARGISNULL(i))
                arg = (Datum) 0;
            else
                arg = CStringGetTextDatum(PG_GETARG_POINTER(i));
        }
        else
        {
            arg = PG_GETARG_DATUM(i);
        }
        if (val_type == InvalidOid || val_type == UNKNOWNOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine data type for argument %d", i + 1)));
        add_jsonb(arg, PG_ARGISNULL(i), &result, val_type, false);
    }

    result.res = pushJsonbValue(&result.parseState, WJB_END_ARRAY, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

Datum jsonb_build_array_noargs

(

PG_FUNCTION_ARGS

)

Definition at line 1311 of file jsonb.c.

References JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

{
    JsonbInState result;

    memset(&result, 0, sizeof(JsonbInState));

    (void) pushJsonbValue(&result.parseState, WJB_BEGIN_ARRAY, NULL);
    result.res = pushJsonbValue(&result.parseState, WJB_END_ARRAY, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

Datum jsonb_build_object

(

PG_FUNCTION_ARGS

)

Definition at line 1172 of file jsonb.c.

References add_jsonb(), arg, CStringGetTextDatum, ereport, errcode(), errmsg(), ERROR, get_fn_expr_arg_stable(), get_fn_expr_argtype(), i, InvalidOid, JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_NARGS, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, TEXTOID, UNKNOWNOID, WJB_BEGIN_OBJECT, and WJB_END_OBJECT.

{
    int         nargs = PG_NARGS();
    int         i;
    Datum       arg;
    Oid         val_type;
    JsonbInState result;

    if (nargs % 2 != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid number of arguments: object must be matched key value pairs")));

    memset(&result, 0, sizeof(JsonbInState));

    result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);

    for (i = 0; i < nargs; i += 2)
    {
        /* process key */

        if (PG_ARGISNULL(i))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("argument %d: key must not be null", i + 1)));
        val_type = get_fn_expr_argtype(fcinfo->flinfo, i);

        /*
         * turn a constant (more or less literal) value that's of unknown type
         * into text. Unknowns come in as a cstring pointer.
         */
        if (val_type == UNKNOWNOID && get_fn_expr_arg_stable(fcinfo->flinfo, i))
        {
            val_type = TEXTOID;
            arg = CStringGetTextDatum(PG_GETARG_POINTER(i));
        }
        else
        {
            arg = PG_GETARG_DATUM(i);
        }
        if (val_type == InvalidOid || val_type == UNKNOWNOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine data type for argument %d", i + 1)));

        add_jsonb(arg, false, &result, val_type, true);

        /* process value */

        val_type = get_fn_expr_argtype(fcinfo->flinfo, i + 1);
        /* see comments above */
        if (val_type == UNKNOWNOID && get_fn_expr_arg_stable(fcinfo->flinfo, i + 1))
        {
            val_type = TEXTOID;
            if (PG_ARGISNULL(i + 1))
                arg = (Datum) 0;
            else
                arg = CStringGetTextDatum(PG_GETARG_POINTER(i + 1));
        }
        else
        {
            arg = PG_GETARG_DATUM(i + 1);
        }
        if (val_type == InvalidOid || val_type == UNKNOWNOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine data type for argument %d", i + 2)));
        add_jsonb(arg, PG_ARGISNULL(i + 1), &result, val_type, false);
    }

    result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

Datum jsonb_build_object_noargs

(

PG_FUNCTION_ARGS

)

Definition at line 1251 of file jsonb.c.

References JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, WJB_BEGIN_OBJECT, and WJB_END_OBJECT.

{
    JsonbInState result;

    memset(&result, 0, sizeof(JsonbInState));

    (void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
    result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

static void jsonb_categorize_type ( Oid  typoid, JsonbTypeCategory *  tcategory, Oid *  outfuncoid  )

static

Definition at line 591 of file jsonb.c.

References ANYARRAYOID, BOOLOID, COERCION_EXPLICIT, COERCION_PATH_FUNC, DATEOID, find_coercion_pathway(), FirstNormalObjectId, FLOAT4OID, FLOAT8OID, get_element_type(), getBaseType(), getTypeOutputInfo(), INT2OID, INT4OID, INT8OID, InvalidOid, JSONBOID, JSONBTYPE_ARRAY, JSONBTYPE_BOOL, JSONBTYPE_COMPOSITE, JSONBTYPE_DATE, JSONBTYPE_JSON, JSONBTYPE_JSONB, JSONBTYPE_JSONCAST, JSONBTYPE_NUMERIC, JSONBTYPE_OTHER, JSONBTYPE_TIMESTAMP, JSONBTYPE_TIMESTAMPTZ, JSONOID, NUMERICOID, OidIsValid, RECORDARRAYOID, TIMESTAMPOID, TIMESTAMPTZOID, and type_is_rowtype().

Referenced by add_jsonb(), array_to_jsonb_internal(), composite_to_jsonb(), jsonb_agg_transfn(), jsonb_object_agg_transfn(), and to_jsonb().

{
    bool        typisvarlena;

    /* Look through any domain */
    typoid = getBaseType(typoid);

    *outfuncoid = InvalidOid;

    /*
     * We need to get the output function for everything except date and
     * timestamp types, booleans, array and composite types, json and jsonb,
     * and non-builtin types where there's a cast to json. In this last case
     * we return the oid of the cast function instead.
     */

    switch (typoid)
    {
        case BOOLOID:
            *tcategory = JSONBTYPE_BOOL;
            break;

        case INT2OID:
        case INT4OID:
        case INT8OID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = JSONBTYPE_NUMERIC;
            break;

        case DATEOID:
            *tcategory = JSONBTYPE_DATE;
            break;

        case TIMESTAMPOID:
            *tcategory = JSONBTYPE_TIMESTAMP;
            break;

        case TIMESTAMPTZOID:
            *tcategory = JSONBTYPE_TIMESTAMPTZ;
            break;

        case JSONBOID:
            *tcategory = JSONBTYPE_JSONB;
            break;

        case JSONOID:
            *tcategory = JSONBTYPE_JSON;
            break;

        default:
            /* Check for arrays and composites */
            if (OidIsValid(get_element_type(typoid)) || typoid == ANYARRAYOID
                || typoid == RECORDARRAYOID)
                *tcategory = JSONBTYPE_ARRAY;
            else if (type_is_rowtype(typoid))   /* includes RECORDOID */
                *tcategory = JSONBTYPE_COMPOSITE;
            else
            {
                /* It's probably the general case ... */
                *tcategory = JSONBTYPE_OTHER;

                /*
                 * but first let's look for a cast to json (note: not to
                 * jsonb) if it's not built-in.
                 */
                if (typoid >= FirstNormalObjectId)
                {
                    Oid         castfunc;
                    CoercionPathType ctype;

                    ctype = find_coercion_pathway(JSONOID, typoid,
                                                  COERCION_EXPLICIT, &castfunc);
                    if (ctype == COERCION_PATH_FUNC && OidIsValid(castfunc))
                    {
                        *tcategory = JSONBTYPE_JSONCAST;
                        *outfuncoid = castfunc;
                    }
                    else
                    {
                        /* not a cast type, so just get the usual output func */
                        getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                    }
                }
                else
                {
                    /* any other builtin type */
                    getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                }
                break;
            }
    }
}

static Datum jsonb_from_cstring ( char *  json, int  len  )

inlinestatic

Definition at line 226 of file jsonb.c.

References JsonSemAction::array_end, JsonSemAction::array_start, jsonb_in_array_end(), jsonb_in_array_start(), jsonb_in_object_end(), jsonb_in_object_field_start(), jsonb_in_object_start(), jsonb_in_scalar(), JsonbValueToJsonb(), makeJsonLexContextCstringLen(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, pg_parse_json(), PG_RETURN_POINTER, JsonbInState::res, JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by jsonb_in(), and jsonb_recv().

{
    JsonLexContext *lex;
    JsonbInState state;
    JsonSemAction sem;

    memset(&state, 0, sizeof(state));
    memset(&sem, 0, sizeof(sem));
    lex = makeJsonLexContextCstringLen(json, len, true);

    sem.semstate = (void *) &state;

    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);

    /* after parsing, the item member has the composed jsonb structure */
    PG_RETURN_POINTER(JsonbValueToJsonb(state.res));
}

Datum jsonb_in

(

PG_FUNCTION_ARGS

)

Definition at line 96 of file jsonb.c.

References jsonb_from_cstring(), and PG_GETARG_CSTRING.

{
    char       *json = PG_GETARG_CSTRING(0);

    return jsonb_from_cstring(json, strlen(json));
}

static void jsonb_in_array_end ( void *  pstate )

static

Definition at line 289 of file jsonb.c.

References NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, and WJB_END_ARRAY.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;

    _state->res = pushJsonbValue(&_state->parseState, WJB_END_ARRAY, NULL);
}

static void jsonb_in_array_start ( void *  pstate )

static

Definition at line 281 of file jsonb.c.

References NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, and WJB_BEGIN_ARRAY.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;

    _state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_ARRAY, NULL);
}

static void jsonb_in_object_end ( void *  pstate )

static

Definition at line 273 of file jsonb.c.

References NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, and WJB_END_OBJECT.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;

    _state->res = pushJsonbValue(&_state->parseState, WJB_END_OBJECT, NULL);
}

static void jsonb_in_object_field_start ( void *  pstate, char *  fname, bool  isnull  )

static

Definition at line 297 of file jsonb.c.

References Assert, checkStringLen(), jbvString, NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, JsonbValue::type, JsonbValue::val, and WJB_KEY.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;
    JsonbValue  v;

    Assert(fname != NULL);
    v.type = jbvString;
    v.val.string.len = checkStringLen(strlen(fname));
    v.val.string.val = fname;

    _state->res = pushJsonbValue(&_state->parseState, WJB_KEY, &v);
}

static void jsonb_in_object_start ( void *  pstate )

static

Definition at line 265 of file jsonb.c.

References NULL, JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, and WJB_BEGIN_OBJECT.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;

    _state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_OBJECT, NULL);
}

static void jsonb_in_scalar ( void *  pstate, char *  token, JsonTokenType  tokentype  )

static

Definition at line 341 of file jsonb.c.

References Assert, checkStringLen(), JsonbParseState::contVal, CStringGetDatum, DatumGetNumeric, DirectFunctionCall3, elog, ERROR, jbvArray, jbvBool, jbvNull, jbvNumeric, jbvObject, jbvString, JSON_TOKEN_FALSE, JSON_TOKEN_NULL, JSON_TOKEN_NUMBER, JSON_TOKEN_STRING, JSON_TOKEN_TRUE, NULL, numeric_in(), JsonbInState::parseState, pushJsonbValue(), JsonbInState::res, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_ELEM, WJB_END_ARRAY, and WJB_VALUE.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

{
    JsonbInState *_state = (JsonbInState *) pstate;
    JsonbValue  v;

    switch (tokentype)
    {

        case JSON_TOKEN_STRING:
            Assert(token != NULL);
            v.type = jbvString;
            v.val.string.len = checkStringLen(strlen(token));
            v.val.string.val = token;
            break;
        case JSON_TOKEN_NUMBER:

            /*
             * No need to check size of numeric values, because maximum
             * numeric size is well below the JsonbValue restriction
             */
            Assert(token != NULL);
            v.type = jbvNumeric;
            v.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(token), 0, -1));

            break;
        case JSON_TOKEN_TRUE:
            v.type = jbvBool;
            v.val.boolean = true;

            break;
        case JSON_TOKEN_FALSE:
            v.type = jbvBool;
            v.val.boolean = false;

            break;
        case JSON_TOKEN_NULL:
            v.type = jbvNull;
            break;
        default:
            /* should not be possible */
            elog(ERROR, "invalid json token type");
            break;
    }

    if (_state->parseState == NULL)
    {
        /* single scalar */
        JsonbValue  va;

        va.type = jbvArray;
        va.val.array.rawScalar = true;
        va.val.array.nElems = 1;

        _state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_ARRAY, &va);
        _state->res = pushJsonbValue(&_state->parseState, WJB_ELEM, &v);
        _state->res = pushJsonbValue(&_state->parseState, WJB_END_ARRAY, NULL);
    }
    else
    {
        JsonbValue *o = &_state->parseState->contVal;

        switch (o->type)
        {
            case jbvArray:
                _state->res = pushJsonbValue(&_state->parseState, WJB_ELEM, &v);
                break;
            case jbvObject:
                _state->res = pushJsonbValue(&_state->parseState, WJB_VALUE, &v);
                break;
            default:
                elog(ERROR, "unexpected parent of nested structure");
        }
    }
}

Datum jsonb_object

(

PG_FUNCTION_ARGS

)

Definition at line 1332 of file jsonb.c.

References ARR_DIMS, ARR_NDIM, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), NULL, JsonbInState::parseState, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, TextDatumGetCString, TEXTOID, JsonbValue::type, JsonbValue::val, WJB_BEGIN_OBJECT, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

{
    ArrayType  *in_array = PG_GETARG_ARRAYTYPE_P(0);
    int         ndims = ARR_NDIM(in_array);
    Datum      *in_datums;
    bool       *in_nulls;
    int         in_count,
                count,
                i;
    JsonbInState result;

    memset(&result, 0, sizeof(JsonbInState));

    (void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);

    switch (ndims)
    {
        case 0:
            goto close_object;
            break;

        case 1:
            if ((ARR_DIMS(in_array)[0]) % 2)
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("array must have even number of elements")));
            break;

        case 2:
            if ((ARR_DIMS(in_array)[1]) != 2)
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("array must have two columns")));
            break;

        default:
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("wrong number of array subscripts")));
    }

    deconstruct_array(in_array,
                      TEXTOID, -1, false, 'i',
                      &in_datums, &in_nulls, &in_count);

    count = in_count / 2;

    for (i = 0; i < count; ++i)
    {
        JsonbValue  v;
        char       *str;
        int         len;

        if (in_nulls[i * 2])
            ereport(ERROR,
                    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                     errmsg("null value not allowed for object key")));

        str = TextDatumGetCString(in_datums[i * 2]);
        len = strlen(str);

        v.type = jbvString;

        v.val.string.len = len;
        v.val.string.val = str;

        (void) pushJsonbValue(&result.parseState, WJB_KEY, &v);

        if (in_nulls[i * 2 + 1])
        {
            v.type = jbvNull;
        }
        else
        {
            str = TextDatumGetCString(in_datums[i * 2 + 1]);
            len = strlen(str);

            v.type = jbvString;

            v.val.string.len = len;
            v.val.string.val = str;
        }

        (void) pushJsonbValue(&result.parseState, WJB_VALUE, &v);
    }

    pfree(in_datums);
    pfree(in_nulls);

close_object:
    result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

Datum jsonb_object_agg_finalfn

(

PG_FUNCTION_ARGS

)

Definition at line 1912 of file jsonb.c.

References AggCheckCallContext(), arg, Assert, clone_parse_state(), JsonbValueToJsonb(), NULL, JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, JsonbAggState::res, result, and WJB_END_OBJECT.

{
    JsonbAggState *arg;
    JsonbInState result;
    Jsonb      *out;

    /* cannot be called directly because of internal-type argument */
    Assert(AggCheckCallContext(fcinfo, NULL));

    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();       /* returns null iff no input values */

    arg = (JsonbAggState *) PG_GETARG_POINTER(0);

    /*
     * We need to do a shallow clone of the argument's res field in case the
     * final function is called more than once, so we avoid changing the
     * aggregate state value.  A shallow clone is sufficient as we aren't
     * going to change any of the values, just add the final object end
     * marker.
     */

    result.parseState = clone_parse_state(arg->res->parseState);

    result.res = pushJsonbValue(&result.parseState,
                                WJB_END_OBJECT, NULL);

    out = JsonbValueToJsonb(result.res);

    PG_RETURN_POINTER(out);
}

Datum jsonb_object_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1716 of file jsonb.c.

References AggCheckCallContext(), buf, datum_to_jsonb(), DatumGetNumeric, DirectFunctionCall1, elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, jbvNumeric, jbvString, jsonb_categorize_type(), JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), JsonbAggState::key_category, JsonbAggState::key_output_func, MemoryContextSwitchTo(), NULL, numeric_uplus(), NumericGetDatum, palloc(), palloc0(), JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, JsonbAggState::res, result, Jsonb::root, snprintf(), JsonbValue::type, JsonbValue::val, val, JsonbAggState::val_category, JsonbAggState::val_output_func, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

{
    MemoryContext oldcontext,
                aggcontext;
    JsonbInState elem;
    JsonbAggState *state;
    Datum       val;
    JsonbInState *result;
    bool        single_scalar;
    JsonbIterator *it;
    Jsonb      *jbkey,
               *jbval;
    JsonbValue  v;
    JsonbIteratorToken type;

    if (!AggCheckCallContext(fcinfo, &aggcontext))
    {
        /* cannot be called directly because of internal-type argument */
        elog(ERROR, "jsonb_object_agg_transfn called in non-aggregate context");
    }

    /* set up the accumulator on the first go round */

    if (PG_ARGISNULL(0))
    {
        Oid         arg_type;

        oldcontext = MemoryContextSwitchTo(aggcontext);
        state = palloc(sizeof(JsonbAggState));
        result = palloc0(sizeof(JsonbInState));
        state->res = result;
        result->res = pushJsonbValue(&result->parseState,
                                     WJB_BEGIN_OBJECT, NULL);
        MemoryContextSwitchTo(oldcontext);

        arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);

        if (arg_type == InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine input data type")));

        jsonb_categorize_type(arg_type, &state->key_category,
                              &state->key_output_func);

        arg_type = get_fn_expr_argtype(fcinfo->flinfo, 2);

        if (arg_type == InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not determine input data type")));

        jsonb_categorize_type(arg_type, &state->val_category,
                              &state->val_output_func);
    }
    else
    {
        state = (JsonbAggState *) PG_GETARG_POINTER(0);
        result = state->res;
    }

    /* turn the argument into jsonb in the normal function context */

    if (PG_ARGISNULL(1))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("field name must not be null")));

    val = PG_GETARG_DATUM(1);

    memset(&elem, 0, sizeof(JsonbInState));

    datum_to_jsonb(val, false, &elem, state->key_category,
                   state->key_output_func, true);

    jbkey = JsonbValueToJsonb(elem.res);

    val = PG_ARGISNULL(2) ? (Datum) 0 : PG_GETARG_DATUM(2);

    memset(&elem, 0, sizeof(JsonbInState));

    datum_to_jsonb(val, PG_ARGISNULL(2), &elem, state->val_category,
                   state->val_output_func, false);

    jbval = JsonbValueToJsonb(elem.res);

    it = JsonbIteratorInit(&jbkey->root);

    /* switch to the aggregate context for accumulation operations */

    oldcontext = MemoryContextSwitchTo(aggcontext);

    /*
     * keys should be scalar, and we should have already checked for that
     * above when calling datum_to_jsonb, so we only need to look for these
     * things.
     */

    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        switch (type)
        {
            case WJB_BEGIN_ARRAY:
                if (!v.val.array.rawScalar)
                    elog(ERROR, "unexpected structure for key");
                break;
            case WJB_ELEM:
                if (v.type == jbvString)
                {
                    /* copy string values in the aggregate context */
                    char       *buf = palloc(v.val.string.len + 1);

                    snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
                    v.val.string.val = buf;
                }
                else
                {
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("object keys must be strings")));
                }
                result->res = pushJsonbValue(&result->parseState,
                                             WJB_KEY, &v);
                break;
            case WJB_END_ARRAY:
                break;
            default:
                elog(ERROR, "unexpected structure for key");
                break;
        }
    }

    it = JsonbIteratorInit(&jbval->root);

    single_scalar = false;

    /*
     * values can be anything, including structured and null, so we treat them
     * as in json_agg_transfn, except that single scalars are always pushed as
     * WJB_VALUE items.
     */

    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        switch (type)
        {
            case WJB_BEGIN_ARRAY:
                if (v.val.array.rawScalar)
                    single_scalar = true;
                else
                    result->res = pushJsonbValue(&result->parseState,
                                                 type, NULL);
                break;
            case WJB_END_ARRAY:
                if (!single_scalar)
                    result->res = pushJsonbValue(&result->parseState,
                                                 type, NULL);
                break;
            case WJB_BEGIN_OBJECT:
            case WJB_END_OBJECT:
                result->res = pushJsonbValue(&result->parseState,
                                             type, NULL);
                break;
            case WJB_ELEM:
            case WJB_KEY:
            case WJB_VALUE:
                if (v.type == jbvString)
                {
                    /* copy string values in the aggregate context */
                    char       *buf = palloc(v.val.string.len + 1);

                    snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
                    v.val.string.val = buf;
                }
                else if (v.type == jbvNumeric)
                {
                    /* same for numeric */
                    v.val.numeric =
                        DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
                                                            NumericGetDatum(v.val.numeric)));
                }
                result->res = pushJsonbValue(&result->parseState,
                                             single_scalar ? WJB_VALUE : type,
                                             &v);
                break;
            default:
                elog(ERROR, "unknown jsonb iterator token type");
        }
    }

    MemoryContextSwitchTo(oldcontext);

    PG_RETURN_POINTER(state);
}

Datum jsonb_object_two_arg

(

PG_FUNCTION_ARGS

)

Definition at line 1434 of file jsonb.c.

References ARR_NDIM, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), NULL, JsonbInState::parseState, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, result, TextDatumGetCString, TEXTOID, JsonbValue::type, JsonbValue::val, WJB_BEGIN_OBJECT, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

{
    ArrayType  *key_array = PG_GETARG_ARRAYTYPE_P(0);
    ArrayType  *val_array = PG_GETARG_ARRAYTYPE_P(1);
    int         nkdims = ARR_NDIM(key_array);
    int         nvdims = ARR_NDIM(val_array);
    Datum      *key_datums,
               *val_datums;
    bool       *key_nulls,
               *val_nulls;
    int         key_count,
                val_count,
                i;
    JsonbInState result;

    memset(&result, 0, sizeof(JsonbInState));

    (void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);

    if (nkdims > 1 || nkdims != nvdims)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));

    if (nkdims == 0)
        goto close_object;

    deconstruct_array(key_array,
                      TEXTOID, -1, false, 'i',
                      &key_datums, &key_nulls, &key_count);

    deconstruct_array(val_array,
                      TEXTOID, -1, false, 'i',
                      &val_datums, &val_nulls, &val_count);

    if (key_count != val_count)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("mismatched array dimensions")));

    for (i = 0; i < key_count; ++i)
    {
        JsonbValue  v;
        char       *str;
        int         len;

        if (key_nulls[i])
            ereport(ERROR,
                    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                     errmsg("null value not allowed for object key")));

        str = TextDatumGetCString(key_datums[i]);
        len = strlen(str);

        v.type = jbvString;

        v.val.string.len = len;
        v.val.string.val = str;

        (void) pushJsonbValue(&result.parseState, WJB_KEY, &v);

        if (val_nulls[i])
        {
            v.type = jbvNull;
        }
        else
        {
            str = TextDatumGetCString(val_datums[i]);
            len = strlen(str);

            v.type = jbvString;

            v.val.string.len = len;
            v.val.string.val = str;
        }

        (void) pushJsonbValue(&result.parseState, WJB_VALUE, &v);
    }

    pfree(key_datums);
    pfree(key_nulls);
    pfree(val_datums);
    pfree(val_nulls);

close_object:
    result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}

Datum jsonb_out

(

PG_FUNCTION_ARGS

)

Definition at line 131 of file jsonb.c.

References JsonbToCString(), NULL, PG_GETARG_JSONB, PG_RETURN_CSTRING, Jsonb::root, and VARSIZE.

{
    Jsonb      *jb = PG_GETARG_JSONB(0);
    char       *out;

    out = JsonbToCString(NULL, &jb->root, VARSIZE(jb));

    PG_RETURN_CSTRING(out);
}

static void jsonb_put_escaped_value ( StringInfo  out, JsonbValue *  scalarVal  )

static

Definition at line 311 of file jsonb.c.

References appendBinaryStringInfo(), appendStringInfoString(), DatumGetCString, DirectFunctionCall1, elog, ERROR, escape_json(), jbvBool, jbvNull, jbvNumeric, jbvString, numeric_out(), pnstrdup(), PointerGetDatum, JsonbValue::type, and JsonbValue::val.

Referenced by JsonbToCStringWorker().

{
    switch (scalarVal->type)
    {
        case jbvNull:
            appendBinaryStringInfo(out, "null", 4);
            break;
        case jbvString:
            escape_json(out, pnstrdup(scalarVal->val.string.val, scalarVal->val.string.len));
            break;
        case jbvNumeric:
            appendStringInfoString(out,
                                   DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                       PointerGetDatum(scalarVal->val.numeric))));
            break;
        case jbvBool:
            if (scalarVal->val.boolean)
                appendBinaryStringInfo(out, "true", 4);
            else
                appendBinaryStringInfo(out, "false", 5);
            break;
        default:
            elog(ERROR, "unknown jsonb scalar type");
    }
}

Datum jsonb_recv

(

PG_FUNCTION_ARGS

)

Definition at line 112 of file jsonb.c.

References buf, StringInfoData::cursor, elog, ERROR, jsonb_from_cstring(), StringInfoData::len, PG_GETARG_POINTER, pq_getmsgint(), and pq_getmsgtext().

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    int         version = pq_getmsgint(buf, 1);
    char       *str;
    int         nbytes;

    if (version == 1)
        str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
    else
        elog(ERROR, "unsupported jsonb version number %d", version);

    return jsonb_from_cstring(str, nbytes);
}

Datum jsonb_send

(

PG_FUNCTION_ARGS

)

Definition at line 147 of file jsonb.c.

References buf, StringInfoData::data, JsonbToCString(), StringInfoData::len, makeStringInfo(), pfree(), PG_GETARG_JSONB, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint(), pq_sendtext(), Jsonb::root, and VARSIZE.

{
    Jsonb      *jb = PG_GETARG_JSONB(0);
    StringInfoData buf;
    StringInfo  jtext = makeStringInfo();
    int         version = 1;

    (void) JsonbToCString(jtext, &jb->root, VARSIZE(jb));

    pq_begintypsend(&buf);
    pq_sendint(&buf, version, 1);
    pq_sendtext(&buf, jtext->data, jtext->len);
    pfree(jtext->data);
    pfree(jtext);

    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

Datum jsonb_typeof

(

PG_FUNCTION_ARGS

)

Definition at line 172 of file jsonb.c.

References Assert, cstring_to_text(), elog, ERROR, JB_ROOT_IS_ARRAY, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, jbvArray, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), PG_GETARG_JSONB, PG_RETURN_TEXT_P, result, Jsonb::root, and JsonbValue::type.

{
    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(&in->root);

        /*
         * 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));
}

char* JsonbToCString	(	StringInfo	out,
		JsonbContainer *	in,
		int	estimated_len
	)

Definition at line 428 of file jsonb.c.

References JsonbToCStringWorker().

Referenced by each_worker_jsonb(), elements_worker_jsonb(), get_jsonb_path_all(), jsonb_array_element_text(), jsonb_object_field_text(), jsonb_out(), jsonb_send(), and populate_scalar().

{
    return JsonbToCStringWorker(out, in, estimated_len, false);
}

char* JsonbToCStringIndent	(	StringInfo	out,
		JsonbContainer *	in,
		int	estimated_len
	)

Definition at line 437 of file jsonb.c.

References JsonbToCStringWorker().

Referenced by jsonb_pretty().

{
    return JsonbToCStringWorker(out, in, estimated_len, true);
}

static char * JsonbToCStringWorker ( StringInfo  out, JsonbContainer *  in, int  estimated_len, bool  indent  )

static

Definition at line 446 of file jsonb.c.

References add_indent(), appendBinaryStringInfo(), appendStringInfoCharMacro, Assert, StringInfoData::data, elog, enlargeStringInfo(), ERROR, jsonb_put_escaped_value(), JsonbIteratorInit(), JsonbIteratorNext(), makeStringInfo(), NULL, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by JsonbToCString(), and JsonbToCStringIndent().

{
    bool        first = true;
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type = WJB_DONE;
    int         level = 0;
    bool        redo_switch = false;

    /* If we are indenting, don't add a space after a comma */
    int         ispaces = indent ? 1 : 2;

    /*
     * Don't indent the very first item. This gets set to the indent flag at
     * the bottom of the loop.
     */
    bool        use_indent = false;
    bool        raw_scalar = false;
    bool        last_was_key = false;

    if (out == NULL)
        out = makeStringInfo();

    enlargeStringInfo(out, (estimated_len >= 0) ? estimated_len : 64);

    it = JsonbIteratorInit(in);

    while (redo_switch ||
           ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE))
    {
        redo_switch = false;
        switch (type)
        {
            case WJB_BEGIN_ARRAY:
                if (!first)
                    appendBinaryStringInfo(out, ", ", ispaces);

                if (!v.val.array.rawScalar)
                {
                    add_indent(out, use_indent && !last_was_key, level);
                    appendStringInfoCharMacro(out, '[');
                }
                else
                    raw_scalar = true;

                first = true;
                level++;
                break;
            case WJB_BEGIN_OBJECT:
                if (!first)
                    appendBinaryStringInfo(out, ", ", ispaces);

                add_indent(out, use_indent && !last_was_key, level);
                appendStringInfoCharMacro(out, '{');

                first = true;
                level++;
                break;
            case WJB_KEY:
                if (!first)
                    appendBinaryStringInfo(out, ", ", ispaces);
                first = true;

                add_indent(out, use_indent, level);

                /* json rules guarantee this is a string */
                jsonb_put_escaped_value(out, &v);
                appendBinaryStringInfo(out, ": ", 2);

                type = JsonbIteratorNext(&it, &v, false);
                if (type == WJB_VALUE)
                {
                    first = false;
                    jsonb_put_escaped_value(out, &v);
                }
                else
                {
                    Assert(type == WJB_BEGIN_OBJECT || type == WJB_BEGIN_ARRAY);

                    /*
                     * We need to rerun the current switch() since we need to
                     * output the object which we just got from the iterator
                     * before calling the iterator again.
                     */
                    redo_switch = true;
                }
                break;
            case WJB_ELEM:
                if (!first)
                    appendBinaryStringInfo(out, ", ", ispaces);
                first = false;

                if (!raw_scalar)
                    add_indent(out, use_indent, level);
                jsonb_put_escaped_value(out, &v);
                break;
            case WJB_END_ARRAY:
                level--;
                if (!raw_scalar)
                {
                    add_indent(out, use_indent, level);
                    appendStringInfoCharMacro(out, ']');
                }
                first = false;
                break;
            case WJB_END_OBJECT:
                level--;
                add_indent(out, use_indent, level);
                appendStringInfoCharMacro(out, '}');
                first = false;
                break;
            default:
                elog(ERROR, "unknown jsonb iterator token type");
        }
        use_indent = indent;
        last_was_key = redo_switch;
    }

    Assert(level == 0);

    return out->data;
}

Datum to_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 1145 of file jsonb.c.

References datum_to_jsonb(), ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, jsonb_categorize_type(), JsonbValueToJsonb(), PG_GETARG_DATUM, PG_RETURN_POINTER, JsonbInState::res, result, and val.

{
    Datum       val = PG_GETARG_DATUM(0);
    Oid         val_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
    JsonbInState result;
    JsonbTypeCategory tcategory;
    Oid         outfuncoid;

    if (val_type == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("could not determine input data type")));

    jsonb_categorize_type(val_type,
                          &tcategory, &outfuncoid);

    memset(&result, 0, sizeof(JsonbInState));

    datum_to_jsonb(val, false, &result, tcategory, outfuncoid, false);

    PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
}