jsonb.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/json.h"
#include "utils/jsonb.h"
#include "utils/jsonfuncs.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"

Include dependency graph for jsonb.c:

Go to the source code of this file.

Data Structures
struct	JsonbAggState

Typedefs
typedef struct JsonbAggState	JsonbAggState

Functions
static Datum	jsonb_from_cstring (char *json, int len, bool unique_keys, Node *escontext)
static bool	checkStringLen (size_t len, Node *escontext)
static JsonParseErrorType	jsonb_in_object_start (void *pstate)
static JsonParseErrorType	jsonb_in_object_end (void *pstate)
static JsonParseErrorType	jsonb_in_array_start (void *pstate)
static JsonParseErrorType	jsonb_in_array_end (void *pstate)
static JsonParseErrorType	jsonb_in_object_field_start (void *pstate, char *fname, bool isnull)
static void	jsonb_put_escaped_value (StringInfo out, JsonbValue *scalarVal)
static JsonParseErrorType	jsonb_in_scalar (void *pstate, char *token, JsonTokenType tokentype)
static void	composite_to_jsonb (Datum composite, JsonbInState *result)
static void	array_dim_to_jsonb (JsonbInState *result, int dim, int ndims, int *dims, const Datum *vals, const bool *nulls, int *valcount, JsonTypeCategory tcategory, Oid outfuncoid)
static void	array_to_jsonb_internal (Datum array, JsonbInState *result)
static void	datum_to_jsonb_internal (Datum val, bool is_null, JsonbInState *result, JsonTypeCategory tcategory, Oid outfuncoid, bool key_scalar)
static void	add_jsonb (Datum val, bool is_null, JsonbInState *result, Oid val_type, bool key_scalar)
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_from_text (text *js, bool unique_keys)
static const char *	JsonbContainerTypeName (JsonbContainer *jbc)
const char *	JsonbTypeName (JsonbValue *val)
Datum	jsonb_typeof (PG_FUNCTION_ARGS)
char *	JsonbToCString (StringInfo out, JsonbContainer *in, int estimated_len)
char *	JsonbToCStringIndent (StringInfo out, JsonbContainer *in, int estimated_len)
bool	to_jsonb_is_immutable (Oid typoid)
Datum	to_jsonb (PG_FUNCTION_ARGS)
Datum	datum_to_jsonb (Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
Datum	jsonb_build_object_worker (int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null, bool unique_keys)
Datum	jsonb_build_object (PG_FUNCTION_ARGS)
Datum	jsonb_build_object_noargs (PG_FUNCTION_ARGS)
Datum	jsonb_build_array_worker (int nargs, const Datum *args, const bool *nulls, const Oid *types, bool absent_on_null)
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)
static Datum	jsonb_agg_transfn_worker (FunctionCallInfo fcinfo, bool absent_on_null)
Datum	jsonb_agg_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_agg_strict_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_agg_finalfn (PG_FUNCTION_ARGS)
static Datum	jsonb_object_agg_transfn_worker (FunctionCallInfo fcinfo, bool absent_on_null, bool unique_keys)
Datum	jsonb_object_agg_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_strict_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_unique_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_unique_strict_transfn (PG_FUNCTION_ARGS)
Datum	jsonb_object_agg_finalfn (PG_FUNCTION_ARGS)
bool	JsonbExtractScalar (JsonbContainer *jbc, JsonbValue *res)
static void	cannotCastJsonbValue (enum jbvType type, const char *sqltype)
Datum	jsonb_bool (PG_FUNCTION_ARGS)
Datum	jsonb_numeric (PG_FUNCTION_ARGS)
Datum	jsonb_int2 (PG_FUNCTION_ARGS)
Datum	jsonb_int4 (PG_FUNCTION_ARGS)
Datum	jsonb_int8 (PG_FUNCTION_ARGS)
Datum	jsonb_float4 (PG_FUNCTION_ARGS)
Datum	jsonb_float8 (PG_FUNCTION_ARGS)
char *	JsonbUnquote (Jsonb *jb)

Typedef Documentation

JsonbAggState

typedef struct JsonbAggState JsonbAggState

Function Documentation

add_indent()

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

static

Definition at line 608 of file jsonb.c.

{
    if (indent)
    {
        appendStringInfoCharMacro(out, '\n');
        appendStringInfoSpaces(out, level * 4);
    }
}

References appendStringInfoCharMacro, and appendStringInfoSpaces().

Referenced by JsonbToCStringWorker().

add_jsonb()

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

static

Definition at line 1053 of file jsonb.c.

{
    JsonTypeCategory 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 = JSONTYPE_NULL;
        outfuncoid = InvalidOid;
    }
    else
        json_categorize_type(val_type, true,
                             &tcategory, &outfuncoid);
 
    datum_to_jsonb_internal(val, is_null, result, tcategory, outfuncoid,
                            key_scalar);
}

References datum_to_jsonb_internal(), ereport, errcode(), errmsg(), ERROR, InvalidOid, json_categorize_type(), JSONTYPE_NULL, and val.

Referenced by jsonb_build_array_worker(), and jsonb_build_object_worker().

array_dim_to_jsonb()

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

static

Definition at line 899 of file jsonb.c.

{
    int         i;
 
    Assert(dim < ndims);
 
    pushJsonbValue(result, WJB_BEGIN_ARRAY, NULL);
 
    for (i = 1; i <= dims[dim]; i++)
    {
        if (dim + 1 == ndims)
        {
            datum_to_jsonb_internal(vals[*valcount], nulls[*valcount], result, tcategory,
                                    outfuncoid, false);
            (*valcount)++;
        }
        else
        {
            array_dim_to_jsonb(result, dim + 1, ndims, dims, vals, nulls,
                               valcount, tcategory, outfuncoid);
        }
    }
 
    pushJsonbValue(result, WJB_END_ARRAY, NULL);
}

References array_dim_to_jsonb(), Assert(), datum_to_jsonb_internal(), i, pushJsonbValue(), WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by array_dim_to_jsonb(), and array_to_jsonb_internal().

array_to_jsonb_internal()

static void array_to_jsonb_internal ( Datum  array, JsonbInState *  result  )

static

Definition at line 931 of file jsonb.c.

{
    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;
    JsonTypeCategory tcategory;
    Oid         outfuncoid;
 
    ndim = ARR_NDIM(v);
    dim = ARR_DIMS(v);
    nitems = ArrayGetNItems(ndim, dim);
 
    if (nitems <= 0)
    {
        pushJsonbValue(result, WJB_BEGIN_ARRAY, NULL);
        pushJsonbValue(result, WJB_END_ARRAY, NULL);
        return;
    }
 
    get_typlenbyvalalign(element_type,
                         &typlen, &typbyval, &typalign);
 
    json_categorize_type(element_type, true,
                         &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);
}

References ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, array_dim_to_jsonb(), ArrayGetNItems(), DatumGetArrayTypeP, deconstruct_array(), get_typlenbyvalalign(), json_categorize_type(), nitems, pfree(), pushJsonbValue(), typalign, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by datum_to_jsonb_internal().

cannotCastJsonbValue()

static void cannotCastJsonbValue ( enum jbvType  type, const char *  sqltype  )

static

Definition at line 1818 of file jsonb.c.

{
    static const struct
    {
        enum jbvType type;
        const char *msg;
    }
                messages[] =
    {
        {jbvNull, gettext_noop("cannot cast jsonb null to type %s")},
        {jbvString, gettext_noop("cannot cast jsonb string to type %s")},
        {jbvNumeric, gettext_noop("cannot cast jsonb numeric to type %s")},
        {jbvBool, gettext_noop("cannot cast jsonb boolean to type %s")},
        {jbvArray, gettext_noop("cannot cast jsonb array to type %s")},
        {jbvObject, gettext_noop("cannot cast jsonb object to type %s")},
        {jbvBinary, gettext_noop("cannot cast jsonb array or object to type %s")}
    };
    int         i;
 
    for (i = 0; i < lengthof(messages); i++)
        if (messages[i].type == type)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg(messages[i].msg, sqltype)));
 
    /* should be unreachable */
    elog(ERROR, "unknown jsonb type: %d", (int) type);
}

References elog, ereport, errcode(), errmsg(), ERROR, gettext_noop, i, jbvArray, jbvBinary, jbvBool, jbvNull, jbvNumeric, jbvObject, jbvString, lengthof, and type.

Referenced by jsonb_bool(), jsonb_float4(), jsonb_float8(), jsonb_int2(), jsonb_int4(), jsonb_int8(), and jsonb_numeric().

checkStringLen()

static bool checkStringLen ( size_t  len, Node *  escontext  )

static

Definition at line 270 of file jsonb.c.

