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

Include dependency graph for jsonb.c:

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

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)

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)

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)

Typedef Documentation

◆ JsonbAggState

typedef struct JsonbAggState JsonbAggState

◆ JsonbInState

typedef struct JsonbInState JsonbInState

Enumeration Type Documentation

◆ JsonbTypeCategory

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 40 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

◆ add_indent()

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

static

Definition at line 625 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 1129 of file jsonb.c.

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

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

Referenced by jsonb_build_array(), and jsonb_build_object().

◆ array_dim_to_jsonb()

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 977 of file jsonb.c.

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

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

Referenced by array_to_jsonb_internal().

◆ array_to_jsonb_internal()

static void array_to_jsonb_internal	(	Datum	array,
		JsonbInState *	result
	)

static

Definition at line 1009 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;
     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);
 }

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

Referenced by datum_to_jsonb().

◆ cannotCastJsonbValue()

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

static

Definition at line 1953 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 generate_unaccent_rules::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 288 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(), jsonb_in_object_field_start(), and jsonb_in_scalar().

◆ clone_parse_state()

static JsonbParseState * clone_parse_state ( JsonbParseState * state )

static

Definition at line 1493 of file jsonb.c.

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

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

Referenced by jsonb_agg_finalfn(), and jsonb_object_agg_finalfn().

◆ composite_to_jsonb()

static void composite_to_jsonb	(	Datum	composite,
		JsonbInState *	result
	)

static

Definition at line 1057 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;
  
     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);
 }

References attname, datum_to_jsonb(), DatumGetHeapTupleHeader, heap_getattr(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, InvalidOid, jbvString, jsonb_categorize_type(), JSONBTYPE_NULL, lookup_rowtype_tupdesc(), NameStr, TupleDescData::natts, 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().

◆ datum_to_jsonb()

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

static

Definition at line 754 of file jsonb.c.

 {
     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)
                     {
                         Datum       numd;
  
                         jb.type = jbvNumeric;
                         numd = DirectFunctionCall3(numeric_in,
                                                    CStringGetDatum(outputstr),
                                                    ObjectIdGetDatum(InvalidOid),
                                                    Int32GetDatum(-1));
                         jb.val.numeric = DatumGetNumeric(numd);
                         pfree(outputstr);
                     }
                     else
                     {
                         jb.type = jbvString;
                         jb.val.string.len = strlen(outputstr);
                         jb.val.string.val = outputstr;
                     }
                 }
                 break;
             case JSONBTYPE_DATE:
                 jb.type = jbvString;
                 jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                        DATEOID, NULL);
                 jb.val.string.len = strlen(jb.val.string.val);
                 break;
             case JSONBTYPE_TIMESTAMP:
                 jb.type = jbvString;
                 jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                        TIMESTAMPOID, NULL);
                 jb.val.string.len = strlen(jb.val.string.val);
                 break;
             case JSONBTYPE_TIMESTAMPTZ:
                 jb.type = jbvString;
                 jb.val.string.val = JsonEncodeDateTime(NULL, val,
                                                        TIMESTAMPTZOID, NULL);
                 jb.val.string.len = strlen(jb.val.string.val);
                 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_or_ereport(lex, &sem);
                 }
                 break;
             case JSONBTYPE_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)
                                 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 = strlen(outputstr);
                 (void) checkStringLen(jb.val.string.len, NULL);
                 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");
         }
     }
 }

References JsonSemAction::array_end, JsonSemAction::array_start, array_to_jsonb_internal(), Assert(), check_stack_depth(), checkStringLen(), composite_to_jsonb(), JsonbParseState::contVal, CStringGetDatum(), DatumGetBool(), DatumGetJsonbP(), DatumGetNumeric(), DatumGetTextPP, DirectFunctionCall3, elog(), ereport, errcode(), errmsg(), ERROR, Int32GetDatum(), 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(), JSONBTYPE_ARRAY, JSONBTYPE_BOOL, JSONBTYPE_COMPOSITE, JSONBTYPE_DATE, JSONBTYPE_JSON, JSONBTYPE_JSONB, JSONBTYPE_JSONCAST, JSONBTYPE_NUMERIC, JSONBTYPE_TIMESTAMP, JSONBTYPE_TIMESTAMPTZ, JsonEncodeDateTime(), makeJsonLexContext(), numeric_in(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, ObjectIdGetDatum(), OidFunctionCall1, OidOutputFunctionCall(), JsonbInState::parseState, pfree(), pg_parse_json_or_ereport, pushJsonbValue(), JsonbInState::res, Jsonb::root, JsonSemAction::scalar, JsonSemAction::semstate, generate_unaccent_rules::type, JsonbValue::type, JsonbValue::val, 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().

◆ jsonb_agg_finalfn()

Datum jsonb_agg_finalfn ( PG_FUNCTION_ARGS )

Definition at line 1643 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);
  
     /*
      * 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.
      */
     memset(&result, 0, sizeof(JsonbInState));
  
     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);
 }

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

◆ jsonb_agg_transfn()

Datum jsonb_agg_transfn ( PG_FUNCTION_ARGS )

Definition at line 1525 of file jsonb.c.

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

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(), numeric_uplus(), NumericGetDatum(), palloc(), palloc0(), JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, Jsonb::root, snprintf, generate_unaccent_rules::type, JsonbValue::type, JsonbValue::val, val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

◆ jsonb_bool()

Datum jsonb_bool ( PG_FUNCTION_ARGS )

Definition at line 1983 of file jsonb.c.

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

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

◆ jsonb_build_array()

Datum jsonb_build_array ( PG_FUNCTION_ARGS )

Definition at line 1249 of file jsonb.c.

 {
     int         nargs;
     int         i;
     JsonbInState result;
     Datum      *args;
     bool       *nulls;
     Oid        *types;
  
     /* build argument values to build the array */
     nargs = extract_variadic_args(fcinfo, 0, true, &args, &types, &nulls);
  
     if (nargs < 0)
         PG_RETURN_NULL();
  
     memset(&result, 0, sizeof(JsonbInState));
  
     result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_ARRAY, NULL);
  
     for (i = 0; i < nargs; i++)
         add_jsonb(args[i], nulls[i], &result, types[i], false);
  
     result.res = pushJsonbValue(&result.parseState, WJB_END_ARRAY, NULL);
  
     PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
 }

References add_jsonb(), generate_unaccent_rules::args, extract_variadic_args(), i, JsonbValueToJsonb(), JsonbInState::parseState, PG_RETURN_NULL, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, types, WJB_BEGIN_ARRAY, and WJB_END_ARRAY.

◆ jsonb_build_array_noargs()

Datum jsonb_build_array_noargs ( PG_FUNCTION_ARGS )

Definition at line 1280 of file jsonb.c.

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

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

◆ jsonb_build_object()

Datum jsonb_build_object ( PG_FUNCTION_ARGS )

Definition at line 1183 of file jsonb.c.

 {
     int         nargs;
     int         i;
     JsonbInState result;
     Datum      *args;
     bool       *nulls;
     Oid        *types;
  
     /* build argument values to build the object */
     nargs = extract_variadic_args(fcinfo, 0, true, &args, &types, &nulls);
  
     if (nargs < 0)
         PG_RETURN_NULL();
  
     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));
  
     result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
  
     for (i = 0; i < nargs; i += 2)
     {
         /* process key */
         if (nulls[i])
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("argument %d: key must not be null", i + 1)));
  
         add_jsonb(args[i], false, &result, types[i], true);
  
         /* process value */
         add_jsonb(args[i + 1], nulls[i + 1], &result, types[i + 1], false);
     }
  
     result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);
  
     PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
 }

References add_jsonb(), generate_unaccent_rules::args, ereport, errcode(), errhint(), errmsg(), ERROR, extract_variadic_args(), i, JsonbValueToJsonb(), JsonbInState::parseState, PG_RETURN_NULL, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, types, WJB_BEGIN_OBJECT, and WJB_END_OBJECT.

◆ jsonb_build_object_noargs()

Datum jsonb_build_object_noargs ( PG_FUNCTION_ARGS )

Definition at line 1233 of file jsonb.c.

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

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

◆ jsonb_categorize_type()

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

static

Definition at line 643 of file jsonb.c.

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