{
    if (len > JENTRY_OFFLENMASK)
        ereturn(escontext, false,
                (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 true;
}

References ereturn, errcode(), errdetail(), errmsg(), JENTRY_OFFLENMASK, and len.

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

composite_to_jsonb()

static void composite_to_jsonb ( Datum  composite, JsonbInState *  result  )

static

Definition at line 979 of file jsonb.c.

{
    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;
 
    pushJsonbValue(result, WJB_BEGIN_OBJECT, NULL);
 
    for (i = 0; i < tupdesc->natts; i++)
    {
        Datum       val;
        bool        isnull;
        char       *attname;
        JsonTypeCategory 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;
 
        pushJsonbValue(result, WJB_KEY, &v);
 
        val = heap_getattr(tuple, i + 1, tupdesc, &isnull);
 
        if (isnull)
        {
            tcategory = JSONTYPE_NULL;
            outfuncoid = InvalidOid;
        }
        else
            json_categorize_type(att->atttypid, true, &tcategory,
                                 &outfuncoid);
 
        datum_to_jsonb_internal(val, isnull, result, tcategory, outfuncoid,
                                false);
    }
 
    pushJsonbValue(result, WJB_END_OBJECT, NULL);
    ReleaseTupleDesc(tupdesc);
}

References attname, datum_to_jsonb_internal(), DatumGetHeapTupleHeader, heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), i, InvalidOid, jbvString, json_categorize_type(), JSONTYPE_NULL, lookup_rowtype_tupdesc(), NameStr, TupleDescData::natts, pushJsonbValue(), ReleaseTupleDesc, 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_internal().

datum_to_jsonb()

Datum datum_to_jsonb	(	Datum	val,
		JsonTypeCategory	tcategory,
		Oid	outfuncoid
	)

Definition at line 1149 of file jsonb.c.

{
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    datum_to_jsonb_internal(val, false, &result, tcategory, outfuncoid,
                            false);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References datum_to_jsonb_internal(), JsonbPGetDatum(), JsonbValueToJsonb(), JsonbInState::result, and val.

Referenced by ExecEvalJsonConstructor(), and to_jsonb().

datum_to_jsonb_internal()

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

static

Definition at line 631 of file jsonb.c.

{
    char       *outputstr;
    Numeric     numeric_val;
    bool        numeric_to_string;
    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 == JSONTYPE_ARRAY ||
              tcategory == JSONTYPE_COMPOSITE ||
              tcategory == JSONTYPE_JSON ||
              tcategory == JSONTYPE_JSONB ||
              tcategory == JSONTYPE_CAST))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("key value must be scalar, not array, composite, or json")));
    }
    else
    {
        switch (tcategory)
        {
            case JSONTYPE_ARRAY:
                array_to_jsonb_internal(val, result);
                break;
            case JSONTYPE_COMPOSITE:
                composite_to_jsonb(val, result);
                break;
            case JSONTYPE_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 JSONTYPE_NUMERIC:
                if (key_scalar)
                {
                    /* always stringify keys */
                    numeric_to_string = true;
                    numeric_val = NULL; /* pacify stupider compilers */
                }
                else
                {
                    Datum       numd;
 
                    switch (outfuncoid)
                    {
                        case F_NUMERIC_OUT:
                            numeric_val = DatumGetNumeric(val);
                            break;
                        case F_INT2OUT:
                            numeric_val = int64_to_numeric(DatumGetInt16(val));
                            break;
                        case F_INT4OUT:
                            numeric_val = int64_to_numeric(DatumGetInt32(val));
                            break;
                        case F_INT8OUT:
                            numeric_val = int64_to_numeric(DatumGetInt64(val));
                            break;
#ifdef NOT_USED
 
                            /*
                             * Ideally we'd short-circuit these two cases
                             * using float[48]_numeric.  However, those
                             * functions are currently slower than the generic
                             * coerce-via-I/O approach.  And they may round
                             * off differently.  Until/unless that gets fixed,
                             * continue to use coerce-via-I/O for floats.
                             */
                        case F_FLOAT4OUT:
                            numd = DirectFunctionCall1(float4_numeric, val);
                            numeric_val = DatumGetNumeric(numd);
                            break;
                        case F_FLOAT8OUT:
                            numd = DirectFunctionCall1(float8_numeric, val);
                            numeric_val = DatumGetNumeric(numd);
                            break;
#endif
                        default:
                            outputstr = OidOutputFunctionCall(outfuncoid, val);
                            numd = DirectFunctionCall3(numeric_in,
                                                       CStringGetDatum(outputstr),
                                                       ObjectIdGetDatum(InvalidOid),
                                                       Int32GetDatum(-1));
                            numeric_val = DatumGetNumeric(numd);
                            break;
                    }
                    /* Must convert to string if it's Inf or NaN */
                    numeric_to_string = (numeric_is_inf(numeric_val) ||
                                         numeric_is_nan(numeric_val));
                }
                if (numeric_to_string)
                {
                    outputstr = OidOutputFunctionCall(outfuncoid, val);
                    jb.type = jbvString;
                    jb.val.string.len = strlen(outputstr);
                    jb.val.string.val = outputstr;
                }
                else
                {
                    jb.type = jbvNumeric;
                    jb.val.numeric = numeric_val;
                }
                break;
            case JSONTYPE_DATE:
                jb.type = jbvString;
                jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                       DATEOID, NULL);
                jb.val.string.len = strlen(jb.val.string.val);
                break;
            case JSONTYPE_TIMESTAMP:
                jb.type = jbvString;
                jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                       TIMESTAMPOID, NULL);
                jb.val.string.len = strlen(jb.val.string.val);
                break;
            case JSONTYPE_TIMESTAMPTZ:
                jb.type = jbvString;
                jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                       TIMESTAMPTZOID, NULL);
                jb.val.string.len = strlen(jb.val.string.val);
                break;
            case JSONTYPE_CAST:
                /* cast to JSON, and then process as JSON */
                val = OidFunctionCall1(outfuncoid, val);
                /* FALL THROUGH */
            case JSONTYPE_JSON:
                {
                    /* parse the json right into the existing result object */
                    JsonLexContext lex;
                    JsonSemAction sem;
                    text       *json = DatumGetTextPP(val);
 
                    makeJsonLexContext(&lex, json, true);
 
                    memset(&sem, 0, sizeof(sem));
 
                    sem.semstate = 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_or_ereport(&lex, &sem);
                    freeJsonLexContext(&lex);
                }
                break;
            case JSONTYPE_JSONB:
                {
                    Jsonb      *jsonb = DatumGetJsonbP(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)
                                pushJsonbValue(result, type, NULL);
                            else
                                pushJsonbValue(result, type, &jb);
                        }
                    }
                }
                break;
            default:
                /* special-case text types to save useless palloc/memcpy ops */
                if (outfuncoid == F_TEXTOUT ||
                    outfuncoid == F_VARCHAROUT ||
                    outfuncoid == F_BPCHAROUT)
                {
                    text       *txt = DatumGetTextPP(val);
 
                    jb.val.string.len = VARSIZE_ANY_EXHDR(txt);
                    jb.val.string.val = VARDATA_ANY(txt);
                }
                else
                {
                    outputstr = OidOutputFunctionCall(outfuncoid, val);
                    jb.val.string.len = strlen(outputstr);
                    jb.val.string.val = outputstr;
                }
                jb.type = jbvString;
                (void) checkStringLen(jb.val.string.len, NULL);
                break;
        }
    }
 
    /* Now insert jb into result, unless we did it recursively */
    if (!is_null && !scalar_jsonb &&
        tcategory >= JSONTYPE_JSON && tcategory <= JSONTYPE_CAST)
    {
        /* 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;
 
        pushJsonbValue(result, WJB_BEGIN_ARRAY, &va);
        pushJsonbValue(result, WJB_ELEM, &jb);
        pushJsonbValue(result, WJB_END_ARRAY, NULL);
    }
    else
    {
        JsonbValue *o = &result->parseState->contVal;
 
        switch (o->type)
        {
            case jbvArray:
                pushJsonbValue(result, WJB_ELEM, &jb);
                break;
            case jbvObject:
                pushJsonbValue(result,
                               key_scalar ? WJB_KEY : WJB_VALUE,
                               &jb);
                break;
            default:
                elog(ERROR, "unexpected parent of nested structure");
        }
    }
}

References JsonSemAction::array_end, JsonSemAction::array_start, array_to_jsonb_internal(), Assert(), check_stack_depth(), checkStringLen(), composite_to_jsonb(), JsonbParseState::contVal, CStringGetDatum(), DatumGetBool(), DatumGetInt16(), DatumGetInt32(), DatumGetInt64(), DatumGetJsonbP(), DatumGetNumeric(), DatumGetTextPP, DirectFunctionCall1, DirectFunctionCall3, elog, ereport, errcode(), errmsg(), ERROR, float4_numeric(), float8_numeric(), freeJsonLexContext(), Int32GetDatum(), int64_to_numeric(), InvalidOid, 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(), JsonEncodeDateTime(), JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NUMERIC, JSONTYPE_TIMESTAMP, JSONTYPE_TIMESTAMPTZ, makeJsonLexContext(), numeric_in(), numeric_is_inf(), numeric_is_nan(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, ObjectIdGetDatum(), OidFunctionCall1, OidOutputFunctionCall(), JsonbInState::parseState, pg_parse_json_or_ereport, pushJsonbValue(), Jsonb::root, JsonSemAction::scalar, sem, JsonSemAction::semstate, type, JsonbValue::type, JsonbValue::val, val, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), 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(), datum_to_jsonb(), jsonb_agg_transfn_worker(), and jsonb_object_agg_transfn_worker().

jsonb_agg_finalfn()

Datum jsonb_agg_finalfn

(

PG_FUNCTION_ARGS

)

Definition at line 1581 of file jsonb.c.

{
    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);
 
    /*
     * The final function can be called more than once, so we must not change
     * the stored JsonbValue data structure.  Fortunately, the WJB_END_ARRAY
     * action will only change fields in the JsonbInState struct itself, so we
     * can simply invoke pushJsonbValue on a local copy of that.
     */
    result = arg->pstate;
 
    pushJsonbValue(&result, WJB_END_ARRAY, NULL);
 
    /* We expect result.parseState == NULL after closing the array */
    Assert(result.parseState == NULL);
 
    out = JsonbValueToJsonb(result.result);
 
    PG_RETURN_POINTER(out);
}

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

jsonb_agg_strict_transfn()

Datum jsonb_agg_strict_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1575 of file jsonb.c.

{
    return jsonb_agg_transfn_worker(fcinfo, true);
}

References jsonb_agg_transfn_worker().

jsonb_agg_transfn()

Datum jsonb_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1566 of file jsonb.c.

{
    return jsonb_agg_transfn_worker(fcinfo, false);
}