References COERCION_EXPLICIT, COERCION_PATH_FUNC, find_coercion_pathway(), FirstNormalObjectId, get_element_type(), getBaseType(), getTypeOutputInfo(), InvalidOid, JSONBTYPE_ARRAY, JSONBTYPE_BOOL, JSONBTYPE_COMPOSITE, JSONBTYPE_DATE, JSONBTYPE_JSON, JSONBTYPE_JSONB, JSONBTYPE_JSONCAST, JSONBTYPE_NUMERIC, JSONBTYPE_OTHER, JSONBTYPE_TIMESTAMP, JSONBTYPE_TIMESTAMPTZ, OidIsValid, 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().

◆ jsonb_float4()

Datum jsonb_float4 ( PG_FUNCTION_ARGS )

Definition at line 2072 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Datum       retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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, jbvNumeric, JsonbExtractScalar(), numeric_float4(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_float8()

Datum jsonb_float8 ( PG_FUNCTION_ARGS )

Definition at line 2090 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Datum       retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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, jbvNumeric, JsonbExtractScalar(), numeric_float8(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_from_cstring()

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

inlinestatic

Definition at line 260 of file jsonb.c.

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

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, and JsonSemAction::semstate.

Referenced by jsonb_in(), and jsonb_recv().

◆ jsonb_in()

Datum jsonb_in ( PG_FUNCTION_ARGS )

Definition at line 98 of file jsonb.c.

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

References jsonb_from_cstring(), and PG_GETARG_CSTRING.

Referenced by jsonb_set_lax().

◆ jsonb_in_array_end()

static JsonParseErrorType jsonb_in_array_end ( void * pstate )

static

Definition at line 331 of file jsonb.c.

 {
     JsonbInState *_state = (JsonbInState *) pstate;
  
     _state->res = pushJsonbValue(&_state->parseState, WJB_END_ARRAY, NULL);
  
     return JSON_SUCCESS;
 }

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

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

◆ jsonb_in_array_start()

static JsonParseErrorType jsonb_in_array_start ( void * pstate )

static

Definition at line 321 of file jsonb.c.

 {
     JsonbInState *_state = (JsonbInState *) pstate;
  
     _state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_ARRAY, NULL);
  
     return JSON_SUCCESS;
 }

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

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

◆ jsonb_in_object_end()

static JsonParseErrorType jsonb_in_object_end ( void * pstate )

static

Definition at line 311 of file jsonb.c.

 {
     JsonbInState *_state = (JsonbInState *) pstate;
  
     _state->res = pushJsonbValue(&_state->parseState, WJB_END_OBJECT, NULL);
  
     return JSON_SUCCESS;
 }

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

Referenced by datum_to_jsonb(), 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 341 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;
  
     _state->res = pushJsonbValue(&_state->parseState, WJB_KEY, &v);
  
     return JSON_SUCCESS;
 }

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

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

◆ jsonb_in_object_start()

static JsonParseErrorType jsonb_in_object_start ( void * pstate )

static

Definition at line 301 of file jsonb.c.

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

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

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

◆ jsonb_in_scalar()

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

static

Definition at line 389 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;
  
         _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");
         }
     }
  
     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(), JsonbInState::res, token, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_ELEM, WJB_END_ARRAY, and WJB_VALUE.

Referenced by datum_to_jsonb(), and jsonb_from_cstring().

◆ jsonb_int2()

Datum jsonb_int2 ( PG_FUNCTION_ARGS )

Definition at line 2018 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Datum       retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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, jbvNumeric, JsonbExtractScalar(), numeric_int2(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_int4()

Datum jsonb_int4 ( PG_FUNCTION_ARGS )

Definition at line 2036 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Datum       retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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, jbvNumeric, JsonbExtractScalar(), numeric_int4(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_int8()

Datum jsonb_int8 ( PG_FUNCTION_ARGS )

Definition at line 2054 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Datum       retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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, jbvNumeric, JsonbExtractScalar(), numeric_int8(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_DATUM, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_numeric()

Datum jsonb_numeric ( PG_FUNCTION_ARGS )

Definition at line 1997 of file jsonb.c.

 {
     Jsonb      *in = PG_GETARG_JSONB_P(0);
     JsonbValue  v;
     Numeric     retValue;
  
     if (!JsonbExtractScalar(&in->root, &v) || 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(), jbvNumeric, JsonbExtractScalar(), NumericGetDatum(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_RETURN_NUMERIC, Jsonb::root, JsonbValue::type, and JsonbValue::val.

◆ jsonb_object()

Datum jsonb_object ( PG_FUNCTION_ARGS )

Definition at line 1301 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));
  
     (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_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;
  
         (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));
 }

References ARR_DIMS, ARR_NDIM, deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), len, JsonbInState::parseState, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, generate_unaccent_rules::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 1875 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);
  
     /*
      * 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.
      */
     memset(&result, 0, sizeof(JsonbInState));
  
     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);
 }

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