References jsonb_agg_transfn_worker().

jsonb_agg_transfn_worker()

static Datum jsonb_agg_transfn_worker ( FunctionCallInfo  fcinfo, bool  absent_on_null  )

static

Definition at line 1507 of file jsonb.c.

{
    MemoryContext aggcontext;
    JsonbAggState *state;
    Datum       val;
    JsonbInState *result;
 
    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")));
 
        state = MemoryContextAllocZero(aggcontext, sizeof(JsonbAggState));
        result = &state->pstate;
        result->outcontext = aggcontext;
        pushJsonbValue(result, WJB_BEGIN_ARRAY, NULL);
 
        json_categorize_type(arg_type, true, &state->val_category,
                             &state->val_output_func);
    }
    else
    {
        state = (JsonbAggState *) PG_GETARG_POINTER(0);
        result = &state->pstate;
    }
 
    if (absent_on_null && PG_ARGISNULL(1))
        PG_RETURN_POINTER(state);
 
    /*
     * We run this code in the normal function context, so that we don't leak
     * any cruft from datatype output functions and such into the aggcontext.
     * But the "result" JsonbValue will be constructed in aggcontext, so that
     * it remains available across calls.
     */
    val = PG_ARGISNULL(1) ? (Datum) 0 : PG_GETARG_DATUM(1);
 
    datum_to_jsonb_internal(val, PG_ARGISNULL(1), result, state->val_category,
                            state->val_output_func, false);
 
    PG_RETURN_POINTER(state);
}

References AggCheckCallContext(), datum_to_jsonb_internal(), elog, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, get_fn_expr_argtype(), InvalidOid, json_categorize_type(), MemoryContextAllocZero(), JsonbInState::outcontext, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), val, and WJB_BEGIN_ARRAY.

Referenced by jsonb_agg_strict_transfn(), and jsonb_agg_transfn().

jsonb_bool()

Datum jsonb_bool

(

PG_FUNCTION_ARGS

)

Definition at line 1848 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "boolean");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvBool)
        cannotCastJsonbValue(v.type, "boolean");
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_BOOL(v.val.boolean);
}

References cannotCastJsonbValue(), jbvBool, jbvNull, JsonbExtractScalar(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_BOOL, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_build_array()

Datum jsonb_build_array

(

PG_FUNCTION_ARGS

)

Definition at line 1274 of file jsonb.c.

{
    Datum      *args;
    bool       *nulls;
    Oid        *types;
 
    /* build argument values to build the object */
    int         nargs = extract_variadic_args(fcinfo, 0, true,
                                              &args, &types, &nulls);
 
    if (nargs < 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(jsonb_build_array_worker(nargs, args, nulls, types, false));
}

References generate_unaccent_rules::args, extract_variadic_args(), jsonb_build_array_worker(), PG_RETURN_DATUM, PG_RETURN_NULL, and types.

jsonb_build_array_noargs()

Datum jsonb_build_array_noargs

(

PG_FUNCTION_ARGS

)

Definition at line 1295 of file jsonb.c.

{
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_ARRAY, NULL);
    pushJsonbValue(&result, WJB_END_ARRAY, NULL);
 
    PG_RETURN_POINTER(JsonbValueToJsonb(result.result));
}

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

jsonb_build_array_worker()

Datum jsonb_build_array_worker	(	int	nargs,
		const Datum *	args,
		const bool *	nulls,
		const Oid *	types,
		bool	absent_on_null
	)

Definition at line 1247 of file jsonb.c.

{
    int         i;
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_ARRAY, NULL);
 
    for (i = 0; i < nargs; i++)
    {
        if (absent_on_null && nulls[i])
            continue;
 
        add_jsonb(args[i], nulls[i], &result, types[i], false);
    }
 
    pushJsonbValue(&result, WJB_END_ARRAY, NULL);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References add_jsonb(), generate_unaccent_rules::args, i, JsonbPGetDatum(), JsonbValueToJsonb(), pushJsonbValue(), JsonbInState::result, types, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

Referenced by ExecEvalJsonConstructor(), and jsonb_build_array().

jsonb_build_object()

Datum jsonb_build_object

(

PG_FUNCTION_ARGS

)

Definition at line 1214 of file jsonb.c.

{
    Datum      *args;
    bool       *nulls;
    Oid        *types;
 
    /* build argument values to build the object */
    int         nargs = extract_variadic_args(fcinfo, 0, true,
                                              &args, &types, &nulls);
 
    if (nargs < 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(jsonb_build_object_worker(nargs, args, nulls, types, false, false));
}

References generate_unaccent_rules::args, extract_variadic_args(), jsonb_build_object_worker(), PG_RETURN_DATUM, PG_RETURN_NULL, and types.

jsonb_build_object_noargs()

Datum jsonb_build_object_noargs

(

PG_FUNCTION_ARGS

)

Definition at line 1234 of file jsonb.c.

{
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_OBJECT, NULL);
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    PG_RETURN_POINTER(JsonbValueToJsonb(result.result));
}

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

jsonb_build_object_worker()

Datum jsonb_build_object_worker	(	int	nargs,
		const Datum *	args,
		const bool *	nulls,
		const Oid *	types,
		bool	absent_on_null,
		bool	unique_keys
	)

Definition at line 1162 of file jsonb.c.

{
    int         i;
    JsonbInState result;
 
    if (nargs % 2 != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument list must have even number of elements"),
        /* translator: %s is a SQL function name */
                 errhint("The arguments of %s must consist of alternating keys and values.",
                         "jsonb_build_object()")));
 
    memset(&result, 0, sizeof(JsonbInState));
 
    pushJsonbValue(&result, WJB_BEGIN_OBJECT, NULL);
    result.parseState->unique_keys = unique_keys;
    result.parseState->skip_nulls = absent_on_null;
 
    for (i = 0; i < nargs; i += 2)
    {
        /* process key */
        bool        skip;
 
        if (nulls[i])
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("argument %d: key must not be null", i + 1)));
 
        /* skip null values if absent_on_null */
        skip = absent_on_null && nulls[i + 1];
 
        /* we need to save skipped keys for the key uniqueness check */
        if (skip && !unique_keys)
            continue;
 
        add_jsonb(args[i], false, &result, types[i], true);
 
        /* process value */
        add_jsonb(args[i + 1], nulls[i + 1], &result, types[i + 1], false);
    }
 
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References add_jsonb(), generate_unaccent_rules::args, ereport, errcode(), errhint(), errmsg(), ERROR, i, JsonbPGetDatum(), JsonbValueToJsonb(), JsonbInState::parseState, pushJsonbValue(), JsonbInState::result, skip, JsonbParseState::skip_nulls, types, JsonbParseState::unique_keys, WJB_BEGIN_OBJECT, and WJB_END_OBJECT.