◆ jsonb_object_agg_transfn()

Datum jsonb_object_agg_transfn ( PG_FUNCTION_ARGS )

Definition at line 1679 of file jsonb.c.

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

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(), numeric_uplus(), NumericGetDatum(), palloc(), palloc0(), JsonbInState::parseState, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, Jsonb::root, snprintf, generate_unaccent_rules::type, JsonbValue::type, JsonbValue::val, val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

◆ jsonb_object_two_arg()

Datum jsonb_object_two_arg ( PG_FUNCTION_ARGS )

Definition at line 1401 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));
  
     (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_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;
  
         (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));
 }

References ARR_NDIM, deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, i, jbvNull, jbvString, JsonbValueToJsonb(), len, JsonbInState::parseState, pfree(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::res, generate_unaccent_rules::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 133 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.

◆ jsonb_put_escaped_value()

static void jsonb_put_escaped_value	(	StringInfo	out,
		JsonbValue *	scalarVal
	)

static

Definition at line 359 of file jsonb.c.

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

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().

◆ jsonb_recv()

Datum jsonb_recv ( PG_FUNCTION_ARGS )

Definition at line 114 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, NULL);
 }

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

◆ jsonb_send()

Datum jsonb_send ( PG_FUNCTION_ARGS )

Definition at line 149 of file jsonb.c.

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

References buf, StringInfoData::data, JsonbToCString(), StringInfoData::len, makeStringInfo(), 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 241 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 171 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 1913 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, res, 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(), and JsonbContainerTypeName().

◆ JsonbToCString()

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

Definition at line 483 of file jsonb.c.

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

References JsonbToCStringWorker().

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

◆ JsonbToCStringIndent()

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

Definition at line 492 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 501 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(), generate_unaccent_rules::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 192 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().

◆ to_jsonb()

Datum to_jsonb ( PG_FUNCTION_ARGS )

Definition at line 1156 of file jsonb.c.

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

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, and val.

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

◆ JsonbAggState

◆ JsonbInState

Enumeration Type Documentation

◆ JsonbTypeCategory

Function Documentation

◆ add_indent()

◆ add_jsonb()

◆ array_dim_to_jsonb()

◆ array_to_jsonb_internal()

◆ cannotCastJsonbValue()

◆ checkStringLen()

◆ clone_parse_state()

◆ composite_to_jsonb()

◆ datum_to_jsonb()

◆ jsonb_agg_finalfn()

◆ jsonb_agg_transfn()

◆ jsonb_bool()

◆ jsonb_build_array()

◆ jsonb_build_array_noargs()

◆ jsonb_build_object()

◆ jsonb_build_object_noargs()

◆ jsonb_categorize_type()

◆ jsonb_float4()

◆ jsonb_float8()

◆ jsonb_from_cstring()

◆ jsonb_in()

◆ jsonb_in_array_end()

◆ jsonb_in_array_start()

◆ jsonb_in_object_end()

◆ jsonb_in_object_field_start()

◆ jsonb_in_object_start()

◆ jsonb_in_scalar()

◆ jsonb_int2()

◆ jsonb_int4()

◆ jsonb_int8()

◆ jsonb_numeric()

◆ jsonb_object()

◆ jsonb_object_agg_finalfn()

◆ jsonb_object_agg_transfn()

◆ jsonb_object_two_arg()

◆ jsonb_out()

◆ jsonb_put_escaped_value()

◆ jsonb_recv()

◆ jsonb_send()

◆ jsonb_typeof()

◆ JsonbContainerTypeName()

◆ JsonbExtractScalar()

◆ JsonbToCString()

◆ JsonbToCStringIndent()

◆ JsonbToCStringWorker()

◆ JsonbTypeName()

◆ to_jsonb()