Referenced by ExecEvalJsonConstructor(), and jsonb_build_object().

jsonb_float4()

Datum jsonb_float4

(

PG_FUNCTION_ARGS

)

Definition at line 1982 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Datum       retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "real");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "real");
 
    retValue = DirectFunctionCall1(numeric_float4,
                                   NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_DATUM(retValue);
}

References cannotCastJsonbValue(), DirectFunctionCall1, jbvNull, jbvNumeric, JsonbExtractScalar(), numeric_float4(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_float8()

Datum jsonb_float8

(

PG_FUNCTION_ARGS

)

Definition at line 2009 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Datum       retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "double precision");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "double precision");
 
    retValue = DirectFunctionCall1(numeric_float8,
                                   NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_DATUM(retValue);
}

References cannotCastJsonbValue(), DirectFunctionCall1, jbvNull, jbvNumeric, JsonbExtractScalar(), numeric_float8(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_from_cstring()

static Datum jsonb_from_cstring ( char *  json, int  len, bool  unique_keys, Node *  escontext  )

inlinestatic

Definition at line 241 of file jsonb.c.

{
    JsonLexContext lex;
    JsonbInState state;
    JsonSemAction sem;
 
    memset(&state, 0, sizeof(state));
    memset(&sem, 0, sizeof(sem));
    makeJsonLexContextCstringLen(&lex, json, len, GetDatabaseEncoding(), true);
 
    state.unique_keys = unique_keys;
    state.escontext = escontext;
    sem.semstate = &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;
 
    if (!pg_parse_json_or_errsave(&lex, &sem, escontext))
        return (Datum) 0;
 
    /* after parsing, the result field has the composed jsonb structure */
    PG_RETURN_POINTER(JsonbValueToJsonb(state.result));
}

References JsonSemAction::array_end, JsonSemAction::array_start, GetDatabaseEncoding(), 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(), len, makeJsonLexContextCstringLen(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, pg_parse_json_or_errsave(), PG_RETURN_POINTER, JsonSemAction::scalar, sem, and JsonSemAction::semstate.

Referenced by jsonb_from_text(), jsonb_in(), and jsonb_recv().

jsonb_from_text()

Datum jsonb_from_text	(	text *	js,
		bool	unique_keys
	)

Definition at line 140 of file jsonb.c.

{
    return jsonb_from_cstring(VARDATA_ANY(js),
                              VARSIZE_ANY_EXHDR(js),
                              unique_keys,
                              NULL);
}

References jsonb_from_cstring(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by ExecEvalJsonConstructor().

jsonb_in()

Datum jsonb_in

(

PG_FUNCTION_ARGS

)

Definition at line 65 of file jsonb.c.

{
    char       *json = PG_GETARG_CSTRING(0);
 
    return jsonb_from_cstring(json, strlen(json), false, fcinfo->context);
}

References jsonb_from_cstring(), and PG_GETARG_CSTRING.

Referenced by ExecEvalJsonCoercion(), GetJsonBehaviorConst(), jsonb_set_lax(), JsonItemFromDatum(), and transformJsonBehavior().

jsonb_in_array_end()

static JsonParseErrorType jsonb_in_array_end ( void *  pstate )

static

Definition at line 314 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
 
    pushJsonbValue(_state, WJB_END_ARRAY, NULL);
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, pushJsonbValue(), and WJB_END_ARRAY.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_in_array_start()

static JsonParseErrorType jsonb_in_array_start ( void *  pstate )

static

Definition at line 304 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
 
    pushJsonbValue(_state, WJB_BEGIN_ARRAY, NULL);
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, pushJsonbValue(), and WJB_BEGIN_ARRAY.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_in_object_end()

static JsonParseErrorType jsonb_in_object_end ( void *  pstate )

static

Definition at line 294 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
 
    pushJsonbValue(_state, WJB_END_OBJECT, NULL);
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, pushJsonbValue(), and WJB_END_OBJECT.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_in_object_field_start()

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

static

Definition at line 324 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
    JsonbValue  v;
 
    Assert(fname != NULL);
    v.type = jbvString;
    v.val.string.len = strlen(fname);
    if (!checkStringLen(v.val.string.len, _state->escontext))
        return JSON_SEM_ACTION_FAILED;
    v.val.string.val = fname;
 
    pushJsonbValue(_state, WJB_KEY, &v);
 
    return JSON_SUCCESS;
}

References Assert(), checkStringLen(), JsonbInState::escontext, jbvString, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, pushJsonbValue(), JsonbValue::type, JsonbValue::val, and WJB_KEY.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_in_object_start()

static JsonParseErrorType jsonb_in_object_start ( void *  pstate )

static

Definition at line 283 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
 
    pushJsonbValue(_state, WJB_BEGIN_OBJECT, NULL);
    _state->parseState->unique_keys = _state->unique_keys;
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, JsonbInState::parseState, pushJsonbValue(), JsonbInState::unique_keys, JsonbParseState::unique_keys, and WJB_BEGIN_OBJECT.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_in_scalar()

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

static

Definition at line 372 of file jsonb.c.

{
    JsonbInState *_state = (JsonbInState *) pstate;
    JsonbValue  v;
    Datum       numd;
 
    switch (tokentype)
    {
 
        case JSON_TOKEN_STRING:
            Assert(token != NULL);
            v.type = jbvString;
            v.val.string.len = strlen(token);
            if (!checkStringLen(v.val.string.len, _state->escontext))
                return JSON_SEM_ACTION_FAILED;
            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;
            if (!DirectInputFunctionCallSafe(numeric_in, token,
                                             InvalidOid, -1,
                                             _state->escontext,
                                             &numd))
                return JSON_SEM_ACTION_FAILED;
            v.val.numeric = DatumGetNumeric(numd);
            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;
 
        pushJsonbValue(_state, WJB_BEGIN_ARRAY, &va);
        pushJsonbValue(_state, WJB_ELEM, &v);
        pushJsonbValue(_state, WJB_END_ARRAY, NULL);
    }
    else
    {
        JsonbValue *o = &_state->parseState->contVal;
 
        switch (o->type)
        {
            case jbvArray:
                pushJsonbValue(_state, WJB_ELEM, &v);
                break;
            case jbvObject:
                pushJsonbValue(_state, WJB_VALUE, &v);
                break;
            default:
                elog(ERROR, "unexpected parent of nested structure");
        }
    }
 
    return JSON_SUCCESS;
}

References Assert(), checkStringLen(), JsonbParseState::contVal, DatumGetNumeric(), DirectInputFunctionCallSafe(), elog, ERROR, JsonbInState::escontext, InvalidOid, jbvArray, jbvBool, jbvNull, jbvNumeric, jbvObject, jbvString, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, JSON_TOKEN_FALSE, JSON_TOKEN_NULL, JSON_TOKEN_NUMBER, JSON_TOKEN_STRING, JSON_TOKEN_TRUE, numeric_in(), JsonbInState::parseState, pushJsonbValue(), token, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_ELEM, WJB_END_ARRAY, and WJB_VALUE.

Referenced by datum_to_jsonb_internal(), and jsonb_from_cstring().

jsonb_int2()

Datum jsonb_int2

(

PG_FUNCTION_ARGS

)

Definition at line 1901 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Datum       retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "smallint");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "smallint");
 
    retValue = DirectFunctionCall1(numeric_int2,
                                   NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_DATUM(retValue);
}

References cannotCastJsonbValue(), DirectFunctionCall1, jbvNull, jbvNumeric, JsonbExtractScalar(), numeric_int2(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_int4()

Datum jsonb_int4

(

PG_FUNCTION_ARGS

)

Definition at line 1928 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Datum       retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "integer");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "integer");
 
    retValue = DirectFunctionCall1(numeric_int4,
                                   NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_DATUM(retValue);
}

References cannotCastJsonbValue(), DirectFunctionCall1, jbvNull, jbvNumeric, JsonbExtractScalar(), numeric_int4(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_int8()

Datum jsonb_int8

(

PG_FUNCTION_ARGS

)

Definition at line 1955 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Datum       retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "bigint");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "bigint");
 
    retValue = DirectFunctionCall1(numeric_int8,
                                   NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_DATUM(retValue);
}

References cannotCastJsonbValue(), DirectFunctionCall1, jbvNull, jbvNumeric, JsonbExtractScalar(), numeric_int8(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, PG_RETURN_NULL, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_numeric()

Datum jsonb_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1871 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    JsonbValue  v;
    Numeric     retValue;
 
    if (!JsonbExtractScalar(&in->root, &v))
        cannotCastJsonbValue(v.type, "numeric");
 
    if (v.type == jbvNull)
    {
        PG_FREE_IF_COPY(in, 0);
        PG_RETURN_NULL();
    }
 
    if (v.type != jbvNumeric)
        cannotCastJsonbValue(v.type, "numeric");
 
    /*
     * v.val.numeric points into jsonb body, so we need to make a copy to
     * return
     */
    retValue = DatumGetNumericCopy(NumericGetDatum(v.val.numeric));
 
    PG_FREE_IF_COPY(in, 0);
 
    PG_RETURN_NUMERIC(retValue);
}

References cannotCastJsonbValue(), DatumGetNumericCopy(), jbvNull, jbvNumeric, JsonbExtractScalar(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_NULL, PG_RETURN_NUMERIC, Jsonb::root, JsonbValue::type, and JsonbValue::val.

jsonb_object()

Datum jsonb_object

(

PG_FUNCTION_ARGS

)

Definition at line 1316 of file jsonb.c.

{
    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));
 
    pushJsonbValue(&result, 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_builtin(in_array, TEXTOID, &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;
 
        pushJsonbValue(&result, 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;
        }
 
        pushJsonbValue(&result, WJB_VALUE, &v);
    }
 
    pfree(in_datums);
    pfree(in_nulls);
 
close_object:
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    PG_RETURN_POINTER(JsonbValueToJsonb(result.result));
}

References ARR_DIMS, ARR_NDIM, deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), len, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::result, str, TextDatumGetCString, JsonbValue::type, JsonbValue::val, WJB_BEGIN_OBJECT, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

jsonb_object_agg_finalfn()

Datum jsonb_object_agg_finalfn

(

PG_FUNCTION_ARGS

)

Definition at line 1739 of file jsonb.c.

{
    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);
 
    /*
     * The final function can be called more than once, so we must not change
     * the stored JsonbValue data structure.  Fortunately, the WJB_END_OBJECT
     * action will only destructively change fields in the JsonbInState struct
     * itself, so we can simply invoke pushJsonbValue on a local copy of that.
     * (This technique results in running uniqueifyJsonbObject each time, but
     * for now we won't bother trying to avoid that.)
     */
    result = arg->pstate;
 
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    /* We expect result.parseState == NULL after closing the object */
    Assert(result.parseState == NULL);
 
    out = JsonbValueToJsonb(result.result);
 
    PG_RETURN_POINTER(out);
}

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

jsonb_object_agg_strict_transfn()

Datum jsonb_object_agg_strict_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1715 of file jsonb.c.

{
    return jsonb_object_agg_transfn_worker(fcinfo, true, false);
}

References jsonb_object_agg_transfn_worker().

jsonb_object_agg_transfn()

Datum jsonb_object_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1705 of file jsonb.c.

{
    return jsonb_object_agg_transfn_worker(fcinfo, false, false);
}

References jsonb_object_agg_transfn_worker().

jsonb_object_agg_transfn_worker()

static Datum jsonb_object_agg_transfn_worker ( FunctionCallInfo  fcinfo, bool  absent_on_null, bool  unique_keys  )

static

Definition at line 1614 of file jsonb.c.

{
    MemoryContext aggcontext;
    JsonbAggState *state;
    Datum       val;
    JsonbInState *result;
    bool        skip;
 
    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;
 
        state = MemoryContextAllocZero(aggcontext, sizeof(JsonbAggState));
        result = &state->pstate;
        result->outcontext = aggcontext;
        pushJsonbValue(result, WJB_BEGIN_OBJECT, NULL);
        result->parseState->unique_keys = unique_keys;
        result->parseState->skip_nulls = absent_on_null;
 
        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")));
 
        json_categorize_type(arg_type, true, &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")));
 
        json_categorize_type(arg_type, true, &state->val_category,
                             &state->val_output_func);
    }
    else
    {
        state = (JsonbAggState *) PG_GETARG_POINTER(0);
        result = &state->pstate;
    }
 
    if (PG_ARGISNULL(1))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("field name must not be null")));
 
    /*
     * Skip null values if absent_on_null unless key uniqueness check is
     * needed (because we must save keys in this case).
     */
    skip = absent_on_null && PG_ARGISNULL(2);
 
    if (skip && !unique_keys)
        PG_RETURN_POINTER(state);
 
    /*
     * We run this code in the normal function context, so that we don't leak
     * any cruft from datatype output functions and such into the aggcontext.
     * But the "result" JsonbValue will be constructed in aggcontext, so that
     * it remains available across calls.
     */
    val = PG_GETARG_DATUM(1);
 
    datum_to_jsonb_internal(val, false, result, state->key_category,
                            state->key_output_func, true);
 
    val = PG_ARGISNULL(2) ? (Datum) 0 : PG_GETARG_DATUM(2);
 
    datum_to_jsonb_internal(val, PG_ARGISNULL(2), result, state->val_category,
                            state->val_output_func, false);
 
    PG_RETURN_POINTER(state);
}

References AggCheckCallContext(), datum_to_jsonb_internal(), elog, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, get_fn_expr_argtype(), InvalidOid, json_categorize_type(), MemoryContextAllocZero(), JsonbInState::outcontext, JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), skip, JsonbParseState::skip_nulls, JsonbParseState::unique_keys, val, and WJB_BEGIN_OBJECT.

Referenced by jsonb_object_agg_strict_transfn(), jsonb_object_agg_transfn(), jsonb_object_agg_unique_strict_transfn(), and jsonb_object_agg_unique_transfn().

jsonb_object_agg_unique_strict_transfn()

Datum jsonb_object_agg_unique_strict_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1733 of file jsonb.c.

{
    return jsonb_object_agg_transfn_worker(fcinfo, true, true);
}

References jsonb_object_agg_transfn_worker().

jsonb_object_agg_unique_transfn()

Datum jsonb_object_agg_unique_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1724 of file jsonb.c.

{
    return jsonb_object_agg_transfn_worker(fcinfo, false, true);
}

References jsonb_object_agg_transfn_worker().

jsonb_object_two_arg()

Datum jsonb_object_two_arg

(

PG_FUNCTION_ARGS

)

Definition at line 1416 of file jsonb.c.

{
    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));
 
    pushJsonbValue(&result, 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_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
    deconstruct_array_builtin(val_array, TEXTOID, &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;
 
        pushJsonbValue(&result, 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;
        }
 
        pushJsonbValue(&result, WJB_VALUE, &v);
    }
 
    pfree(key_datums);
    pfree(key_nulls);
    pfree(val_datums);
    pfree(val_nulls);
 
close_object:
    pushJsonbValue(&result, WJB_END_OBJECT, NULL);
 
    PG_RETURN_POINTER(JsonbValueToJsonb(result.result));
}

References ARR_NDIM, deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), len, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::result, str, TextDatumGetCString, JsonbValue::type, JsonbValue::val, WJB_BEGIN_OBJECT, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

jsonb_out()

Datum jsonb_out

(

PG_FUNCTION_ARGS

)

Definition at line 100 of file jsonb.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    char       *out;
 
    out = JsonbToCString(NULL, &jb->root, VARSIZE(jb));
 
    PG_RETURN_CSTRING(out);
}

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

Referenced by ExecEvalJsonExprPath(), and ExecGetJsonValueItemString().

jsonb_put_escaped_value()

static void jsonb_put_escaped_value ( StringInfo  out, JsonbValue *  scalarVal  )

static

Definition at line 342 of file jsonb.c.

{
    switch (scalarVal->type)
    {
        case jbvNull:
            appendBinaryStringInfo(out, "null", 4);
            break;
        case jbvString:
            escape_json_with_len(out, 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");
    }
}

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

Referenced by JsonbToCStringWorker().

jsonb_recv()

Datum jsonb_recv

(

PG_FUNCTION_ARGS

)

Definition at line 81 of file jsonb.c.

{
    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, false, NULL);
}

References buf, elog, ERROR, jsonb_from_cstring(), PG_GETARG_POINTER, pq_getmsgint(), pq_getmsgtext(), and str.

jsonb_send()

Datum jsonb_send

(

PG_FUNCTION_ARGS

)

Definition at line 116 of file jsonb.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    StringInfoData buf;
    StringInfoData jtext;
    int         version = 1;
 
    initStringInfo(&jtext);
    (void) JsonbToCString(&jtext, &jb->root, VARSIZE(jb));
 
    pq_begintypsend(&buf);
    pq_sendint8(&buf, version);
    pq_sendtext(&buf, jtext.data, jtext.len);
    pfree(jtext.data);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, StringInfoData::data, initStringInfo(), JsonbToCString(), StringInfoData::len, pfree(), PG_GETARG_JSONB_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), pq_sendtext(), Jsonb::root, and VARSIZE().

jsonb_typeof()

Datum jsonb_typeof

(

PG_FUNCTION_ARGS

)

Definition at line 222 of file jsonb.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    const char *result = JsonbContainerTypeName(&in->root);
 
    PG_RETURN_TEXT_P(cstring_to_text(result));
}

References cstring_to_text(), JsonbContainerTypeName(), PG_GETARG_JSONB_P, PG_RETURN_TEXT_P, and Jsonb::root.

JsonbContainerTypeName()

static const char * JsonbContainerTypeName ( JsonbContainer *  jbc )

static

Definition at line 152 of file jsonb.c.

{
    JsonbValue  scalar;
 
    if (JsonbExtractScalar(jbc, &scalar))
        return JsonbTypeName(&scalar);
    else if (JsonContainerIsArray(jbc))
        return "array";
    else if (JsonContainerIsObject(jbc))
        return "object";
    else
    {
        elog(ERROR, "invalid jsonb container type: 0x%08x", jbc->header);
        return "unknown";
    }
}

References elog, ERROR, JsonbContainer::header, JsonbExtractScalar(), JsonbTypeName(), JsonContainerIsArray, and JsonContainerIsObject.

Referenced by jsonb_typeof(), and JsonbTypeName().

JsonbExtractScalar()

bool JsonbExtractScalar	(	JsonbContainer *	jbc,
		JsonbValue *	res
	)

Definition at line 1778 of file jsonb.c.

{
    JsonbIterator *it;
    JsonbIteratorToken tok PG_USED_FOR_ASSERTS_ONLY;
    JsonbValue  tmp;
 
    if (!JsonContainerIsArray(jbc) || !JsonContainerIsScalar(jbc))
    {
        /* inform caller about actual type of container */
        res->type = (JsonContainerIsArray(jbc)) ? jbvArray : jbvObject;
        return false;
    }
 
    /*
     * A root scalar is stored as an array of one element, so we get the array
     * and then its first (and only) member.
     */
    it = JsonbIteratorInit(jbc);
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_BEGIN_ARRAY);
    Assert(tmp.val.array.nElems == 1 && tmp.val.array.rawScalar);
 
    tok = JsonbIteratorNext(&it, res, true);
    Assert(tok == WJB_ELEM);
    Assert(IsAJsonbScalar(res));
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_END_ARRAY);
 
    tok = JsonbIteratorNext(&it, &tmp, true);
    Assert(tok == WJB_DONE);
 
    return true;
}

References Assert(), IsAJsonbScalar, jbvArray, jbvObject, JsonbIteratorInit(), JsonbIteratorNext(), JsonContainerIsArray, JsonContainerIsScalar, PG_USED_FOR_ASSERTS_ONLY, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_END_ARRAY.

Referenced by executeJsonPath(), jsonb_bool(), jsonb_float4(), jsonb_float8(), jsonb_int2(), jsonb_int4(), jsonb_int8(), jsonb_numeric(), JsonbContainerTypeName(), JsonbUnquote(), JsonItemFromDatum(), and JsonPathValue().

JsonbToCString()

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

Definition at line 466 of file jsonb.c.

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

References JsonbToCStringWorker().

Referenced by jsonb_get_element(), jsonb_out(), jsonb_send(), JsonbUnquote(), JsonbValueAsText(), and populate_scalar().

JsonbToCStringIndent()

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

Definition at line 475 of file jsonb.c.

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

References JsonbToCStringWorker().

Referenced by jsonb_pretty().

JsonbToCStringWorker()

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

static

Definition at line 484 of file jsonb.c.

{
    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;
}

References add_indent(), appendBinaryStringInfo(), appendStringInfoCharMacro, Assert(), StringInfoData::data, elog, enlargeStringInfo(), ERROR, jsonb_put_escaped_value(), JsonbIteratorInit(), JsonbIteratorNext(), makeStringInfo(), type, 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().

JsonbTypeName()

const char * JsonbTypeName

(

JsonbValue *

val

)

Definition at line 173 of file jsonb.c.

{
    switch (val->type)
    {
        case jbvBinary:
            return JsonbContainerTypeName(val->val.binary.data);
        case jbvObject:
            return "object";
        case jbvArray:
            return "array";
        case jbvNumeric:
            return "number";
        case jbvString:
            return "string";
        case jbvBool:
            return "boolean";
        case jbvNull:
            return "null";
        case jbvDatetime:
            switch (val->val.datetime.typid)
            {
                case DATEOID:
                    return "date";
                case TIMEOID:
                    return "time without time zone";
                case TIMETZOID:
                    return "time with time zone";
                case TIMESTAMPOID:
                    return "timestamp without time zone";
                case TIMESTAMPTZOID:
                    return "timestamp with time zone";
                default:
                    elog(ERROR, "unrecognized jsonb value datetime type: %d",
                         val->val.datetime.typid);
            }
            return "unknown";
        default:
            elog(ERROR, "unrecognized jsonb value type: %d", val->type);
            return "unknown";
    }
}

References elog, ERROR, jbvArray, jbvBinary, jbvBool, jbvDatetime, jbvNull, jbvNumeric, jbvObject, jbvString, JsonbContainerTypeName(), and val.

Referenced by executeItemOptUnwrapTarget(), and JsonbContainerTypeName().

JsonbUnquote()

char * JsonbUnquote

(

Jsonb *

jb

)

Definition at line 2039 of file jsonb.c.

{
    if (JB_ROOT_IS_SCALAR(jb))
    {
        JsonbValue  v;
 
        (void) JsonbExtractScalar(&jb->root, &v);
 
        if (v.type == jbvString)
            return pnstrdup(v.val.string.val, v.val.string.len);
        else if (v.type == jbvBool)
            return pstrdup(v.val.boolean ? "true" : "false");
        else if (v.type == jbvNumeric)
            return DatumGetCString(DirectFunctionCall1(numeric_out,
                                                       PointerGetDatum(v.val.numeric)));
        else if (v.type == jbvNull)
            return pstrdup("null");
        else
        {
            elog(ERROR, "unrecognized jsonb value type %d", v.type);
            return NULL;
        }
    }
    else
        return JsonbToCString(NULL, &jb->root, VARSIZE(jb));
}

References DatumGetCString(), DirectFunctionCall1, elog, ERROR, JB_ROOT_IS_SCALAR, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbExtractScalar(), JsonbToCString(), numeric_out(), pnstrdup(), PointerGetDatum(), pstrdup(), Jsonb::root, JsonbValue::type, JsonbValue::val, and VARSIZE().

Referenced by json_populate_type().

to_jsonb()

Datum to_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 1125 of file jsonb.c.

{
    Datum       val = PG_GETARG_DATUM(0);
    Oid         val_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
    JsonTypeCategory tcategory;
    Oid         outfuncoid;
 
    if (val_type == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("could not determine input data type")));
 
    json_categorize_type(val_type, true,
                         &tcategory, &outfuncoid);
 
    PG_RETURN_DATUM(datum_to_jsonb(val, tcategory, outfuncoid));
}

References datum_to_jsonb(), ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, json_categorize_type(), PG_GETARG_DATUM, PG_RETURN_DATUM, and val.

to_jsonb_is_immutable()

bool to_jsonb_is_immutable

(

Oid

typoid

)

Definition at line 1086 of file jsonb.c.

{
    JsonTypeCategory tcategory;
    Oid         outfuncoid;
 
    json_categorize_type(typoid, true, &tcategory, &outfuncoid);
 
    switch (tcategory)
    {
        case JSONTYPE_NULL:
        case JSONTYPE_BOOL:
        case JSONTYPE_JSON:
        case JSONTYPE_JSONB:
            return true;
 
        case JSONTYPE_DATE:
        case JSONTYPE_TIMESTAMP:
        case JSONTYPE_TIMESTAMPTZ:
            return false;
 
        case JSONTYPE_ARRAY:
            return false;       /* TODO recurse into elements */
 
        case JSONTYPE_COMPOSITE:
            return false;       /* TODO recurse into fields */
 
        case JSONTYPE_NUMERIC:
        case JSONTYPE_CAST:
        case JSONTYPE_OTHER:
            return func_volatile(outfuncoid) == PROVOLATILE_IMMUTABLE;
    }
 
    return false;               /* not reached */
}

References func_volatile(), json_categorize_type(), JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NULL, JSONTYPE_NUMERIC, JSONTYPE_OTHER, JSONTYPE_TIMESTAMP, and JSONTYPE_TIMESTAMPTZ.

Referenced by contain_mutable_functions_walker().